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         /* year-2038 will overflow in case time_t is 32bit */
 158         if (time_ns / 1000000000 != (time_t)(time_ns / 1000000000)) {
 159             error_setg(errp, "Time %" PRId64 " is too large", time_ns);
 160             return;
 161         }
 162
 163         tv.tv_sec = time_ns / 1000000000;
 164         tv.tv_usec = (time_ns % 1000000000) / 1000;
 165
 166         ret = settimeofday(&tv, NULL);
 167         if (ret < 0) {
 168             error_setg_errno(errp, errno, "Failed to set time to guest");
 169             return;
 170         }
 171     }
 172
 173     /* Now, if user has passed a time to set and the system time is set, we
 174      * just need to synchronize the hardware clock. However, if no time was
 175      * passed, user is requesting the opposite: set the system time from the
 176      * hardware clock (RTC). */
 177     pid = fork();
 178     if (pid == 0) {
 179         setsid();
 180         reopen_fd_to_null(0);
 181         reopen_fd_to_null(1);
 182         reopen_fd_to_null(2);
 183
 184         /* Use '/sbin/hwclock -w' to set RTC from the system time,
 185          * or '/sbin/hwclock -s' to set the system time from RTC. */
 186         execle("/sbin/hwclock", "hwclock", has_time ? "-w" : "-s",
 187                NULL, environ);
 188         _exit(EXIT_FAILURE);
 189     } else if (pid < 0) {
 190         error_setg_errno(errp, errno, "failed to create child process");
 191         return;
 192     }
 193
 194     ga_wait_child(pid, &status, &local_err);
 195     if (local_err) {
 196         error_propagate(errp, local_err);
 197         return;
 198     }
 199
 200     if (!WIFEXITED(status)) {
 201         error_setg(errp, "child process has terminated abnormally");
 202         return;
 203     }
 204
 205     if (WEXITSTATUS(status)) {
 206         error_setg(errp, "hwclock failed to set hardware clock to system time");
 207         return;
 208     }
 209 }
 210
 211 typedef struct GuestFileHandle {
 212     uint64_t id;
 213     FILE *fh;
 214     QTAILQ_ENTRY(GuestFileHandle) next;
 215 } GuestFileHandle;
 216
 217 static struct {
 218     QTAILQ_HEAD(, GuestFileHandle) filehandles;
 219 } guest_file_state;
 220
 221 static int64_t guest_file_handle_add(FILE *fh, Error **errp)
 222 {
 223     GuestFileHandle *gfh;
 224     int64_t handle;
 225
 226     handle = ga_get_fd_handle(ga_state, errp);
 227     if (handle < 0) {
 228         return -1;
 229     }
 230
 231     gfh = g_malloc0(sizeof(GuestFileHandle));
 232     gfh->id = handle;
 233     gfh->fh = fh;
 234     QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);
 235
 236     return handle;
 237 }
 238
 239 static GuestFileHandle *guest_file_handle_find(int64_t id, Error **errp)
 240 {
 241     GuestFileHandle *gfh;
 242
 243     QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next)
 244     {
 245         if (gfh->id == id) {
 246             return gfh;
 247         }
 248     }
 249
 250     error_setg(errp, "handle '%" PRId64 "' has not been found", id);
 251     return NULL;
 252 }
 253
 254 typedef const char * const ccpc;
 255
 256 #ifndef O_BINARY
 257 #define O_BINARY 0
 258 #endif
 259
 260 /* http://pubs.opengroup.org/onlinepubs/9699919799/functions/fopen.html */
 261 static const struct {
 262     ccpc *forms;
 263     int oflag_base;
 264 } guest_file_open_modes[] = {
 265     { (ccpc[]){ "r",          NULL }, O_RDONLY                                 },
 266     { (ccpc[]){ "rb",         NULL }, O_RDONLY                      | O_BINARY },
 267     { (ccpc[]){ "w",          NULL }, O_WRONLY | O_CREAT | O_TRUNC             },
 268     { (ccpc[]){ "wb",         NULL }, O_WRONLY | O_CREAT | O_TRUNC  | O_BINARY },
 269     { (ccpc[]){ "a",          NULL }, O_WRONLY | O_CREAT | O_APPEND            },
 270     { (ccpc[]){ "ab",         NULL }, O_WRONLY | O_CREAT | O_APPEND | O_BINARY },
 271     { (ccpc[]){ "r+",         NULL }, O_RDWR                                   },
 272     { (ccpc[]){ "rb+", "r+b", NULL }, O_RDWR                        | O_BINARY },
 273     { (ccpc[]){ "w+",         NULL }, O_RDWR   | O_CREAT | O_TRUNC             },
 274     { (ccpc[]){ "wb+", "w+b", NULL }, O_RDWR   | O_CREAT | O_TRUNC  | O_BINARY },
 275     { (ccpc[]){ "a+",         NULL }, O_RDWR   | O_CREAT | O_APPEND            },
 276     { (ccpc[]){ "ab+", "a+b", NULL }, O_RDWR   | O_CREAT | O_APPEND | O_BINARY }
 277 };
 278
 279 static int
 280 find_open_flag(const char *mode_str, Error **errp)
 281 {
 282     unsigned mode;
 283
 284     for (mode = 0; mode < ARRAY_SIZE(guest_file_open_modes); ++mode) {
 285         ccpc *form;
 286
 287         form = guest_file_open_modes[mode].forms;
 288         while (*form != NULL && strcmp(*form, mode_str) != 0) {
 289             ++form;
 290         }
 291         if (*form != NULL) {
 292             break;
 293         }
 294     }
 295
 296     if (mode == ARRAY_SIZE(guest_file_open_modes)) {
 297         error_setg(errp, "invalid file open mode '%s'", mode_str);
 298         return -1;
 299     }
 300     return guest_file_open_modes[mode].oflag_base | O_NOCTTY | O_NONBLOCK;
 301 }
 302
 303 #define DEFAULT_NEW_FILE_MODE (S_IRUSR | S_IWUSR | \
 304                                S_IRGRP | S_IWGRP | \
 305                                S_IROTH | S_IWOTH)
 306
 307 static FILE *
 308 safe_open_or_create(const char *path, const char *mode, Error **errp)
 309 {
 310     Error *local_err = NULL;
 311     int oflag;
 312
 313     oflag = find_open_flag(mode, &local_err);
 314     if (local_err == NULL) {
 315         int fd;
 316
 317         /* If the caller wants / allows creation of a new file, we implement it
 318          * with a two step process: open() + (open() / fchmod()).
 319          *
 320          * First we insist on creating the file exclusively as a new file. If
 321          * that succeeds, we're free to set any file-mode bits on it. (The
 322          * motivation is that we want to set those file-mode bits independently
 323          * of the current umask.)
 324          *
 325          * If the exclusive creation fails because the file already exists
 326          * (EEXIST is not possible for any other reason), we just attempt to
 327          * open the file, but in this case we won't be allowed to change the
 328          * file-mode bits on the preexistent file.
 329          *
 330          * The pathname should never disappear between the two open()s in
 331          * practice. If it happens, then someone very likely tried to race us.
 332          * In this case just go ahead and report the ENOENT from the second
 333          * open() to the caller.
 334          *
 335          * If the caller wants to open a preexistent file, then the first
 336          * open() is decisive and its third argument is ignored, and the second
 337          * open() and the fchmod() are never called.
 338          */
 339         fd = open(path, oflag | ((oflag & O_CREAT) ? O_EXCL : 0), 0);
 340         if (fd == -1 && errno == EEXIST) {
 341             oflag &= ~(unsigned)O_CREAT;
 342             fd = open(path, oflag);
 343         }
 344
 345         if (fd == -1) {
 346             error_setg_errno(&local_err, errno, "failed to open file '%s' "
 347                              "(mode: '%s')", path, mode);
 348         } else {
 349             qemu_set_cloexec(fd);
 350
 351             if ((oflag & O_CREAT) && fchmod(fd, DEFAULT_NEW_FILE_MODE) == -1) {
 352                 error_setg_errno(&local_err, errno, "failed to set permission "
 353                                  "0%03o on new file '%s' (mode: '%s')",
 354                                  (unsigned)DEFAULT_NEW_FILE_MODE, path, mode);
 355             } else {
 356                 FILE *f;
 357
 358                 f = fdopen(fd, mode);
 359                 if (f == NULL) {
 360                     error_setg_errno(&local_err, errno, "failed to associate "
 361                                      "stdio stream with file descriptor %d, "
 362                                      "file '%s' (mode: '%s')", fd, path, mode);
 363                 } else {
 364                     return f;
 365                 }
 366             }
 367
 368             close(fd);
 369             if (oflag & O_CREAT) {
 370                 unlink(path);
 371             }
 372         }
 373     }
 374
 375     error_propagate(errp, local_err);
 376     return NULL;
 377 }
 378
 379 int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode,
 380                             Error **errp)
 381 {
 382     FILE *fh;
 383     Error *local_err = NULL;
 384     int fd;
 385     int64_t ret = -1, handle;
 386
 387     if (!has_mode) {
 388         mode = "r";
 389     }
 390     slog("guest-file-open called, filepath: %s, mode: %s", path, mode);
 391     fh = safe_open_or_create(path, mode, &local_err);
 392     if (local_err != NULL) {
 393         error_propagate(errp, local_err);
 394         return -1;
 395     }
 396
 397     /* set fd non-blocking to avoid common use cases (like reading from a
 398      * named pipe) from hanging the agent
 399      */
 400     fd = fileno(fh);
 401     ret = fcntl(fd, F_GETFL);
 402     ret = fcntl(fd, F_SETFL, ret | O_NONBLOCK);
 403     if (ret == -1) {
 404         error_setg_errno(errp, errno, "failed to make file '%s' non-blocking",
 405                          path);
 406         fclose(fh);
 407         return -1;
 408     }
 409
 410     handle = guest_file_handle_add(fh, errp);
 411     if (handle < 0) {
 412         fclose(fh);
 413         return -1;
 414     }
 415
 416     slog("guest-file-open, handle: %" PRId64, handle);
 417     return handle;
 418 }
 419
 420 void qmp_guest_file_close(int64_t handle, Error **errp)
 421 {
 422     GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
 423     int ret;
 424
 425     slog("guest-file-close called, handle: %" PRId64, handle);
 426     if (!gfh) {
 427         return;
 428     }
 429
 430     ret = fclose(gfh->fh);
 431     if (ret == EOF) {
 432         error_setg_errno(errp, errno, "failed to close handle");
 433         return;
 434     }
 435
 436     QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next);
 437     g_free(gfh);
 438 }
 439
 440 struct GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count,
 441                                           int64_t count, Error **errp)
 442 {
 443     GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
 444     GuestFileRead *read_data = NULL;
 445     guchar *buf;
 446     FILE *fh;
 447     size_t read_count;
 448
 449     if (!gfh) {
 450         return NULL;
 451     }
 452
 453     if (!has_count) {
 454         count = QGA_READ_COUNT_DEFAULT;
 455     } else if (count < 0) {
 456         error_setg(errp, "value '%" PRId64 "' is invalid for argument count",
 457                    count);
 458         return NULL;
 459     }
 460
 461     fh = gfh->fh;
 462     buf = g_malloc0(count+1);
 463     read_count = fread(buf, 1, count, fh);
 464     if (ferror(fh)) {
 465         error_setg_errno(errp, errno, "failed to read file");
 466         slog("guest-file-read failed, handle: %" PRId64, handle);
 467     } else {
 468         buf[read_count] = 0;
 469         read_data = g_malloc0(sizeof(GuestFileRead));
 470         read_data->count = read_count;
 471         read_data->eof = feof(fh);
 472         if (read_count) {
 473             read_data->buf_b64 = g_base64_encode(buf, read_count);
 474         }
 475     }
 476     g_free(buf);
 477     clearerr(fh);
 478
 479     return read_data;
 480 }
 481
 482 GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
 483                                      bool has_count, int64_t count,
 484                                      Error **errp)
 485 {
 486     GuestFileWrite *write_data = NULL;
 487     guchar *buf;
 488     gsize buf_len;
 489     int write_count;
 490     GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
 491     FILE *fh;
 492
 493     if (!gfh) {
 494         return NULL;
 495     }
 496
 497     fh = gfh->fh;
 498     buf = g_base64_decode(buf_b64, &buf_len);
 499
 500     if (!has_count) {
 501         count = buf_len;
 502     } else if (count < 0 || count > buf_len) {
 503         error_setg(errp, "value '%" PRId64 "' is invalid for argument count",
 504                    count);
 505         g_free(buf);
 506         return NULL;
 507     }
 508
 509     write_count = fwrite(buf, 1, count, fh);
 510     if (ferror(fh)) {
 511         error_setg_errno(errp, errno, "failed to write to file");
 512         slog("guest-file-write failed, handle: %" PRId64, handle);
 513     } else {
 514         write_data = g_malloc0(sizeof(GuestFileWrite));
 515         write_data->count = write_count;
 516         write_data->eof = feof(fh);
 517     }
 518     g_free(buf);
 519     clearerr(fh);
 520
 521     return write_data;
 522 }
 523
 524 struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
 525                                           int64_t whence, Error **errp)
 526 {
 527     GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
 528     GuestFileSeek *seek_data = NULL;
 529     FILE *fh;
 530     int ret;
 531
 532     if (!gfh) {
 533         return NULL;
 534     }
 535
 536     fh = gfh->fh;
 537     ret = fseek(fh, offset, whence);
 538     if (ret == -1) {
 539         error_setg_errno(errp, errno, "failed to seek file");
 540     } else {
 541         seek_data = g_new0(GuestFileSeek, 1);
 542         seek_data->position = ftell(fh);
 543         seek_data->eof = feof(fh);
 544     }
 545     clearerr(fh);
 546
 547     return seek_data;
 548 }
 549
 550 void qmp_guest_file_flush(int64_t handle, Error **errp)
 551 {
 552     GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
 553     FILE *fh;
 554     int ret;
 555
 556     if (!gfh) {
 557         return;
 558     }
 559
 560     fh = gfh->fh;
 561     ret = fflush(fh);
 562     if (ret == EOF) {
 563         error_setg_errno(errp, errno, "failed to flush file");
 564     }
 565 }
 566
 567 static void guest_file_init(void)
 568 {
 569     QTAILQ_INIT(&guest_file_state.filehandles);
 570 }
 571
 572 /* linux-specific implementations. avoid this if at all possible. */
 573 #if defined(__linux__)
 574
 575 #if defined(CONFIG_FSFREEZE) || defined(CONFIG_FSTRIM)
 576 typedef struct FsMount {
 577     char *dirname;
 578     char *devtype;
 579     unsigned int devmajor, devminor;
 580     QTAILQ_ENTRY(FsMount) next;
 581 } FsMount;
 582
 583 typedef QTAILQ_HEAD(FsMountList, FsMount) FsMountList;
 584
 585 static void free_fs_mount_list(FsMountList *mounts)
 586 {
 587      FsMount *mount, *temp;
 588
 589      if (!mounts) {
 590          return;
 591      }
 592
 593      QTAILQ_FOREACH_SAFE(mount, mounts, next, temp) {
 594          QTAILQ_REMOVE(mounts, mount, next);
 595          g_free(mount->dirname);
 596          g_free(mount->devtype);
 597          g_free(mount);
 598      }
 599 }
 600
 601 static int dev_major_minor(const char *devpath,
 602                            unsigned int *devmajor, unsigned int *devminor)
 603 {
 604     struct stat st;
 605
 606     *devmajor = 0;
 607     *devminor = 0;
 608
 609     if (stat(devpath, &st) < 0) {
 610         slog("failed to stat device file '%s': %s", devpath, strerror(errno));
 611         return -1;
 612     }
 613     if (S_ISDIR(st.st_mode)) {
 614         /* It is bind mount */
 615         return -2;
 616     }
 617     if (S_ISBLK(st.st_mode)) {
 618         *devmajor = major(st.st_rdev);
 619         *devminor = minor(st.st_rdev);
 620         return 0;
 621     }
 622     return -1;
 623 }
 624
 625 /*
 626  * Walk the mount table and build a list of local file systems
 627  */
 628 static void build_fs_mount_list_from_mtab(FsMountList *mounts, Error **errp)
 629 {
 630     struct mntent *ment;
 631     FsMount *mount;
 632     char const *mtab = "/proc/self/mounts";
 633     FILE *fp;
 634     unsigned int devmajor, devminor;
 635
 636     fp = setmntent(mtab, "r");
 637     if (!fp) {
 638         error_setg(errp, "failed to open mtab file: '%s'", mtab);
 639         return;
 640     }
 641
 642     while ((ment = getmntent(fp))) {
 643         /*
 644          * An entry which device name doesn't start with a '/' is
 645          * either a dummy file system or a network file system.
 646          * Add special handling for smbfs and cifs as is done by
 647          * coreutils as well.
 648          */
 649         if ((ment->mnt_fsname[0] != '/') ||
 650             (strcmp(ment->mnt_type, "smbfs") == 0) ||
 651             (strcmp(ment->mnt_type, "cifs") == 0)) {
 652             continue;
 653         }
 654         if (dev_major_minor(ment->mnt_fsname, &devmajor, &devminor) == -2) {
 655             /* Skip bind mounts */
 656             continue;
 657         }
 658
 659         mount = g_malloc0(sizeof(FsMount));
 660         mount->dirname = g_strdup(ment->mnt_dir);
 661         mount->devtype = g_strdup(ment->mnt_type);
 662         mount->devmajor = devmajor;
 663         mount->devminor = devminor;
 664
 665         QTAILQ_INSERT_TAIL(mounts, mount, next);
 666     }
 667
 668     endmntent(fp);
 669 }
 670
 671 static void decode_mntname(char *name, int len)
 672 {
 673     int i, j = 0;
 674     for (i = 0; i <= len; i++) {
 675         if (name[i] != '\\') {
 676             name[j++] = name[i];
 677         } else if (name[i + 1] == '\\') {
 678             name[j++] = '\\';
 679             i++;
 680         } else if (name[i + 1] >= '0' && name[i + 1] <= '3' &&
 681                    name[i + 2] >= '0' && name[i + 2] <= '7' &&
 682                    name[i + 3] >= '0' && name[i + 3] <= '7') {
 683             name[j++] = (name[i + 1] - '0') * 64 +
 684                         (name[i + 2] - '0') * 8 +
 685                         (name[i + 3] - '0');
 686             i += 3;
 687         } else {
 688             name[j++] = name[i];
 689         }
 690     }
 691 }
 692
 693 static void build_fs_mount_list(FsMountList *mounts, Error **errp)
 694 {
 695     FsMount *mount;
 696     char const *mountinfo = "/proc/self/mountinfo";
 697     FILE *fp;
 698     char *line = NULL, *dash;
 699     size_t n;
 700     char check;
 701     unsigned int devmajor, devminor;
 702     int ret, dir_s, dir_e, type_s, type_e, dev_s, dev_e;
 703
 704     fp = fopen(mountinfo, "r");
 705     if (!fp) {
 706         build_fs_mount_list_from_mtab(mounts, errp);
 707         return;
 708     }
 709
 710     while (getline(&line, &n, fp) != -1) {
 711         ret = sscanf(line, "%*u %*u %u:%u %*s %n%*s%n%c",
 712                      &devmajor, &devminor, &dir_s, &dir_e, &check);
 713         if (ret < 3) {
 714             continue;
 715         }
 716         dash = strstr(line + dir_e, " - ");
 717         if (!dash) {
 718             continue;
 719         }
 720         ret = sscanf(dash, " - %n%*s%n %n%*s%n%c",
 721                      &type_s, &type_e, &dev_s, &dev_e, &check);
 722         if (ret < 1) {
 723             continue;
 724         }
 725         line[dir_e] = 0;
 726         dash[type_e] = 0;
 727         dash[dev_e] = 0;
 728         decode_mntname(line + dir_s, dir_e - dir_s);
 729         decode_mntname(dash + dev_s, dev_e - dev_s);
 730         if (devmajor == 0) {
 731             /* btrfs reports major number = 0 */
 732             if (strcmp("btrfs", dash + type_s) != 0 ||
 733                 dev_major_minor(dash + dev_s, &devmajor, &devminor) < 0) {
 734                 continue;
 735             }
 736         }
 737
 738         mount = g_malloc0(sizeof(FsMount));
 739         mount->dirname = g_strdup(line + dir_s);
 740         mount->devtype = g_strdup(dash + type_s);
 741         mount->devmajor = devmajor;
 742         mount->devminor = devminor;
 743
 744         QTAILQ_INSERT_TAIL(mounts, mount, next);
 745     }
 746     free(line);
 747
 748     fclose(fp);
 749 }
 750 #endif
 751
 752 #if defined(CONFIG_FSFREEZE)
 753
 754 static char *get_pci_driver(char const *syspath, int pathlen, Error **errp)
 755 {
 756     char *path;
 757     char *dpath;
 758     char *driver = NULL;
 759     char buf[PATH_MAX];
 760     ssize_t len;
 761
 762     path = g_strndup(syspath, pathlen);
 763     dpath = g_strdup_printf("%s/driver", path);
 764     len = readlink(dpath, buf, sizeof(buf) - 1);
 765     if (len != -1) {
 766         buf[len] = 0;
 767         driver = g_strdup(basename(buf));
 768     }
 769     g_free(dpath);
 770     g_free(path);
 771     return driver;
 772 }
 773
 774 static int compare_uint(const void *_a, const void *_b)
 775 {
 776     unsigned int a = *(unsigned int *)_a;
 777     unsigned int b = *(unsigned int *)_b;
 778
 779     return a < b ? -1 : a > b ? 1 : 0;
 780 }
 781
 782 /* Walk the specified sysfs and build a sorted list of host or ata numbers */
 783 static int build_hosts(char const *syspath, char const *host, bool ata,
 784                        unsigned int *hosts, int hosts_max, Error **errp)
 785 {
 786     char *path;
 787     DIR *dir;
 788     struct dirent *entry;
 789     int i = 0;
 790
 791     path = g_strndup(syspath, host - syspath);
 792     dir = opendir(path);
 793     if (!dir) {
 794         error_setg_errno(errp, errno, "opendir(\"%s\")", path);
 795         g_free(path);
 796         return -1;
 797     }
 798
 799     while (i < hosts_max) {
 800         entry = readdir(dir);
 801         if (!entry) {
 802             break;
 803         }
 804         if (ata && sscanf(entry->d_name, "ata%d", hosts + i) == 1) {
 805             ++i;
 806         } else if (!ata && sscanf(entry->d_name, "host%d", hosts + i) == 1) {
 807             ++i;
 808         }
 809     }
 810
 811     qsort(hosts, i, sizeof(hosts[0]), compare_uint);
 812
 813     g_free(path);
 814     closedir(dir);
 815     return i;
 816 }
 817
 818 /* Store disk device info specified by @sysfs into @fs */
 819 static void build_guest_fsinfo_for_real_device(char const *syspath,
 820                                                GuestFilesystemInfo *fs,
 821                                                Error **errp)
 822 {
 823     unsigned int pci[4], host, hosts[8], tgt[3];
 824     int i, nhosts = 0, pcilen;
 825     GuestDiskAddress *disk;
 826     GuestPCIAddress *pciaddr;
 827     GuestDiskAddressList *list = NULL;
 828     bool has_ata = false, has_host = false, has_tgt = false;
 829     char *p, *q, *driver = NULL;
 830
 831     p = strstr(syspath, "/devices/pci");
 832     if (!p || sscanf(p + 12, "%*x:%*x/%x:%x:%x.%x%n",
 833                      pci, pci + 1, pci + 2, pci + 3, &pcilen) < 4) {
 834         g_debug("only pci device is supported: sysfs path \"%s\"", syspath);
 835         return;
 836     }
 837
 838     driver = get_pci_driver(syspath, (p + 12 + pcilen) - syspath, errp);
 839     if (!driver) {
 840         goto cleanup;
 841     }
 842
 843     p = strstr(syspath, "/target");
 844     if (p && sscanf(p + 7, "%*u:%*u:%*u/%*u:%u:%u:%u",
 845                     tgt, tgt + 1, tgt + 2) == 3) {
 846         has_tgt = true;
 847     }
 848
 849     p = strstr(syspath, "/ata");
 850     if (p) {
 851         q = p + 4;
 852         has_ata = true;
 853     } else {
 854         p = strstr(syspath, "/host");
 855         q = p + 5;
 856     }
 857     if (p && sscanf(q, "%u", &host) == 1) {
 858         has_host = true;
 859         nhosts = build_hosts(syspath, p, has_ata, hosts,
 860                              sizeof(hosts) / sizeof(hosts[0]), errp);
 861         if (nhosts < 0) {
 862             goto cleanup;
 863         }
 864     }
 865
 866     pciaddr = g_malloc0(sizeof(*pciaddr));
 867     pciaddr->domain = pci[0];
 868     pciaddr->bus = pci[1];
 869     pciaddr->slot = pci[2];
 870     pciaddr->function = pci[3];
 871
 872     disk = g_malloc0(sizeof(*disk));
 873     disk->pci_controller = pciaddr;
 874
 875     list = g_malloc0(sizeof(*list));
 876     list->value = disk;
 877
 878     if (strcmp(driver, "ata_piix") == 0) {
 879         /* a host per ide bus, target*:0:<unit>:0 */
 880         if (!has_host || !has_tgt) {
 881             g_debug("invalid sysfs path '%s' (driver '%s')", syspath, driver);
 882             goto cleanup;
 883         }
 884         for (i = 0; i < nhosts; i++) {
 885             if (host == hosts[i]) {
 886                 disk->bus_type = GUEST_DISK_BUS_TYPE_IDE;
 887                 disk->bus = i;
 888                 disk->unit = tgt[1];
 889                 break;
 890             }
 891         }
 892         if (i >= nhosts) {
 893             g_debug("no host for '%s' (driver '%s')", syspath, driver);
 894             goto cleanup;
 895         }
 896     } else if (strcmp(driver, "sym53c8xx") == 0) {
 897         /* scsi(LSI Logic): target*:0:<unit>:0 */
 898         if (!has_tgt) {
 899             g_debug("invalid sysfs path '%s' (driver '%s')", syspath, driver);
 900             goto cleanup;
 901         }
 902         disk->bus_type = GUEST_DISK_BUS_TYPE_SCSI;
 903         disk->unit = tgt[1];
 904     } else if (strcmp(driver, "virtio-pci") == 0) {
 905         if (has_tgt) {
 906             /* virtio-scsi: target*:0:0:<unit> */
 907             disk->bus_type = GUEST_DISK_BUS_TYPE_SCSI;
 908             disk->unit = tgt[2];
 909         } else {
 910             /* virtio-blk: 1 disk per 1 device */
 911             disk->bus_type = GUEST_DISK_BUS_TYPE_VIRTIO;
 912         }
 913     } else if (strcmp(driver, "ahci") == 0) {
 914         /* ahci: 1 host per 1 unit */
 915         if (!has_host || !has_tgt) {
 916             g_debug("invalid sysfs path '%s' (driver '%s')", syspath, driver);
 917             goto cleanup;
 918         }
 919         for (i = 0; i < nhosts; i++) {
 920             if (host == hosts[i]) {
 921                 disk->unit = i;
 922                 disk->bus_type = GUEST_DISK_BUS_TYPE_SATA;
 923                 break;
 924             }
 925         }
 926         if (i >= nhosts) {
 927             g_debug("no host for '%s' (driver '%s')", syspath, driver);
 928             goto cleanup;
 929         }
 930     } else {
 931         g_debug("unknown driver '%s' (sysfs path '%s')", driver, syspath);
 932         goto cleanup;
 933     }
 934
 935     list->next = fs->disk;
 936     fs->disk = list;
 937     g_free(driver);
 938     return;
 939
 940 cleanup:
 941     if (list) {
 942         qapi_free_GuestDiskAddressList(list);
 943     }
 944     g_free(driver);
 945 }
 946
 947 static void build_guest_fsinfo_for_device(char const *devpath,
 948                                           GuestFilesystemInfo *fs,
 949                                           Error **errp);
 950
 951 /* Store a list of slave devices of virtual volume specified by @syspath into
 952  * @fs */
 953 static void build_guest_fsinfo_for_virtual_device(char const *syspath,
 954                                                   GuestFilesystemInfo *fs,
 955                                                   Error **errp)
 956 {
 957     DIR *dir;
 958     char *dirpath;
 959     struct dirent *entry;
 960
 961     dirpath = g_strdup_printf("%s/slaves", syspath);
 962     dir = opendir(dirpath);
 963     if (!dir) {
 964         error_setg_errno(errp, errno, "opendir(\"%s\")", dirpath);
 965         g_free(dirpath);
 966         return;
 967     }
 968
 969     for (;;) {
 970         errno = 0;
 971         entry = readdir(dir);
 972         if (entry == NULL) {
 973             if (errno) {
 974                 error_setg_errno(errp, errno, "readdir(\"%s\")", dirpath);
 975             }
 976             break;
 977         }
 978
 979         if (entry->d_type == DT_LNK) {
 980             char *path;
 981
 982             g_debug(" slave device '%s'", entry->d_name);
 983             path = g_strdup_printf("%s/slaves/%s", syspath, entry->d_name);
 984             build_guest_fsinfo_for_device(path, fs, errp);
 985             g_free(path);
 986
 987             if (*errp) {
 988                 break;
 989             }
 990         }
 991     }
 992
 993     g_free(dirpath);
 994     closedir(dir);
 995 }
 996
 997 /* Dispatch to functions for virtual/real device */
 998 static void build_guest_fsinfo_for_device(char const *devpath,
 999                                           GuestFilesystemInfo *fs,
1000                                           Error **errp)
1001 {
1002     char *syspath = realpath(devpath, NULL);
1003
1004     if (!syspath) {
1005         error_setg_errno(errp, errno, "realpath(\"%s\")", devpath);
1006         return;
1007     }
1008
1009     if (!fs->name) {
1010         fs->name = g_strdup(basename(syspath));
1011     }
1012
1013     g_debug("  parse sysfs path '%s'", syspath);
1014
1015     if (strstr(syspath, "/devices/virtual/block/")) {
1016         build_guest_fsinfo_for_virtual_device(syspath, fs, errp);
1017     } else {
1018         build_guest_fsinfo_for_real_device(syspath, fs, errp);
1019     }
1020
1021     free(syspath);
1022 }
1023
1024 /* Return a list of the disk device(s)' info which @mount lies on */
1025 static GuestFilesystemInfo *build_guest_fsinfo(struct FsMount *mount,
1026                                                Error **errp)
1027 {
1028     GuestFilesystemInfo *fs = g_malloc0(sizeof(*fs));
1029     char *devpath = g_strdup_printf("/sys/dev/block/%u:%u",
1030                                     mount->devmajor, mount->devminor);
1031
1032     fs->mountpoint = g_strdup(mount->dirname);
1033     fs->type = g_strdup(mount->devtype);
1034     build_guest_fsinfo_for_device(devpath, fs, errp);
1035
1036     g_free(devpath);
1037     return fs;
1038 }
1039
1040 GuestFilesystemInfoList *qmp_guest_get_fsinfo(Error **errp)
1041 {
1042     FsMountList mounts;
1043     struct FsMount *mount;
1044     GuestFilesystemInfoList *new, *ret = NULL;
1045     Error *local_err = NULL;
1046
1047     QTAILQ_INIT(&mounts);
1048     build_fs_mount_list(&mounts, &local_err);
1049     if (local_err) {
1050         error_propagate(errp, local_err);
1051         return NULL;
1052     }
1053
1054     QTAILQ_FOREACH(mount, &mounts, next) {
1055         g_debug("Building guest fsinfo for '%s'", mount->dirname);
1056
1057         new = g_malloc0(sizeof(*ret));
1058         new->value = build_guest_fsinfo(mount, &local_err);
1059         new->next = ret;
1060         ret = new;
1061         if (local_err) {
1062             error_propagate(errp, local_err);
1063             qapi_free_GuestFilesystemInfoList(ret);
1064             ret = NULL;
1065             break;
1066         }
1067     }
1068
1069     free_fs_mount_list(&mounts);
1070     return ret;
1071 }
1072
1073
1074 typedef enum {
1075     FSFREEZE_HOOK_THAW = 0,
1076     FSFREEZE_HOOK_FREEZE,
1077 } FsfreezeHookArg;
1078
1079 static const char *fsfreeze_hook_arg_string[] = {
1080     "thaw",
1081     "freeze",
1082 };
1083
1084 static void execute_fsfreeze_hook(FsfreezeHookArg arg, Error **errp)
1085 {
1086     int status;
1087     pid_t pid;
1088     const char *hook;
1089     const char *arg_str = fsfreeze_hook_arg_string[arg];
1090     Error *local_err = NULL;
1091
1092     hook = ga_fsfreeze_hook(ga_state);
1093     if (!hook) {
1094         return;
1095     }
1096     if (access(hook, X_OK) != 0) {
1097         error_setg_errno(errp, errno, "can't access fsfreeze hook '%s'", hook);
1098         return;
1099     }
1100
1101     slog("executing fsfreeze hook with arg '%s'", arg_str);
1102     pid = fork();
1103     if (pid == 0) {
1104         setsid();
1105         reopen_fd_to_null(0);
1106         reopen_fd_to_null(1);
1107         reopen_fd_to_null(2);
1108
1109         execle(hook, hook, arg_str, NULL, environ);
1110         _exit(EXIT_FAILURE);
1111     } else if (pid < 0) {
1112         error_setg_errno(errp, errno, "failed to create child process");
1113         return;
1114     }
1115
1116     ga_wait_child(pid, &status, &local_err);
1117     if (local_err) {
1118         error_propagate(errp, local_err);
1119         return;
1120     }
1121
1122     if (!WIFEXITED(status)) {
1123         error_setg(errp, "fsfreeze hook has terminated abnormally");
1124         return;
1125     }
1126
1127     status = WEXITSTATUS(status);
1128     if (status) {
1129         error_setg(errp, "fsfreeze hook has failed with status %d", status);
1130         return;
1131     }
1132 }
1133
1134 /*
1135  * Return status of freeze/thaw
1136  */
1137 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp)
1138 {
1139     if (ga_is_frozen(ga_state)) {
1140         return GUEST_FSFREEZE_STATUS_FROZEN;
1141     }
1142
1143     return GUEST_FSFREEZE_STATUS_THAWED;
1144 }
1145
1146 int64_t qmp_guest_fsfreeze_freeze(Error **errp)
1147 {
1148     return qmp_guest_fsfreeze_freeze_list(false, NULL, errp);
1149 }
1150
1151 /*
1152  * Walk list of mounted file systems in the guest, and freeze the ones which
1153  * are real local file systems.
1154  */
1155 int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints,
1156                                        strList *mountpoints,
1157                                        Error **errp)
1158 {
1159     int ret = 0, i = 0;
1160     strList *list;
1161     FsMountList mounts;
1162     struct FsMount *mount;
1163     Error *local_err = NULL;
1164     int fd;
1165
1166     slog("guest-fsfreeze called");
1167
1168     execute_fsfreeze_hook(FSFREEZE_HOOK_FREEZE, &local_err);
1169     if (local_err) {
1170         error_propagate(errp, local_err);
1171         return -1;
1172     }
1173
1174     QTAILQ_INIT(&mounts);
1175     build_fs_mount_list(&mounts, &local_err);
1176     if (local_err) {
1177         error_propagate(errp, local_err);
1178         return -1;
1179     }
1180
1181     /* cannot risk guest agent blocking itself on a write in this state */
1182     ga_set_frozen(ga_state);
1183
1184     QTAILQ_FOREACH_REVERSE(mount, &mounts, FsMountList, next) {
1185         /* To issue fsfreeze in the reverse order of mounts, check if the
1186          * mount is listed in the list here */
1187         if (has_mountpoints) {
1188             for (list = mountpoints; list; list = list->next) {
1189                 if (strcmp(list->value, mount->dirname) == 0) {
1190                     break;
1191                 }
1192             }
1193             if (!list) {
1194                 continue;
1195             }
1196         }
1197
1198         fd = qemu_open(mount->dirname, O_RDONLY);
1199         if (fd == -1) {
1200             error_setg_errno(errp, errno, "failed to open %s", mount->dirname);
1201             goto error;
1202         }
1203
1204         /* we try to cull filesytems we know won't work in advance, but other
1205          * filesytems may not implement fsfreeze for less obvious reasons.
1206          * these will report EOPNOTSUPP. we simply ignore these when tallying
1207          * the number of frozen filesystems.
1208          *
1209          * any other error means a failure to freeze a filesystem we
1210          * expect to be freezable, so return an error in those cases
1211          * and return system to thawed state.
1212          */
1213         ret = ioctl(fd, FIFREEZE);
1214         if (ret == -1) {
1215             if (errno != EOPNOTSUPP) {
1216                 error_setg_errno(errp, errno, "failed to freeze %s",
1217                                  mount->dirname);
1218                 close(fd);
1219                 goto error;
1220             }
1221         } else {
1222             i++;
1223         }
1224         close(fd);
1225     }
1226
1227     free_fs_mount_list(&mounts);
1228     return i;
1229
1230 error:
1231     free_fs_mount_list(&mounts);
1232     qmp_guest_fsfreeze_thaw(NULL);
1233     return 0;
1234 }
1235
1236 /*
1237  * Walk list of frozen file systems in the guest, and thaw them.
1238  */
1239 int64_t qmp_guest_fsfreeze_thaw(Error **errp)
1240 {
1241     int ret;
1242     FsMountList mounts;
1243     FsMount *mount;
1244     int fd, i = 0, logged;
1245     Error *local_err = NULL;
1246
1247     QTAILQ_INIT(&mounts);
1248     build_fs_mount_list(&mounts, &local_err);
1249     if (local_err) {
1250         error_propagate(errp, local_err);
1251         return 0;
1252     }
1253
1254     QTAILQ_FOREACH(mount, &mounts, next) {
1255         logged = false;
1256         fd = qemu_open(mount->dirname, O_RDONLY);
1257         if (fd == -1) {
1258             continue;
1259         }
1260         /* we have no way of knowing whether a filesystem was actually unfrozen
1261          * as a result of a successful call to FITHAW, only that if an error
1262          * was returned the filesystem was *not* unfrozen by that particular
1263          * call.
1264          *
1265          * since multiple preceding FIFREEZEs require multiple calls to FITHAW
1266          * to unfreeze, continuing issuing FITHAW until an error is returned,
1267          * in which case either the filesystem is in an unfreezable state, or,
1268          * more likely, it was thawed previously (and remains so afterward).
1269          *
1270          * also, since the most recent successful call is the one that did
1271          * the actual unfreeze, we can use this to provide an accurate count
1272          * of the number of filesystems unfrozen by guest-fsfreeze-thaw, which
1273          * may * be useful for determining whether a filesystem was unfrozen
1274          * during the freeze/thaw phase by a process other than qemu-ga.
1275          */
1276         do {
1277             ret = ioctl(fd, FITHAW);
1278             if (ret == 0 && !logged) {
1279                 i++;
1280                 logged = true;
1281             }
1282         } while (ret == 0);
1283         close(fd);
1284     }
1285
1286     ga_unset_frozen(ga_state);
1287     free_fs_mount_list(&mounts);
1288
1289     execute_fsfreeze_hook(FSFREEZE_HOOK_THAW, errp);
1290
1291     return i;
1292 }
1293
1294 static void guest_fsfreeze_cleanup(void)
1295 {
1296     Error *err = NULL;
1297
1298     if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) {
1299         qmp_guest_fsfreeze_thaw(&err);
1300         if (err) {
1301             slog("failed to clean up frozen filesystems: %s",
1302                  error_get_pretty(err));
1303             error_free(err);
1304         }
1305     }
1306 }
1307 #endif /* CONFIG_FSFREEZE */
1308
1309 #if defined(CONFIG_FSTRIM)
1310 /*
1311  * Walk list of mounted file systems in the guest, and trim them.
1312  */
1313 void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
1314 {
1315     int ret = 0;
1316     FsMountList mounts;
1317     struct FsMount *mount;
1318     int fd;
1319     Error *local_err = NULL;
1320     struct fstrim_range r = {
1321         .start = 0,
1322         .len = -1,
1323         .minlen = has_minimum ? minimum : 0,
1324     };
1325
1326     slog("guest-fstrim called");
1327
1328     QTAILQ_INIT(&mounts);
1329     build_fs_mount_list(&mounts, &local_err);
1330     if (local_err) {
1331         error_propagate(errp, local_err);
1332         return;
1333     }
1334
1335     QTAILQ_FOREACH(mount, &mounts, next) {
1336         fd = qemu_open(mount->dirname, O_RDONLY);
1337         if (fd == -1) {
1338             error_setg_errno(errp, errno, "failed to open %s", mount->dirname);
1339             goto error;
1340         }
1341
1342         /* We try to cull filesytems we know won't work in advance, but other
1343          * filesytems may not implement fstrim for less obvious reasons.  These
1344          * will report EOPNOTSUPP; we simply ignore these errors.  Any other
1345          * error means an unexpected error, so return it in those cases.  In
1346          * some other cases ENOTTY will be reported (e.g. CD-ROMs).
1347          */
1348         ret = ioctl(fd, FITRIM, &r);
1349         if (ret == -1) {
1350             if (errno != ENOTTY && errno != EOPNOTSUPP) {
1351                 error_setg_errno(errp, errno, "failed to trim %s",
1352                                  mount->dirname);
1353                 close(fd);
1354                 goto error;
1355             }
1356         }
1357         close(fd);
1358     }
1359
1360 error:
1361     free_fs_mount_list(&mounts);
1362 }
1363 #endif /* CONFIG_FSTRIM */
1364
1365
1366 #define LINUX_SYS_STATE_FILE "/sys/power/state"
1367 #define SUSPEND_SUPPORTED 0
1368 #define SUSPEND_NOT_SUPPORTED 1
1369
1370 static void bios_supports_mode(const char *pmutils_bin, const char *pmutils_arg,
1371                                const char *sysfile_str, Error **errp)
1372 {
1373     Error *local_err = NULL;
1374     char *pmutils_path;
1375     pid_t pid;
1376     int status;
1377
1378     pmutils_path = g_find_program_in_path(pmutils_bin);
1379
1380     pid = fork();
1381     if (!pid) {
1382         char buf[32]; /* hopefully big enough */
1383         ssize_t ret;
1384         int fd;
1385
1386         setsid();
1387         reopen_fd_to_null(0);
1388         reopen_fd_to_null(1);
1389         reopen_fd_to_null(2);
1390
1391         if (pmutils_path) {
1392             execle(pmutils_path, pmutils_bin, pmutils_arg, NULL, environ);
1393         }
1394
1395         /*
1396          * If we get here either pm-utils is not installed or execle() has
1397          * failed. Let's try the manual method if the caller wants it.
1398          */
1399
1400         if (!sysfile_str) {
1401             _exit(SUSPEND_NOT_SUPPORTED);
1402         }
1403
1404         fd = open(LINUX_SYS_STATE_FILE, O_RDONLY);
1405         if (fd < 0) {
1406             _exit(SUSPEND_NOT_SUPPORTED);
1407         }
1408
1409         ret = read(fd, buf, sizeof(buf)-1);
1410         if (ret <= 0) {
1411             _exit(SUSPEND_NOT_SUPPORTED);
1412         }
1413         buf[ret] = '\0';
1414
1415         if (strstr(buf, sysfile_str)) {
1416             _exit(SUSPEND_SUPPORTED);
1417         }
1418
1419         _exit(SUSPEND_NOT_SUPPORTED);
1420     } else if (pid < 0) {
1421         error_setg_errno(errp, errno, "failed to create child process");
1422         goto out;
1423     }
1424
1425     ga_wait_child(pid, &status, &local_err);
1426     if (local_err) {
1427         error_propagate(errp, local_err);
1428         goto out;
1429     }
1430
1431     if (!WIFEXITED(status)) {
1432         error_setg(errp, "child process has terminated abnormally");
1433         goto out;
1434     }
1435
1436     switch (WEXITSTATUS(status)) {
1437     case SUSPEND_SUPPORTED:
1438         goto out;
1439     case SUSPEND_NOT_SUPPORTED:
1440         error_setg(errp,
1441                    "the requested suspend mode is not supported by the guest");
1442         goto out;
1443     default:
1444         error_setg(errp,
1445                    "the helper program '%s' returned an unexpected exit status"
1446                    " code (%d)", pmutils_path, WEXITSTATUS(status));
1447         goto out;
1448     }
1449
1450 out:
1451     g_free(pmutils_path);
1452 }
1453
1454 static void guest_suspend(const char *pmutils_bin, const char *sysfile_str,
1455                           Error **errp)
1456 {
1457     Error *local_err = NULL;
1458     char *pmutils_path;
1459     pid_t pid;
1460     int status;
1461
1462     pmutils_path = g_find_program_in_path(pmutils_bin);
1463
1464     pid = fork();
1465     if (pid == 0) {
1466         /* child */
1467         int fd;
1468
1469         setsid();
1470         reopen_fd_to_null(0);
1471         reopen_fd_to_null(1);
1472         reopen_fd_to_null(2);
1473
1474         if (pmutils_path) {
1475             execle(pmutils_path, pmutils_bin, NULL, environ);
1476         }
1477
1478         /*
1479          * If we get here either pm-utils is not installed or execle() has
1480          * failed. Let's try the manual method if the caller wants it.
1481          */
1482
1483         if (!sysfile_str) {
1484             _exit(EXIT_FAILURE);
1485         }
1486
1487         fd = open(LINUX_SYS_STATE_FILE, O_WRONLY);
1488         if (fd < 0) {
1489             _exit(EXIT_FAILURE);
1490         }
1491
1492         if (write(fd, sysfile_str, strlen(sysfile_str)) < 0) {
1493             _exit(EXIT_FAILURE);
1494         }
1495
1496         _exit(EXIT_SUCCESS);
1497     } else if (pid < 0) {
1498         error_setg_errno(errp, errno, "failed to create child process");
1499         goto out;
1500     }
1501
1502     ga_wait_child(pid, &status, &local_err);
1503     if (local_err) {
1504         error_propagate(errp, local_err);
1505         goto out;
1506     }
1507
1508     if (!WIFEXITED(status)) {
1509         error_setg(errp, "child process has terminated abnormally");
1510         goto out;
1511     }
1512
1513     if (WEXITSTATUS(status)) {
1514         error_setg(errp, "child process has failed to suspend");
1515         goto out;
1516     }
1517
1518 out:
1519     g_free(pmutils_path);
1520 }
1521
1522 void qmp_guest_suspend_disk(Error **errp)
1523 {
1524     Error *local_err = NULL;
1525
1526     bios_supports_mode("pm-is-supported", "--hibernate", "disk", &local_err);
1527     if (local_err) {
1528         error_propagate(errp, local_err);
1529         return;
1530     }
1531
1532     guest_suspend("pm-hibernate", "disk", errp);
1533 }
1534
1535 void qmp_guest_suspend_ram(Error **errp)
1536 {
1537     Error *local_err = NULL;
1538
1539     bios_supports_mode("pm-is-supported", "--suspend", "mem", &local_err);
1540     if (local_err) {
1541         error_propagate(errp, local_err);
1542         return;
1543     }
1544
1545     guest_suspend("pm-suspend", "mem", errp);
1546 }
1547
1548 void qmp_guest_suspend_hybrid(Error **errp)
1549 {
1550     Error *local_err = NULL;
1551
1552     bios_supports_mode("pm-is-supported", "--suspend-hybrid", NULL,
1553                        &local_err);
1554     if (local_err) {
1555         error_propagate(errp, local_err);
1556         return;
1557     }
1558
1559     guest_suspend("pm-suspend-hybrid", NULL, errp);
1560 }
1561
1562 static GuestNetworkInterfaceList *
1563 guest_find_interface(GuestNetworkInterfaceList *head,
1564                      const char *name)
1565 {
1566     for (; head; head = head->next) {
1567         if (strcmp(head->value->name, name) == 0) {
1568             break;
1569         }
1570     }
1571
1572     return head;
1573 }
1574
1575 /*
1576  * Build information about guest interfaces
1577  */
1578 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
1579 {
1580     GuestNetworkInterfaceList *head = NULL, *cur_item = NULL;
1581     struct ifaddrs *ifap, *ifa;
1582
1583     if (getifaddrs(&ifap) < 0) {
1584         error_setg_errno(errp, errno, "getifaddrs failed");
1585         goto error;
1586     }
1587
1588     for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
1589         GuestNetworkInterfaceList *info;
1590         GuestIpAddressList **address_list = NULL, *address_item = NULL;
1591         char addr4[INET_ADDRSTRLEN];
1592         char addr6[INET6_ADDRSTRLEN];
1593         int sock;
1594         struct ifreq ifr;
1595         unsigned char *mac_addr;
1596         void *p;
1597
1598         g_debug("Processing %s interface", ifa->ifa_name);
1599
1600         info = guest_find_interface(head, ifa->ifa_name);
1601
1602         if (!info) {
1603             info = g_malloc0(sizeof(*info));
1604             info->value = g_malloc0(sizeof(*info->value));
1605             info->value->name = g_strdup(ifa->ifa_name);
1606
1607             if (!cur_item) {
1608                 head = cur_item = info;
1609             } else {
1610                 cur_item->next = info;
1611                 cur_item = info;
1612             }
1613         }
1614
1615         if (!info->value->has_hardware_address &&
1616             ifa->ifa_flags & SIOCGIFHWADDR) {
1617             /* we haven't obtained HW address yet */
1618             sock = socket(PF_INET, SOCK_STREAM, 0);
1619             if (sock == -1) {
1620                 error_setg_errno(errp, errno, "failed to create socket");
1621                 goto error;
1622             }
1623
1624             memset(&ifr, 0, sizeof(ifr));
1625             pstrcpy(ifr.ifr_name, IF_NAMESIZE, info->value->name);
1626             if (ioctl(sock, SIOCGIFHWADDR, &ifr) == -1) {
1627                 error_setg_errno(errp, errno,
1628                                  "failed to get MAC address of %s",
1629                                  ifa->ifa_name);
1630                 close(sock);
1631                 goto error;
1632             }
1633
1634             close(sock);
1635             mac_addr = (unsigned char *) &ifr.ifr_hwaddr.sa_data;
1636
1637             info->value->hardware_address =
1638                 g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x",
1639                                 (int) mac_addr[0], (int) mac_addr[1],
1640                                 (int) mac_addr[2], (int) mac_addr[3],
1641                                 (int) mac_addr[4], (int) mac_addr[5]);
1642
1643             info->value->has_hardware_address = true;
1644         }
1645
1646         if (ifa->ifa_addr &&
1647             ifa->ifa_addr->sa_family == AF_INET) {
1648             /* interface with IPv4 address */
1649             p = &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
1650             if (!inet_ntop(AF_INET, p, addr4, sizeof(addr4))) {
1651                 error_setg_errno(errp, errno, "inet_ntop failed");
1652                 goto error;
1653             }
1654
1655             address_item = g_malloc0(sizeof(*address_item));
1656             address_item->value = g_malloc0(sizeof(*address_item->value));
1657             address_item->value->ip_address = g_strdup(addr4);
1658             address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4;
1659
1660             if (ifa->ifa_netmask) {
1661                 /* Count the number of set bits in netmask.
1662                  * This is safe as '1' and '0' cannot be shuffled in netmask. */
1663                 p = &((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr;
1664                 address_item->value->prefix = ctpop32(((uint32_t *) p)[0]);
1665             }
1666         } else if (ifa->ifa_addr &&
1667                    ifa->ifa_addr->sa_family == AF_INET6) {
1668             /* interface with IPv6 address */
1669             p = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr;
1670             if (!inet_ntop(AF_INET6, p, addr6, sizeof(addr6))) {
1671                 error_setg_errno(errp, errno, "inet_ntop failed");
1672                 goto error;
1673             }
1674
1675             address_item = g_malloc0(sizeof(*address_item));
1676             address_item->value = g_malloc0(sizeof(*address_item->value));
1677             address_item->value->ip_address = g_strdup(addr6);
1678             address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6;
1679
1680             if (ifa->ifa_netmask) {
1681                 /* Count the number of set bits in netmask.
1682                  * This is safe as '1' and '0' cannot be shuffled in netmask. */
1683                 p = &((struct sockaddr_in6 *)ifa->ifa_netmask)->sin6_addr;
1684                 address_item->value->prefix =
1685                     ctpop32(((uint32_t *) p)[0]) +
1686                     ctpop32(((uint32_t *) p)[1]) +
1687                     ctpop32(((uint32_t *) p)[2]) +
1688                     ctpop32(((uint32_t *) p)[3]);
1689             }
1690         }
1691
1692         if (!address_item) {
1693             continue;
1694         }
1695
1696         address_list = &info->value->ip_addresses;
1697
1698         while (*address_list && (*address_list)->next) {
1699             address_list = &(*address_list)->next;
1700         }
1701
1702         if (!*address_list) {
1703             *address_list = address_item;
1704         } else {
1705             (*address_list)->next = address_item;
1706         }
1707
1708         info->value->has_ip_addresses = true;
1709
1710
1711     }
1712
1713     freeifaddrs(ifap);
1714     return head;
1715
1716 error:
1717     freeifaddrs(ifap);
1718     qapi_free_GuestNetworkInterfaceList(head);
1719     return NULL;
1720 }
1721
1722 #define SYSCONF_EXACT(name, errp) sysconf_exact((name), #name, (errp))
1723
1724 static long sysconf_exact(int name, const char *name_str, Error **errp)
1725 {
1726     long ret;
1727
1728     errno = 0;
1729     ret = sysconf(name);
1730     if (ret == -1) {
1731         if (errno == 0) {
1732             error_setg(errp, "sysconf(%s): value indefinite", name_str);
1733         } else {
1734             error_setg_errno(errp, errno, "sysconf(%s)", name_str);
1735         }
1736     }
1737     return ret;
1738 }
1739
1740 /* Transfer online/offline status between @vcpu and the guest system.
1741  *
1742  * On input either @errp or *@errp must be NULL.
1743  *
1744  * In system-to-@vcpu direction, the following @vcpu fields are accessed:
1745  * - R: vcpu->logical_id
1746  * - W: vcpu->online
1747  * - W: vcpu->can_offline
1748  *
1749  * In @vcpu-to-system direction, the following @vcpu fields are accessed:
1750  * - R: vcpu->logical_id
1751  * - R: vcpu->online
1752  *
1753  * Written members remain unmodified on error.
1754  */
1755 static void transfer_vcpu(GuestLogicalProcessor *vcpu, bool sys2vcpu,
1756                           Error **errp)
1757 {
1758     char *dirpath;
1759     int dirfd;
1760
1761     dirpath = g_strdup_printf("/sys/devices/system/cpu/cpu%" PRId64 "/",
1762                               vcpu->logical_id);
1763     dirfd = open(dirpath, O_RDONLY | O_DIRECTORY);
1764     if (dirfd == -1) {
1765         error_setg_errno(errp, errno, "open(\"%s\")", dirpath);
1766     } else {
1767         static const char fn[] = "online";
1768         int fd;
1769         int res;
1770
1771         fd = openat(dirfd, fn, sys2vcpu ? O_RDONLY : O_RDWR);
1772         if (fd == -1) {
1773             if (errno != ENOENT) {
1774                 error_setg_errno(errp, errno, "open(\"%s/%s\")", dirpath, fn);
1775             } else if (sys2vcpu) {
1776                 vcpu->online = true;
1777                 vcpu->can_offline = false;
1778             } else if (!vcpu->online) {
1779                 error_setg(errp, "logical processor #%" PRId64 " can't be "
1780                            "offlined", vcpu->logical_id);
1781             } /* otherwise pretend successful re-onlining */
1782         } else {
1783             unsigned char status;
1784
1785             res = pread(fd, &status, 1, 0);
1786             if (res == -1) {
1787                 error_setg_errno(errp, errno, "pread(\"%s/%s\")", dirpath, fn);
1788             } else if (res == 0) {
1789                 error_setg(errp, "pread(\"%s/%s\"): unexpected EOF", dirpath,
1790                            fn);
1791             } else if (sys2vcpu) {
1792                 vcpu->online = (status != '0');
1793                 vcpu->can_offline = true;
1794             } else if (vcpu->online != (status != '0')) {
1795                 status = '0' + vcpu->online;
1796                 if (pwrite(fd, &status, 1, 0) == -1) {
1797                     error_setg_errno(errp, errno, "pwrite(\"%s/%s\")", dirpath,
1798                                      fn);
1799                 }
1800             } /* otherwise pretend successful re-(on|off)-lining */
1801
1802             res = close(fd);
1803             g_assert(res == 0);
1804         }
1805
1806         res = close(dirfd);
1807         g_assert(res == 0);
1808     }
1809
1810     g_free(dirpath);
1811 }
1812
1813 GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp)
1814 {
1815     int64_t current;
1816     GuestLogicalProcessorList *head, **link;
1817     long sc_max;
1818     Error *local_err = NULL;
1819
1820     current = 0;
1821     head = NULL;
1822     link = &head;
1823     sc_max = SYSCONF_EXACT(_SC_NPROCESSORS_CONF, &local_err);
1824
1825     while (local_err == NULL && current < sc_max) {
1826         GuestLogicalProcessor *vcpu;
1827         GuestLogicalProcessorList *entry;
1828
1829         vcpu = g_malloc0(sizeof *vcpu);
1830         vcpu->logical_id = current++;
1831         vcpu->has_can_offline = true; /* lolspeak ftw */
1832         transfer_vcpu(vcpu, true, &local_err);
1833
1834         entry = g_malloc0(sizeof *entry);
1835         entry->value = vcpu;
1836
1837         *link = entry;
1838         link = &entry->next;
1839     }
1840
1841     if (local_err == NULL) {
1842         /* there's no guest with zero VCPUs */
1843         g_assert(head != NULL);
1844         return head;
1845     }
1846
1847     qapi_free_GuestLogicalProcessorList(head);
1848     error_propagate(errp, local_err);
1849     return NULL;
1850 }
1851
1852 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp)
1853 {
1854     int64_t processed;
1855     Error *local_err = NULL;
1856
1857     processed = 0;
1858     while (vcpus != NULL) {
1859         transfer_vcpu(vcpus->value, false, &local_err);
1860         if (local_err != NULL) {
1861             break;
1862         }
1863         ++processed;
1864         vcpus = vcpus->next;
1865     }
1866
1867     if (local_err != NULL) {
1868         if (processed == 0) {
1869             error_propagate(errp, local_err);
1870         } else {
1871             error_free(local_err);
1872         }
1873     }
1874
1875     return processed;
1876 }
1877
1878 #else /* defined(__linux__) */
1879
1880 void qmp_guest_suspend_disk(Error **errp)
1881 {
1882     error_set(errp, QERR_UNSUPPORTED);
1883 }
1884
1885 void qmp_guest_suspend_ram(Error **errp)
1886 {
1887     error_set(errp, QERR_UNSUPPORTED);
1888 }
1889
1890 void qmp_guest_suspend_hybrid(Error **errp)
1891 {
1892     error_set(errp, QERR_UNSUPPORTED);
1893 }
1894
1895 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
1896 {
1897     error_set(errp, QERR_UNSUPPORTED);
1898     return NULL;
1899 }
1900
1901 GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp)
1902 {
1903     error_set(errp, QERR_UNSUPPORTED);
1904     return NULL;
1905 }
1906
1907 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp)
1908 {
1909     error_set(errp, QERR_UNSUPPORTED);
1910     return -1;
1911 }
1912
1913 #endif
1914
1915 #if !defined(CONFIG_FSFREEZE)
1916
1917 GuestFilesystemInfoList *qmp_guest_get_fsinfo(Error **errp)
1918 {
1919     error_set(errp, QERR_UNSUPPORTED);
1920     return NULL;
1921 }
1922
1923 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp)
1924 {
1925     error_set(errp, QERR_UNSUPPORTED);
1926
1927     return 0;
1928 }
1929
1930 int64_t qmp_guest_fsfreeze_freeze(Error **errp)
1931 {
1932     error_set(errp, QERR_UNSUPPORTED);
1933
1934     return 0;
1935 }
1936
1937 int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints,
1938                                        strList *mountpoints,
1939                                        Error **errp)
1940 {
1941     error_set(errp, QERR_UNSUPPORTED);
1942
1943     return 0;
1944 }
1945
1946 int64_t qmp_guest_fsfreeze_thaw(Error **errp)
1947 {
1948     error_set(errp, QERR_UNSUPPORTED);
1949
1950     return 0;
1951 }
1952 #endif /* CONFIG_FSFREEZE */
1953
1954 #if !defined(CONFIG_FSTRIM)
1955 void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
1956 {
1957     error_set(errp, QERR_UNSUPPORTED);
1958 }
1959 #endif
1960
1961 /* add unsupported commands to the blacklist */
1962 GList *ga_command_blacklist_init(GList *blacklist)
1963 {
1964 #if !defined(__linux__)
1965     {
1966         const char *list[] = {
1967             "guest-suspend-disk", "guest-suspend-ram",
1968             "guest-suspend-hybrid", "guest-network-get-interfaces",
1969             "guest-get-vcpus", "guest-set-vcpus", NULL};
1970         char **p = (char **)list;
1971
1972         while (*p) {
1973             blacklist = g_list_append(blacklist, *p++);
1974         }
1975     }
1976 #endif
1977
1978 #if !defined(CONFIG_FSFREEZE)
1979     {
1980         const char *list[] = {
1981             "guest-get-fsinfo", "guest-fsfreeze-status",
1982             "guest-fsfreeze-freeze", "guest-fsfreeze-freeze-list",
1983             "guest-fsfreeze-thaw", "guest-get-fsinfo", NULL};
1984         char **p = (char **)list;
1985
1986         while (*p) {
1987             blacklist = g_list_append(blacklist, *p++);
1988         }
1989     }
1990 #endif
1991
1992 #if !defined(CONFIG_FSTRIM)
1993     blacklist = g_list_append(blacklist, (char *)"guest-fstrim");
1994 #endif
1995
1996     return blacklist;
1997 }
1998
1999 /* register init/cleanup routines for stateful command groups */
2000 void ga_command_state_init(GAState *s, GACommandState *cs)
2001 {
2002 #if defined(CONFIG_FSFREEZE)
2003     ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup);
2004 #endif
2005     ga_command_state_add(cs, guest_file_init, NULL);
2006 }