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