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