qga/commands-posix.c

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