qga/commands-posix.c

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