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 <inttypes.h>
  22 #include "qga/guest-agent-core.h"
  23 #include "qga-qmp-commands.h"
  24 #include "qapi/qmp/qerror.h"
  25 #include "qemu/queue.h"
  26 #include "qemu/host-utils.h"
  27
  28 #ifndef CONFIG_HAS_ENVIRON
  29 #ifdef __APPLE__
  30 #include <crt_externs.h>
  31 #define environ (*_NSGetEnviron())
  32 #else
  33 extern char **environ;
  34 #endif
  35 #endif
  36
  37 #if defined(__linux__)
  38 #include <mntent.h>
  39 #include <linux/fs.h>
  40 #include <ifaddrs.h>
  41 #include <arpa/inet.h>
  42 #include <sys/socket.h>
  43 #include <net/if.h>
  44
  45 #ifdef FIFREEZE
  46 #define CONFIG_FSFREEZE
  47 #endif
  48 #ifdef FITRIM
  49 #define CONFIG_FSTRIM
  50 #endif
  51 #endif
  52
  53 static void ga_wait_child(pid_t pid, int *status, Error **err)
  54 {
  55     pid_t rpid;
  56
  57     *status = 0;
  58
  59     do {
  60         rpid = waitpid(pid, status, 0);
  61     } while (rpid == -1 && errno == EINTR);
  62
  63     if (rpid == -1) {
  64         error_setg_errno(err, errno, "failed to wait for child (pid: %d)", pid);
  65         return;
  66     }
  67
  68     g_assert(rpid == pid);
  69 }
  70
  71 void qmp_guest_shutdown(bool has_mode, const char *mode, Error **err)
  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(err,
  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", shutdown_flag, "+0",
 100                "hypervisor initiated shutdown", (char*)NULL, environ);
 101         _exit(EXIT_FAILURE);
 102     } else if (pid < 0) {
 103         error_setg_errno(err, errno, "failed to create child process");
 104         return;
 105     }
 106
 107     ga_wait_child(pid, &status, &local_err);
 108     if (error_is_set(&local_err)) {
 109         error_propagate(err, local_err);
 110         return;
 111     }
 112
 113     if (!WIFEXITED(status)) {
 114         error_setg(err, "child process has terminated abnormally");
 115         return;
 116     }
 117
 118     if (WEXITSTATUS(status)) {
 119         error_setg(err, "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(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     /* year-2038 will overflow in case time_t is 32bit */
 151     if (time_ns / 1000000000 != (time_t)(time_ns / 1000000000)) {
 152         error_setg(errp, "Time %" PRId64 " is too large", time_ns);
 153         return;
 154     }
 155
 156     tv.tv_sec = time_ns / 1000000000;
 157     tv.tv_usec = (time_ns % 1000000000) / 1000;
 158
 159     ret = settimeofday(&tv, NULL);
 160     if (ret < 0) {
 161         error_setg_errno(errp, errno, "Failed to set time to guest");
 162         return;
 163     }
 164
 165     /* Set the Hardware Clock to the current System Time. */
 166     pid = fork();
 167     if (pid == 0) {
 168         setsid();
 169         reopen_fd_to_null(0);
 170         reopen_fd_to_null(1);
 171         reopen_fd_to_null(2);
 172
 173         execle("/sbin/hwclock", "hwclock", "-w", NULL, environ);
 174         _exit(EXIT_FAILURE);
 175     } else if (pid < 0) {
 176         error_setg_errno(errp, errno, "failed to create child process");
 177         return;
 178     }
 179
 180     ga_wait_child(pid, &status, &local_err);
 181     if (error_is_set(&local_err)) {
 182         error_propagate(errp, local_err);
 183         return;
 184     }
 185
 186     if (!WIFEXITED(status)) {
 187         error_setg(errp, "child process has terminated abnormally");
 188         return;
 189     }
 190
 191     if (WEXITSTATUS(status)) {
 192         error_setg(errp, "hwclock failed to set hardware clock to system time");
 193         return;
 194     }
 195 }
 196
 197 typedef struct GuestFileHandle {
 198     uint64_t id;
 199     FILE *fh;
 200     QTAILQ_ENTRY(GuestFileHandle) next;
 201 } GuestFileHandle;
 202
 203 static struct {
 204     QTAILQ_HEAD(, GuestFileHandle) filehandles;
 205 } guest_file_state;
 206
 207 static int64_t guest_file_handle_add(FILE *fh, Error **errp)
 208 {
 209     GuestFileHandle *gfh;
 210     int64_t handle;
 211
 212     handle = ga_get_fd_handle(ga_state, errp);
 213     if (error_is_set(errp)) {
 214         return 0;
 215     }
 216
 217     gfh = g_malloc0(sizeof(GuestFileHandle));
 218     gfh->id = handle;
 219     gfh->fh = fh;
 220     QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);
 221
 222     return handle;
 223 }
 224
 225 static GuestFileHandle *guest_file_handle_find(int64_t id, Error **err)
 226 {
 227     GuestFileHandle *gfh;
 228
 229     QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next)
 230     {
 231         if (gfh->id == id) {
 232             return gfh;
 233         }
 234     }
 235
 236     error_setg(err, "handle '%" PRId64 "' has not been found", id);
 237     return NULL;
 238 }
 239
 240 int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, Error **err)
 241 {
 242     FILE *fh;
 243     int fd;
 244     int64_t ret = -1, handle;
 245
 246     if (!has_mode) {
 247         mode = "r";
 248     }
 249     slog("guest-file-open called, filepath: %s, mode: %s", path, mode);
 250     fh = fopen(path, mode);
 251     if (!fh) {
 252         error_setg_errno(err, errno, "failed to open file '%s' (mode: '%s')",
 253                          path, mode);
 254         return -1;
 255     }
 256
 257     /* set fd non-blocking to avoid common use cases (like reading from a
 258      * named pipe) from hanging the agent
 259      */
 260     fd = fileno(fh);
 261     ret = fcntl(fd, F_GETFL);
 262     ret = fcntl(fd, F_SETFL, ret | O_NONBLOCK);
 263     if (ret == -1) {
 264         error_setg_errno(err, errno, "failed to make file '%s' non-blocking",
 265                          path);
 266         fclose(fh);
 267         return -1;
 268     }
 269
 270     handle = guest_file_handle_add(fh, err);
 271     if (error_is_set(err)) {
 272         fclose(fh);
 273         return -1;
 274     }
 275
 276     slog("guest-file-open, handle: %d", handle);
 277     return handle;
 278 }
 279
 280 void qmp_guest_file_close(int64_t handle, Error **err)
 281 {
 282     GuestFileHandle *gfh = guest_file_handle_find(handle, err);
 283     int ret;
 284
 285     slog("guest-file-close called, handle: %ld", handle);
 286     if (!gfh) {
 287         return;
 288     }
 289
 290     ret = fclose(gfh->fh);
 291     if (ret == EOF) {
 292         error_setg_errno(err, errno, "failed to close handle");
 293         return;
 294     }
 295
 296     QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next);
 297     g_free(gfh);
 298 }
 299
 300 struct GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count,
 301                                           int64_t count, Error **err)
 302 {
 303     GuestFileHandle *gfh = guest_file_handle_find(handle, err);
 304     GuestFileRead *read_data = NULL;
 305     guchar *buf;
 306     FILE *fh;
 307     size_t read_count;
 308
 309     if (!gfh) {
 310         return NULL;
 311     }
 312
 313     if (!has_count) {
 314         count = QGA_READ_COUNT_DEFAULT;
 315     } else if (count < 0) {
 316         error_setg(err, "value '%" PRId64 "' is invalid for argument count",
 317                    count);
 318         return NULL;
 319     }
 320
 321     fh = gfh->fh;
 322     buf = g_malloc0(count+1);
 323     read_count = fread(buf, 1, count, fh);
 324     if (ferror(fh)) {
 325         error_setg_errno(err, errno, "failed to read file");
 326         slog("guest-file-read failed, handle: %ld", handle);
 327     } else {
 328         buf[read_count] = 0;
 329         read_data = g_malloc0(sizeof(GuestFileRead));
 330         read_data->count = read_count;
 331         read_data->eof = feof(fh);
 332         if (read_count) {
 333             read_data->buf_b64 = g_base64_encode(buf, read_count);
 334         }
 335     }
 336     g_free(buf);
 337     clearerr(fh);
 338
 339     return read_data;
 340 }
 341
 342 GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
 343                                      bool has_count, int64_t count, Error **err)
 344 {
 345     GuestFileWrite *write_data = NULL;
 346     guchar *buf;
 347     gsize buf_len;
 348     int write_count;
 349     GuestFileHandle *gfh = guest_file_handle_find(handle, err);
 350     FILE *fh;
 351
 352     if (!gfh) {
 353         return NULL;
 354     }
 355
 356     fh = gfh->fh;
 357     buf = g_base64_decode(buf_b64, &buf_len);
 358
 359     if (!has_count) {
 360         count = buf_len;
 361     } else if (count < 0 || count > buf_len) {
 362         error_setg(err, "value '%" PRId64 "' is invalid for argument count",
 363                    count);
 364         g_free(buf);
 365         return NULL;
 366     }
 367
 368     write_count = fwrite(buf, 1, count, fh);
 369     if (ferror(fh)) {
 370         error_setg_errno(err, errno, "failed to write to file");
 371         slog("guest-file-write failed, handle: %ld", handle);
 372     } else {
 373         write_data = g_malloc0(sizeof(GuestFileWrite));
 374         write_data->count = write_count;
 375         write_data->eof = feof(fh);
 376     }
 377     g_free(buf);
 378     clearerr(fh);
 379
 380     return write_data;
 381 }
 382
 383 struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
 384                                           int64_t whence, Error **err)
 385 {
 386     GuestFileHandle *gfh = guest_file_handle_find(handle, err);
 387     GuestFileSeek *seek_data = NULL;
 388     FILE *fh;
 389     int ret;
 390
 391     if (!gfh) {
 392         return NULL;
 393     }
 394
 395     fh = gfh->fh;
 396     ret = fseek(fh, offset, whence);
 397     if (ret == -1) {
 398         error_setg_errno(err, errno, "failed to seek file");
 399     } else {
 400         seek_data = g_malloc0(sizeof(GuestFileRead));
 401         seek_data->position = ftell(fh);
 402         seek_data->eof = feof(fh);
 403     }
 404     clearerr(fh);
 405
 406     return seek_data;
 407 }
 408
 409 void qmp_guest_file_flush(int64_t handle, Error **err)
 410 {
 411     GuestFileHandle *gfh = guest_file_handle_find(handle, err);
 412     FILE *fh;
 413     int ret;
 414
 415     if (!gfh) {
 416         return;
 417     }
 418
 419     fh = gfh->fh;
 420     ret = fflush(fh);
 421     if (ret == EOF) {
 422         error_setg_errno(err, errno, "failed to flush file");
 423     }
 424 }
 425
 426 static void guest_file_init(void)
 427 {
 428     QTAILQ_INIT(&guest_file_state.filehandles);
 429 }
 430
 431 /* linux-specific implementations. avoid this if at all possible. */
 432 #if defined(__linux__)
 433
 434 #if defined(CONFIG_FSFREEZE) || defined(CONFIG_FSTRIM)
 435 typedef struct FsMount {
 436     char *dirname;
 437     char *devtype;
 438     QTAILQ_ENTRY(FsMount) next;
 439 } FsMount;
 440
 441 typedef QTAILQ_HEAD(, FsMount) FsMountList;
 442
 443 static void free_fs_mount_list(FsMountList *mounts)
 444 {
 445      FsMount *mount, *temp;
 446
 447      if (!mounts) {
 448          return;
 449      }
 450
 451      QTAILQ_FOREACH_SAFE(mount, mounts, next, temp) {
 452          QTAILQ_REMOVE(mounts, mount, next);
 453          g_free(mount->dirname);
 454          g_free(mount->devtype);
 455          g_free(mount);
 456      }
 457 }
 458
 459 /*
 460  * Walk the mount table and build a list of local file systems
 461  */
 462 static void build_fs_mount_list(FsMountList *mounts, Error **err)
 463 {
 464     struct mntent *ment;
 465     FsMount *mount;
 466     char const *mtab = "/proc/self/mounts";
 467     FILE *fp;
 468
 469     fp = setmntent(mtab, "r");
 470     if (!fp) {
 471         error_setg(err, "failed to open mtab file: '%s'", mtab);
 472         return;
 473     }
 474
 475     while ((ment = getmntent(fp))) {
 476         /*
 477          * An entry which device name doesn't start with a '/' is
 478          * either a dummy file system or a network file system.
 479          * Add special handling for smbfs and cifs as is done by
 480          * coreutils as well.
 481          */
 482         if ((ment->mnt_fsname[0] != '/') ||
 483             (strcmp(ment->mnt_type, "smbfs") == 0) ||
 484             (strcmp(ment->mnt_type, "cifs") == 0)) {
 485             continue;
 486         }
 487
 488         mount = g_malloc0(sizeof(FsMount));
 489         mount->dirname = g_strdup(ment->mnt_dir);
 490         mount->devtype = g_strdup(ment->mnt_type);
 491
 492         QTAILQ_INSERT_TAIL(mounts, mount, next);
 493     }
 494
 495     endmntent(fp);
 496 }
 497 #endif
 498
 499 #if defined(CONFIG_FSFREEZE)
 500
 501 typedef enum {
 502     FSFREEZE_HOOK_THAW = 0,
 503     FSFREEZE_HOOK_FREEZE,
 504 } FsfreezeHookArg;
 505
 506 const char *fsfreeze_hook_arg_string[] = {
 507     "thaw",
 508     "freeze",
 509 };
 510
 511 static void execute_fsfreeze_hook(FsfreezeHookArg arg, Error **err)
 512 {
 513     int status;
 514     pid_t pid;
 515     const char *hook;
 516     const char *arg_str = fsfreeze_hook_arg_string[arg];
 517     Error *local_err = NULL;
 518
 519     hook = ga_fsfreeze_hook(ga_state);
 520     if (!hook) {
 521         return;
 522     }
 523     if (access(hook, X_OK) != 0) {
 524         error_setg_errno(err, errno, "can't access fsfreeze hook '%s'", hook);
 525         return;
 526     }
 527
 528     slog("executing fsfreeze hook with arg '%s'", arg_str);
 529     pid = fork();
 530     if (pid == 0) {
 531         setsid();
 532         reopen_fd_to_null(0);
 533         reopen_fd_to_null(1);
 534         reopen_fd_to_null(2);
 535
 536         execle(hook, hook, arg_str, NULL, environ);
 537         _exit(EXIT_FAILURE);
 538     } else if (pid < 0) {
 539         error_setg_errno(err, errno, "failed to create child process");
 540         return;
 541     }
 542
 543     ga_wait_child(pid, &status, &local_err);
 544     if (error_is_set(&local_err)) {
 545         error_propagate(err, local_err);
 546         return;
 547     }
 548
 549     if (!WIFEXITED(status)) {
 550         error_setg(err, "fsfreeze hook has terminated abnormally");
 551         return;
 552     }
 553
 554     status = WEXITSTATUS(status);
 555     if (status) {
 556         error_setg(err, "fsfreeze hook has failed with status %d", status);
 557         return;
 558     }
 559 }
 560
 561 /*
 562  * Return status of freeze/thaw
 563  */
 564 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err)
 565 {
 566     if (ga_is_frozen(ga_state)) {
 567         return GUEST_FSFREEZE_STATUS_FROZEN;
 568     }
 569
 570     return GUEST_FSFREEZE_STATUS_THAWED;
 571 }
 572
 573 /*
 574  * Walk list of mounted file systems in the guest, and freeze the ones which
 575  * are real local file systems.
 576  */
 577 int64_t qmp_guest_fsfreeze_freeze(Error **err)
 578 {
 579     int ret = 0, i = 0;
 580     FsMountList mounts;
 581     struct FsMount *mount;
 582     Error *local_err = NULL;
 583     int fd;
 584
 585     slog("guest-fsfreeze called");
 586
 587     execute_fsfreeze_hook(FSFREEZE_HOOK_FREEZE, &local_err);
 588     if (error_is_set(&local_err)) {
 589         error_propagate(err, local_err);
 590         return -1;
 591     }
 592
 593     QTAILQ_INIT(&mounts);
 594     build_fs_mount_list(&mounts, &local_err);
 595     if (error_is_set(&local_err)) {
 596         error_propagate(err, local_err);
 597         return -1;
 598     }
 599
 600     /* cannot risk guest agent blocking itself on a write in this state */
 601     ga_set_frozen(ga_state);
 602
 603     QTAILQ_FOREACH(mount, &mounts, next) {
 604         fd = qemu_open(mount->dirname, O_RDONLY);
 605         if (fd == -1) {
 606             error_setg_errno(err, errno, "failed to open %s", mount->dirname);
 607             goto error;
 608         }
 609
 610         /* we try to cull filesytems we know won't work in advance, but other
 611          * filesytems may not implement fsfreeze for less obvious reasons.
 612          * these will report EOPNOTSUPP. we simply ignore these when tallying
 613          * the number of frozen filesystems.
 614          *
 615          * any other error means a failure to freeze a filesystem we
 616          * expect to be freezable, so return an error in those cases
 617          * and return system to thawed state.
 618          */
 619         ret = ioctl(fd, FIFREEZE);
 620         if (ret == -1) {
 621             if (errno != EOPNOTSUPP) {
 622                 error_setg_errno(err, errno, "failed to freeze %s",
 623                                  mount->dirname);
 624                 close(fd);
 625                 goto error;
 626             }
 627         } else {
 628             i++;
 629         }
 630         close(fd);
 631     }
 632
 633     free_fs_mount_list(&mounts);
 634     return i;
 635
 636 error:
 637     free_fs_mount_list(&mounts);
 638     qmp_guest_fsfreeze_thaw(NULL);
 639     return 0;
 640 }
 641
 642 /*
 643  * Walk list of frozen file systems in the guest, and thaw them.
 644  */
 645 int64_t qmp_guest_fsfreeze_thaw(Error **err)
 646 {
 647     int ret;
 648     FsMountList mounts;
 649     FsMount *mount;
 650     int fd, i = 0, logged;
 651     Error *local_err = NULL;
 652
 653     QTAILQ_INIT(&mounts);
 654     build_fs_mount_list(&mounts, &local_err);
 655     if (error_is_set(&local_err)) {
 656         error_propagate(err, local_err);
 657         return 0;
 658     }
 659
 660     QTAILQ_FOREACH(mount, &mounts, next) {
 661         logged = false;
 662         fd = qemu_open(mount->dirname, O_RDONLY);
 663         if (fd == -1) {
 664             continue;
 665         }
 666         /* we have no way of knowing whether a filesystem was actually unfrozen
 667          * as a result of a successful call to FITHAW, only that if an error
 668          * was returned the filesystem was *not* unfrozen by that particular
 669          * call.
 670          *
 671          * since multiple preceding FIFREEZEs require multiple calls to FITHAW
 672          * to unfreeze, continuing issuing FITHAW until an error is returned,
 673          * in which case either the filesystem is in an unfreezable state, or,
 674          * more likely, it was thawed previously (and remains so afterward).
 675          *
 676          * also, since the most recent successful call is the one that did
 677          * the actual unfreeze, we can use this to provide an accurate count
 678          * of the number of filesystems unfrozen by guest-fsfreeze-thaw, which
 679          * may * be useful for determining whether a filesystem was unfrozen
 680          * during the freeze/thaw phase by a process other than qemu-ga.
 681          */
 682         do {
 683             ret = ioctl(fd, FITHAW);
 684             if (ret == 0 && !logged) {
 685                 i++;
 686                 logged = true;
 687             }
 688         } while (ret == 0);
 689         close(fd);
 690     }
 691
 692     ga_unset_frozen(ga_state);
 693     free_fs_mount_list(&mounts);
 694
 695     execute_fsfreeze_hook(FSFREEZE_HOOK_THAW, err);
 696
 697     return i;
 698 }
 699
 700 static void guest_fsfreeze_cleanup(void)
 701 {
 702     Error *err = NULL;
 703
 704     if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) {
 705         qmp_guest_fsfreeze_thaw(&err);
 706         if (err) {
 707             slog("failed to clean up frozen filesystems: %s",
 708                  error_get_pretty(err));
 709             error_free(err);
 710         }
 711     }
 712 }
 713 #endif /* CONFIG_FSFREEZE */
 714
 715 #if defined(CONFIG_FSTRIM)
 716 /*
 717  * Walk list of mounted file systems in the guest, and trim them.
 718  */
 719 void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **err)
 720 {
 721     int ret = 0;
 722     FsMountList mounts;
 723     struct FsMount *mount;
 724     int fd;
 725     Error *local_err = NULL;
 726     struct fstrim_range r = {
 727         .start = 0,
 728         .len = -1,
 729         .minlen = has_minimum ? minimum : 0,
 730     };
 731
 732     slog("guest-fstrim called");
 733
 734     QTAILQ_INIT(&mounts);
 735     build_fs_mount_list(&mounts, &local_err);
 736     if (error_is_set(&local_err)) {
 737         error_propagate(err, local_err);
 738         return;
 739     }
 740
 741     QTAILQ_FOREACH(mount, &mounts, next) {
 742         fd = qemu_open(mount->dirname, O_RDONLY);
 743         if (fd == -1) {
 744             error_setg_errno(err, errno, "failed to open %s", mount->dirname);
 745             goto error;
 746         }
 747
 748         /* We try to cull filesytems we know won't work in advance, but other
 749          * filesytems may not implement fstrim for less obvious reasons.  These
 750          * will report EOPNOTSUPP; we simply ignore these errors.  Any other
 751          * error means an unexpected error, so return it in those cases.  In
 752          * some other cases ENOTTY will be reported (e.g. CD-ROMs).
 753          */
 754         ret = ioctl(fd, FITRIM, &r);
 755         if (ret == -1) {
 756             if (errno != ENOTTY && errno != EOPNOTSUPP) {
 757                 error_setg_errno(err, errno, "failed to trim %s",
 758                                  mount->dirname);
 759                 close(fd);
 760                 goto error;
 761             }
 762         }
 763         close(fd);
 764     }
 765
 766 error:
 767     free_fs_mount_list(&mounts);
 768 }
 769 #endif /* CONFIG_FSTRIM */
 770
 771
 772 #define LINUX_SYS_STATE_FILE "/sys/power/state"
 773 #define SUSPEND_SUPPORTED 0
 774 #define SUSPEND_NOT_SUPPORTED 1
 775
 776 static void bios_supports_mode(const char *pmutils_bin, const char *pmutils_arg,
 777                                const char *sysfile_str, Error **err)
 778 {
 779     Error *local_err = NULL;
 780     char *pmutils_path;
 781     pid_t pid;
 782     int status;
 783
 784     pmutils_path = g_find_program_in_path(pmutils_bin);
 785
 786     pid = fork();
 787     if (!pid) {
 788         char buf[32]; /* hopefully big enough */
 789         ssize_t ret;
 790         int fd;
 791
 792         setsid();
 793         reopen_fd_to_null(0);
 794         reopen_fd_to_null(1);
 795         reopen_fd_to_null(2);
 796
 797         if (pmutils_path) {
 798             execle(pmutils_path, pmutils_bin, pmutils_arg, NULL, environ);
 799         }
 800
 801         /*
 802          * If we get here either pm-utils is not installed or execle() has
 803          * failed. Let's try the manual method if the caller wants it.
 804          */
 805
 806         if (!sysfile_str) {
 807             _exit(SUSPEND_NOT_SUPPORTED);
 808         }
 809
 810         fd = open(LINUX_SYS_STATE_FILE, O_RDONLY);
 811         if (fd < 0) {
 812             _exit(SUSPEND_NOT_SUPPORTED);
 813         }
 814
 815         ret = read(fd, buf, sizeof(buf)-1);
 816         if (ret <= 0) {
 817             _exit(SUSPEND_NOT_SUPPORTED);
 818         }
 819         buf[ret] = '\0';
 820
 821         if (strstr(buf, sysfile_str)) {
 822             _exit(SUSPEND_SUPPORTED);
 823         }
 824
 825         _exit(SUSPEND_NOT_SUPPORTED);
 826     } else if (pid < 0) {
 827         error_setg_errno(err, errno, "failed to create child process");
 828         goto out;
 829     }
 830
 831     ga_wait_child(pid, &status, &local_err);
 832     if (error_is_set(&local_err)) {
 833         error_propagate(err, local_err);
 834         goto out;
 835     }
 836
 837     if (!WIFEXITED(status)) {
 838         error_setg(err, "child process has terminated abnormally");
 839         goto out;
 840     }
 841
 842     switch (WEXITSTATUS(status)) {
 843     case SUSPEND_SUPPORTED:
 844         goto out;
 845     case SUSPEND_NOT_SUPPORTED:
 846         error_setg(err,
 847                    "the requested suspend mode is not supported by the guest");
 848         goto out;
 849     default:
 850         error_setg(err,
 851                    "the helper program '%s' returned an unexpected exit status"
 852                    " code (%d)", pmutils_path, WEXITSTATUS(status));
 853         goto out;
 854     }
 855
 856 out:
 857     g_free(pmutils_path);
 858 }
 859
 860 static void guest_suspend(const char *pmutils_bin, const char *sysfile_str,
 861                           Error **err)
 862 {
 863     Error *local_err = NULL;
 864     char *pmutils_path;
 865     pid_t pid;
 866     int status;
 867
 868     pmutils_path = g_find_program_in_path(pmutils_bin);
 869
 870     pid = fork();
 871     if (pid == 0) {
 872         /* child */
 873         int fd;
 874
 875         setsid();
 876         reopen_fd_to_null(0);
 877         reopen_fd_to_null(1);
 878         reopen_fd_to_null(2);
 879
 880         if (pmutils_path) {
 881             execle(pmutils_path, pmutils_bin, NULL, environ);
 882         }
 883
 884         /*
 885          * If we get here either pm-utils is not installed or execle() has
 886          * failed. Let's try the manual method if the caller wants it.
 887          */
 888
 889         if (!sysfile_str) {
 890             _exit(EXIT_FAILURE);
 891         }
 892
 893         fd = open(LINUX_SYS_STATE_FILE, O_WRONLY);
 894         if (fd < 0) {
 895             _exit(EXIT_FAILURE);
 896         }
 897
 898         if (write(fd, sysfile_str, strlen(sysfile_str)) < 0) {
 899             _exit(EXIT_FAILURE);
 900         }
 901
 902         _exit(EXIT_SUCCESS);
 903     } else if (pid < 0) {
 904         error_setg_errno(err, errno, "failed to create child process");
 905         goto out;
 906     }
 907
 908     ga_wait_child(pid, &status, &local_err);
 909     if (error_is_set(&local_err)) {
 910         error_propagate(err, local_err);
 911         goto out;
 912     }
 913
 914     if (!WIFEXITED(status)) {
 915         error_setg(err, "child process has terminated abnormally");
 916         goto out;
 917     }
 918
 919     if (WEXITSTATUS(status)) {
 920         error_setg(err, "child process has failed to suspend");
 921         goto out;
 922     }
 923
 924 out:
 925     g_free(pmutils_path);
 926 }
 927
 928 void qmp_guest_suspend_disk(Error **err)
 929 {
 930     bios_supports_mode("pm-is-supported", "--hibernate", "disk", err);
 931     if (error_is_set(err)) {
 932         return;
 933     }
 934
 935     guest_suspend("pm-hibernate", "disk", err);
 936 }
 937
 938 void qmp_guest_suspend_ram(Error **err)
 939 {
 940     bios_supports_mode("pm-is-supported", "--suspend", "mem", err);
 941     if (error_is_set(err)) {
 942         return;
 943     }
 944
 945     guest_suspend("pm-suspend", "mem", err);
 946 }
 947
 948 void qmp_guest_suspend_hybrid(Error **err)
 949 {
 950     bios_supports_mode("pm-is-supported", "--suspend-hybrid", NULL, err);
 951     if (error_is_set(err)) {
 952         return;
 953     }
 954
 955     guest_suspend("pm-suspend-hybrid", NULL, err);
 956 }
 957
 958 static GuestNetworkInterfaceList *
 959 guest_find_interface(GuestNetworkInterfaceList *head,
 960                      const char *name)
 961 {
 962     for (; head; head = head->next) {
 963         if (strcmp(head->value->name, name) == 0) {
 964             break;
 965         }
 966     }
 967
 968     return head;
 969 }
 970
 971 /*
 972  * Build information about guest interfaces
 973  */
 974 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
 975 {
 976     GuestNetworkInterfaceList *head = NULL, *cur_item = NULL;
 977     struct ifaddrs *ifap, *ifa;
 978
 979     if (getifaddrs(&ifap) < 0) {
 980         error_setg_errno(errp, errno, "getifaddrs failed");
 981         goto error;
 982     }
 983
 984     for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
 985         GuestNetworkInterfaceList *info;
 986         GuestIpAddressList **address_list = NULL, *address_item = NULL;
 987         char addr4[INET_ADDRSTRLEN];
 988         char addr6[INET6_ADDRSTRLEN];
 989         int sock;
 990         struct ifreq ifr;
 991         unsigned char *mac_addr;
 992         void *p;
 993
 994         g_debug("Processing %s interface", ifa->ifa_name);
 995
 996         info = guest_find_interface(head, ifa->ifa_name);
 997
 998         if (!info) {
 999             info = g_malloc0(sizeof(*info));
1000             info->value = g_malloc0(sizeof(*info->value));
1001             info->value->name = g_strdup(ifa->ifa_name);
1002
1003             if (!cur_item) {
1004                 head = cur_item = info;
1005             } else {
1006                 cur_item->next = info;
1007                 cur_item = info;
1008             }
1009         }
1010
1011         if (!info->value->has_hardware_address &&
1012             ifa->ifa_flags & SIOCGIFHWADDR) {
1013             /* we haven't obtained HW address yet */
1014             sock = socket(PF_INET, SOCK_STREAM, 0);
1015             if (sock == -1) {
1016                 error_setg_errno(errp, errno, "failed to create socket");
1017                 goto error;
1018             }
1019
1020             memset(&ifr, 0, sizeof(ifr));
1021             pstrcpy(ifr.ifr_name, IF_NAMESIZE, info->value->name);
1022             if (ioctl(sock, SIOCGIFHWADDR, &ifr) == -1) {
1023                 error_setg_errno(errp, errno,
1024                                  "failed to get MAC address of %s",
1025                                  ifa->ifa_name);
1026                 close(sock);
1027                 goto error;
1028             }
1029
1030             close(sock);
1031             mac_addr = (unsigned char *) &ifr.ifr_hwaddr.sa_data;
1032
1033             info->value->hardware_address =
1034                 g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x",
1035                                 (int) mac_addr[0], (int) mac_addr[1],
1036                                 (int) mac_addr[2], (int) mac_addr[3],
1037                                 (int) mac_addr[4], (int) mac_addr[5]);
1038
1039             info->value->has_hardware_address = true;
1040         }
1041
1042         if (ifa->ifa_addr &&
1043             ifa->ifa_addr->sa_family == AF_INET) {
1044             /* interface with IPv4 address */
1045             p = &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
1046             if (!inet_ntop(AF_INET, p, addr4, sizeof(addr4))) {
1047                 error_setg_errno(errp, errno, "inet_ntop failed");
1048                 goto error;
1049             }
1050
1051             address_item = g_malloc0(sizeof(*address_item));
1052             address_item->value = g_malloc0(sizeof(*address_item->value));
1053             address_item->value->ip_address = g_strdup(addr4);
1054             address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4;
1055
1056             if (ifa->ifa_netmask) {
1057                 /* Count the number of set bits in netmask.
1058                  * This is safe as '1' and '0' cannot be shuffled in netmask. */
1059                 p = &((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr;
1060                 address_item->value->prefix = ctpop32(((uint32_t *) p)[0]);
1061             }
1062         } else if (ifa->ifa_addr &&
1063                    ifa->ifa_addr->sa_family == AF_INET6) {
1064             /* interface with IPv6 address */
1065             p = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr;
1066             if (!inet_ntop(AF_INET6, p, addr6, sizeof(addr6))) {
1067                 error_setg_errno(errp, errno, "inet_ntop failed");
1068                 goto error;
1069             }
1070
1071             address_item = g_malloc0(sizeof(*address_item));
1072             address_item->value = g_malloc0(sizeof(*address_item->value));
1073             address_item->value->ip_address = g_strdup(addr6);
1074             address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6;
1075
1076             if (ifa->ifa_netmask) {
1077                 /* Count the number of set bits in netmask.
1078                  * This is safe as '1' and '0' cannot be shuffled in netmask. */
1079                 p = &((struct sockaddr_in6 *)ifa->ifa_netmask)->sin6_addr;
1080                 address_item->value->prefix =
1081                     ctpop32(((uint32_t *) p)[0]) +
1082                     ctpop32(((uint32_t *) p)[1]) +
1083                     ctpop32(((uint32_t *) p)[2]) +
1084                     ctpop32(((uint32_t *) p)[3]);
1085             }
1086         }
1087
1088         if (!address_item) {
1089             continue;
1090         }
1091
1092         address_list = &info->value->ip_addresses;
1093
1094         while (*address_list && (*address_list)->next) {
1095             address_list = &(*address_list)->next;
1096         }
1097
1098         if (!*address_list) {
1099             *address_list = address_item;
1100         } else {
1101             (*address_list)->next = address_item;
1102         }
1103
1104         info->value->has_ip_addresses = true;
1105
1106
1107     }
1108
1109     freeifaddrs(ifap);
1110     return head;
1111
1112 error:
1113     freeifaddrs(ifap);
1114     qapi_free_GuestNetworkInterfaceList(head);
1115     return NULL;
1116 }
1117
1118 #define SYSCONF_EXACT(name, err) sysconf_exact((name), #name, (err))
1119
1120 static long sysconf_exact(int name, const char *name_str, Error **err)
1121 {
1122     long ret;
1123
1124     errno = 0;
1125     ret = sysconf(name);
1126     if (ret == -1) {
1127         if (errno == 0) {
1128             error_setg(err, "sysconf(%s): value indefinite", name_str);
1129         } else {
1130             error_setg_errno(err, errno, "sysconf(%s)", name_str);
1131         }
1132     }
1133     return ret;
1134 }
1135
1136 /* Transfer online/offline status between @vcpu and the guest system.
1137  *
1138  * On input either @errp or *@errp must be NULL.
1139  *
1140  * In system-to-@vcpu direction, the following @vcpu fields are accessed:
1141  * - R: vcpu->logical_id
1142  * - W: vcpu->online
1143  * - W: vcpu->can_offline
1144  *
1145  * In @vcpu-to-system direction, the following @vcpu fields are accessed:
1146  * - R: vcpu->logical_id
1147  * - R: vcpu->online
1148  *
1149  * Written members remain unmodified on error.
1150  */
1151 static void transfer_vcpu(GuestLogicalProcessor *vcpu, bool sys2vcpu,
1152                           Error **errp)
1153 {
1154     char *dirpath;
1155     int dirfd;
1156
1157     dirpath = g_strdup_printf("/sys/devices/system/cpu/cpu%" PRId64 "/",
1158                               vcpu->logical_id);
1159     dirfd = open(dirpath, O_RDONLY | O_DIRECTORY);
1160     if (dirfd == -1) {
1161         error_setg_errno(errp, errno, "open(\"%s\")", dirpath);
1162     } else {
1163         static const char fn[] = "online";
1164         int fd;
1165         int res;
1166
1167         fd = openat(dirfd, fn, sys2vcpu ? O_RDONLY : O_RDWR);
1168         if (fd == -1) {
1169             if (errno != ENOENT) {
1170                 error_setg_errno(errp, errno, "open(\"%s/%s\")", dirpath, fn);
1171             } else if (sys2vcpu) {
1172                 vcpu->online = true;
1173                 vcpu->can_offline = false;
1174             } else if (!vcpu->online) {
1175                 error_setg(errp, "logical processor #%" PRId64 " can't be "
1176                            "offlined", vcpu->logical_id);
1177             } /* otherwise pretend successful re-onlining */
1178         } else {
1179             unsigned char status;
1180
1181             res = pread(fd, &status, 1, 0);
1182             if (res == -1) {
1183                 error_setg_errno(errp, errno, "pread(\"%s/%s\")", dirpath, fn);
1184             } else if (res == 0) {
1185                 error_setg(errp, "pread(\"%s/%s\"): unexpected EOF", dirpath,
1186                            fn);
1187             } else if (sys2vcpu) {
1188                 vcpu->online = (status != '0');
1189                 vcpu->can_offline = true;
1190             } else if (vcpu->online != (status != '0')) {
1191                 status = '0' + vcpu->online;
1192                 if (pwrite(fd, &status, 1, 0) == -1) {
1193                     error_setg_errno(errp, errno, "pwrite(\"%s/%s\")", dirpath,
1194                                      fn);
1195                 }
1196             } /* otherwise pretend successful re-(on|off)-lining */
1197
1198             res = close(fd);
1199             g_assert(res == 0);
1200         }
1201
1202         res = close(dirfd);
1203         g_assert(res == 0);
1204     }
1205
1206     g_free(dirpath);
1207 }
1208
1209 GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp)
1210 {
1211     int64_t current;
1212     GuestLogicalProcessorList *head, **link;
1213     long sc_max;
1214     Error *local_err = NULL;
1215
1216     current = 0;
1217     head = NULL;
1218     link = &head;
1219     sc_max = SYSCONF_EXACT(_SC_NPROCESSORS_CONF, &local_err);
1220
1221     while (local_err == NULL && current < sc_max) {
1222         GuestLogicalProcessor *vcpu;
1223         GuestLogicalProcessorList *entry;
1224
1225         vcpu = g_malloc0(sizeof *vcpu);
1226         vcpu->logical_id = current++;
1227         vcpu->has_can_offline = true; /* lolspeak ftw */
1228         transfer_vcpu(vcpu, true, &local_err);
1229
1230         entry = g_malloc0(sizeof *entry);
1231         entry->value = vcpu;
1232
1233         *link = entry;
1234         link = &entry->next;
1235     }
1236
1237     if (local_err == NULL) {
1238         /* there's no guest with zero VCPUs */
1239         g_assert(head != NULL);
1240         return head;
1241     }
1242
1243     qapi_free_GuestLogicalProcessorList(head);
1244     error_propagate(errp, local_err);
1245     return NULL;
1246 }
1247
1248 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp)
1249 {
1250     int64_t processed;
1251     Error *local_err = NULL;
1252
1253     processed = 0;
1254     while (vcpus != NULL) {
1255         transfer_vcpu(vcpus->value, false, &local_err);
1256         if (local_err != NULL) {
1257             break;
1258         }
1259         ++processed;
1260         vcpus = vcpus->next;
1261     }
1262
1263     if (local_err != NULL) {
1264         if (processed == 0) {
1265             error_propagate(errp, local_err);
1266         } else {
1267             error_free(local_err);
1268         }
1269     }
1270
1271     return processed;
1272 }
1273
1274 #else /* defined(__linux__) */
1275
1276 void qmp_guest_suspend_disk(Error **err)
1277 {
1278     error_set(err, QERR_UNSUPPORTED);
1279 }
1280
1281 void qmp_guest_suspend_ram(Error **err)
1282 {
1283     error_set(err, QERR_UNSUPPORTED);
1284 }
1285
1286 void qmp_guest_suspend_hybrid(Error **err)
1287 {
1288     error_set(err, QERR_UNSUPPORTED);
1289 }
1290
1291 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
1292 {
1293     error_set(errp, QERR_UNSUPPORTED);
1294     return NULL;
1295 }
1296
1297 GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp)
1298 {
1299     error_set(errp, QERR_UNSUPPORTED);
1300     return NULL;
1301 }
1302
1303 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp)
1304 {
1305     error_set(errp, QERR_UNSUPPORTED);
1306     return -1;
1307 }
1308
1309 #endif
1310
1311 #if !defined(CONFIG_FSFREEZE)
1312
1313 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err)
1314 {
1315     error_set(err, QERR_UNSUPPORTED);
1316
1317     return 0;
1318 }
1319
1320 int64_t qmp_guest_fsfreeze_freeze(Error **err)
1321 {
1322     error_set(err, QERR_UNSUPPORTED);
1323
1324     return 0;
1325 }
1326
1327 int64_t qmp_guest_fsfreeze_thaw(Error **err)
1328 {
1329     error_set(err, QERR_UNSUPPORTED);
1330
1331     return 0;
1332 }
1333 #endif /* CONFIG_FSFREEZE */
1334
1335 #if !defined(CONFIG_FSTRIM)
1336 void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **err)
1337 {
1338     error_set(err, QERR_UNSUPPORTED);
1339 }
1340 #endif
1341
1342 /* register init/cleanup routines for stateful command groups */
1343 void ga_command_state_init(GAState *s, GACommandState *cs)
1344 {
1345 #if defined(CONFIG_FSFREEZE)
1346     ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup);
1347 #endif
1348     ga_command_state_add(cs, guest_file_init, NULL);
1349 }