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