Return to commands-posix.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / qga

Annotation of qemu/qga/commands-posix.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * QEMU Guest Agent POSIX-specific command implementations
        !             3:  *
        !             4:  * Copyright IBM Corp. 2011
        !             5:  *
        !             6:  * Authors:
        !             7:  *  Michael Roth      <[email protected]>
        !             8:  *  Michal Privoznik  <[email protected]>
        !             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 "qga/guest-agent-core.h"
        !            19: #include "qga-qmp-commands.h"
        !            20: #include "qerror.h"
        !            21: #include "qemu-queue.h"
        !            22: #include "host-utils.h"
        !            23: 
        !            24: #ifndef CONFIG_HAS_ENVIRON
        !            25: #ifdef __APPLE__
        !            26: #include <crt_externs.h>
        !            27: #define environ (*_NSGetEnviron())
        !            28: #else
        !            29: extern char **environ;
        !            30: #endif
        !            31: #endif
        !            32: 
        !            33: #if defined(__linux__)
        !            34: #include <mntent.h>
        !            35: #include <linux/fs.h>
        !            36: #include <ifaddrs.h>
        !            37: #include <arpa/inet.h>
        !            38: #include <sys/socket.h>
        !            39: #include <net/if.h>
        !            40: 
        !            41: #if defined(__linux__) && defined(FIFREEZE)
        !            42: #define CONFIG_FSFREEZE
        !            43: #endif
        !            44: #endif
        !            45: 
        !            46: void qmp_guest_shutdown(bool has_mode, const char *mode, Error **err)
        !            47: {
        !            48:     const char *shutdown_flag;
        !            49:     pid_t rpid, pid;
        !            50:     int status;
        !            51: 
        !            52:     slog("guest-shutdown called, mode: %s", mode);
        !            53:     if (!has_mode || strcmp(mode, "powerdown") == 0) {
        !            54:         shutdown_flag = "-P";
        !            55:     } else if (strcmp(mode, "halt") == 0) {
        !            56:         shutdown_flag = "-H";
        !            57:     } else if (strcmp(mode, "reboot") == 0) {
        !            58:         shutdown_flag = "-r";
        !            59:     } else {
        !            60:         error_set(err, QERR_INVALID_PARAMETER_VALUE, "mode",
        !            61:                   "halt|powerdown|reboot");
        !            62:         return;
        !            63:     }
        !            64: 
        !            65:     pid = fork();
        !            66:     if (pid == 0) {
        !            67:         /* child, start the shutdown */
        !            68:         setsid();
        !            69:         reopen_fd_to_null(0);
        !            70:         reopen_fd_to_null(1);
        !            71:         reopen_fd_to_null(2);
        !            72: 
        !            73:         execle("/sbin/shutdown", "shutdown", shutdown_flag, "+0",
        !            74:                "hypervisor initiated shutdown", (char*)NULL, environ);
        !            75:         _exit(EXIT_FAILURE);
        !            76:     } else if (pid < 0) {
        !            77:         goto exit_err;
        !            78:     }
        !            79: 
        !            80:     do {
        !            81:         rpid = waitpid(pid, &status, 0);
        !            82:     } while (rpid == -1 && errno == EINTR);
        !            83:     if (rpid == pid && WIFEXITED(status) && !WEXITSTATUS(status)) {
        !            84:         return;
        !            85:     }
        !            86: 
        !            87: exit_err:
        !            88:     error_set(err, QERR_UNDEFINED_ERROR);
        !            89: }
        !            90: 
        !            91: typedef struct GuestFileHandle {
        !            92:     uint64_t id;
        !            93:     FILE *fh;
        !            94:     QTAILQ_ENTRY(GuestFileHandle) next;
        !            95: } GuestFileHandle;
        !            96: 
        !            97: static struct {
        !            98:     QTAILQ_HEAD(, GuestFileHandle) filehandles;
        !            99: } guest_file_state;
        !           100: 
        !           101: static void guest_file_handle_add(FILE *fh)
        !           102: {
        !           103:     GuestFileHandle *gfh;
        !           104: 
        !           105:     gfh = g_malloc0(sizeof(GuestFileHandle));
        !           106:     gfh->id = fileno(fh);
        !           107:     gfh->fh = fh;
        !           108:     QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);
        !           109: }
        !           110: 
        !           111: static GuestFileHandle *guest_file_handle_find(int64_t id)
        !           112: {
        !           113:     GuestFileHandle *gfh;
        !           114: 
        !           115:     QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next)
        !           116:     {
        !           117:         if (gfh->id == id) {
        !           118:             return gfh;
        !           119:         }
        !           120:     }
        !           121: 
        !           122:     return NULL;
        !           123: }
        !           124: 
        !           125: int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, Error **err)
        !           126: {
        !           127:     FILE *fh;
        !           128:     int fd;
        !           129:     int64_t ret = -1;
        !           130: 
        !           131:     if (!has_mode) {
        !           132:         mode = "r";
        !           133:     }
        !           134:     slog("guest-file-open called, filepath: %s, mode: %s", path, mode);
        !           135:     fh = fopen(path, mode);
        !           136:     if (!fh) {
        !           137:         error_set(err, QERR_OPEN_FILE_FAILED, path);
        !           138:         return -1;
        !           139:     }
        !           140: 
        !           141:     /* set fd non-blocking to avoid common use cases (like reading from a
        !           142:      * named pipe) from hanging the agent
        !           143:      */
        !           144:     fd = fileno(fh);
        !           145:     ret = fcntl(fd, F_GETFL);
        !           146:     ret = fcntl(fd, F_SETFL, ret | O_NONBLOCK);
        !           147:     if (ret == -1) {
        !           148:         error_set(err, QERR_QGA_COMMAND_FAILED, "fcntl() failed");
        !           149:         fclose(fh);
        !           150:         return -1;
        !           151:     }
        !           152: 
        !           153:     guest_file_handle_add(fh);
        !           154:     slog("guest-file-open, handle: %d", fd);
        !           155:     return fd;
        !           156: }
        !           157: 
        !           158: void qmp_guest_file_close(int64_t handle, Error **err)
        !           159: {
        !           160:     GuestFileHandle *gfh = guest_file_handle_find(handle);
        !           161:     int ret;
        !           162: 
        !           163:     slog("guest-file-close called, handle: %ld", handle);
        !           164:     if (!gfh) {
        !           165:         error_set(err, QERR_FD_NOT_FOUND, "handle");
        !           166:         return;
        !           167:     }
        !           168: 
        !           169:     ret = fclose(gfh->fh);
        !           170:     if (ret == -1) {
        !           171:         error_set(err, QERR_QGA_COMMAND_FAILED, "fclose() failed");
        !           172:         return;
        !           173:     }
        !           174: 
        !           175:     QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next);
        !           176:     g_free(gfh);
        !           177: }
        !           178: 
        !           179: struct GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count,
        !           180:                                           int64_t count, Error **err)
        !           181: {
        !           182:     GuestFileHandle *gfh = guest_file_handle_find(handle);
        !           183:     GuestFileRead *read_data = NULL;
        !           184:     guchar *buf;
        !           185:     FILE *fh;
        !           186:     size_t read_count;
        !           187: 
        !           188:     if (!gfh) {
        !           189:         error_set(err, QERR_FD_NOT_FOUND, "handle");
        !           190:         return NULL;
        !           191:     }
        !           192: 
        !           193:     if (!has_count) {
        !           194:         count = QGA_READ_COUNT_DEFAULT;
        !           195:     } else if (count < 0) {
        !           196:         error_set(err, QERR_INVALID_PARAMETER, "count");
        !           197:         return NULL;
        !           198:     }
        !           199: 
        !           200:     fh = gfh->fh;
        !           201:     buf = g_malloc0(count+1);
        !           202:     read_count = fread(buf, 1, count, fh);
        !           203:     if (ferror(fh)) {
        !           204:         slog("guest-file-read failed, handle: %ld", handle);
        !           205:         error_set(err, QERR_QGA_COMMAND_FAILED, "fread() failed");
        !           206:     } else {
        !           207:         buf[read_count] = 0;
        !           208:         read_data = g_malloc0(sizeof(GuestFileRead));
        !           209:         read_data->count = read_count;
        !           210:         read_data->eof = feof(fh);
        !           211:         if (read_count) {
        !           212:             read_data->buf_b64 = g_base64_encode(buf, read_count);
        !           213:         }
        !           214:     }
        !           215:     g_free(buf);
        !           216:     clearerr(fh);
        !           217: 
        !           218:     return read_data;
        !           219: }
        !           220: 
        !           221: GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
        !           222:                                      bool has_count, int64_t count, Error **err)
        !           223: {
        !           224:     GuestFileWrite *write_data = NULL;
        !           225:     guchar *buf;
        !           226:     gsize buf_len;
        !           227:     int write_count;
        !           228:     GuestFileHandle *gfh = guest_file_handle_find(handle);
        !           229:     FILE *fh;
        !           230: 
        !           231:     if (!gfh) {
        !           232:         error_set(err, QERR_FD_NOT_FOUND, "handle");
        !           233:         return NULL;
        !           234:     }
        !           235: 
        !           236:     fh = gfh->fh;
        !           237:     buf = g_base64_decode(buf_b64, &buf_len);
        !           238: 
        !           239:     if (!has_count) {
        !           240:         count = buf_len;
        !           241:     } else if (count < 0 || count > buf_len) {
        !           242:         g_free(buf);
        !           243:         error_set(err, QERR_INVALID_PARAMETER, "count");
        !           244:         return NULL;
        !           245:     }
        !           246: 
        !           247:     write_count = fwrite(buf, 1, count, fh);
        !           248:     if (ferror(fh)) {
        !           249:         slog("guest-file-write failed, handle: %ld", handle);
        !           250:         error_set(err, QERR_QGA_COMMAND_FAILED, "fwrite() error");
        !           251:     } else {
        !           252:         write_data = g_malloc0(sizeof(GuestFileWrite));
        !           253:         write_data->count = write_count;
        !           254:         write_data->eof = feof(fh);
        !           255:     }
        !           256:     g_free(buf);
        !           257:     clearerr(fh);
        !           258: 
        !           259:     return write_data;
        !           260: }
        !           261: 
        !           262: struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
        !           263:                                           int64_t whence, Error **err)
        !           264: {
        !           265:     GuestFileHandle *gfh = guest_file_handle_find(handle);
        !           266:     GuestFileSeek *seek_data = NULL;
        !           267:     FILE *fh;
        !           268:     int ret;
        !           269: 
        !           270:     if (!gfh) {
        !           271:         error_set(err, QERR_FD_NOT_FOUND, "handle");
        !           272:         return NULL;
        !           273:     }
        !           274: 
        !           275:     fh = gfh->fh;
        !           276:     ret = fseek(fh, offset, whence);
        !           277:     if (ret == -1) {
        !           278:         error_set(err, QERR_QGA_COMMAND_FAILED, strerror(errno));
        !           279:     } else {
        !           280:         seek_data = g_malloc0(sizeof(GuestFileRead));
        !           281:         seek_data->position = ftell(fh);
        !           282:         seek_data->eof = feof(fh);
        !           283:     }
        !           284:     clearerr(fh);
        !           285: 
        !           286:     return seek_data;
        !           287: }
        !           288: 
        !           289: void qmp_guest_file_flush(int64_t handle, Error **err)
        !           290: {
        !           291:     GuestFileHandle *gfh = guest_file_handle_find(handle);
        !           292:     FILE *fh;
        !           293:     int ret;
        !           294: 
        !           295:     if (!gfh) {
        !           296:         error_set(err, QERR_FD_NOT_FOUND, "handle");
        !           297:         return;
        !           298:     }
        !           299: 
        !           300:     fh = gfh->fh;
        !           301:     ret = fflush(fh);
        !           302:     if (ret == EOF) {
        !           303:         error_set(err, QERR_QGA_COMMAND_FAILED, strerror(errno));
        !           304:     }
        !           305: }
        !           306: 
        !           307: static void guest_file_init(void)
        !           308: {
        !           309:     QTAILQ_INIT(&guest_file_state.filehandles);
        !           310: }
        !           311: 
        !           312: /* linux-specific implementations. avoid this if at all possible. */
        !           313: #if defined(__linux__)
        !           314: 
        !           315: #if defined(CONFIG_FSFREEZE)
        !           316: 
        !           317: typedef struct GuestFsfreezeMount {
        !           318:     char *dirname;
        !           319:     char *devtype;
        !           320:     QTAILQ_ENTRY(GuestFsfreezeMount) next;
        !           321: } GuestFsfreezeMount;
        !           322: 
        !           323: typedef QTAILQ_HEAD(, GuestFsfreezeMount) GuestFsfreezeMountList;
        !           324: 
        !           325: static void guest_fsfreeze_free_mount_list(GuestFsfreezeMountList *mounts)
        !           326: {
        !           327:      GuestFsfreezeMount *mount, *temp;
        !           328: 
        !           329:      if (!mounts) {
        !           330:          return;
        !           331:      }
        !           332: 
        !           333:      QTAILQ_FOREACH_SAFE(mount, mounts, next, temp) {
        !           334:          QTAILQ_REMOVE(mounts, mount, next);
        !           335:          g_free(mount->dirname);
        !           336:          g_free(mount->devtype);
        !           337:          g_free(mount);
        !           338:      }
        !           339: }
        !           340: 
        !           341: /*
        !           342:  * Walk the mount table and build a list of local file systems
        !           343:  */
        !           344: static int guest_fsfreeze_build_mount_list(GuestFsfreezeMountList *mounts)
        !           345: {
        !           346:     struct mntent *ment;
        !           347:     GuestFsfreezeMount *mount;
        !           348:     char const *mtab = "/proc/self/mounts";
        !           349:     FILE *fp;
        !           350: 
        !           351:     fp = setmntent(mtab, "r");
        !           352:     if (!fp) {
        !           353:         g_warning("fsfreeze: unable to read mtab");
        !           354:         return -1;
        !           355:     }
        !           356: 
        !           357:     while ((ment = getmntent(fp))) {
        !           358:         /*
        !           359:          * An entry which device name doesn't start with a '/' is
        !           360:          * either a dummy file system or a network file system.
        !           361:          * Add special handling for smbfs and cifs as is done by
        !           362:          * coreutils as well.
        !           363:          */
        !           364:         if ((ment->mnt_fsname[0] != '/') ||
        !           365:             (strcmp(ment->mnt_type, "smbfs") == 0) ||
        !           366:             (strcmp(ment->mnt_type, "cifs") == 0)) {
        !           367:             continue;
        !           368:         }
        !           369: 
        !           370:         mount = g_malloc0(sizeof(GuestFsfreezeMount));
        !           371:         mount->dirname = g_strdup(ment->mnt_dir);
        !           372:         mount->devtype = g_strdup(ment->mnt_type);
        !           373: 
        !           374:         QTAILQ_INSERT_TAIL(mounts, mount, next);
        !           375:     }
        !           376: 
        !           377:     endmntent(fp);
        !           378: 
        !           379:     return 0;
        !           380: }
        !           381: 
        !           382: /*
        !           383:  * Return status of freeze/thaw
        !           384:  */
        !           385: GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err)
        !           386: {
        !           387:     if (ga_is_frozen(ga_state)) {
        !           388:         return GUEST_FSFREEZE_STATUS_FROZEN;
        !           389:     }
        !           390: 
        !           391:     return GUEST_FSFREEZE_STATUS_THAWED;
        !           392: }
        !           393: 
        !           394: /*
        !           395:  * Walk list of mounted file systems in the guest, and freeze the ones which
        !           396:  * are real local file systems.
        !           397:  */
        !           398: int64_t qmp_guest_fsfreeze_freeze(Error **err)
        !           399: {
        !           400:     int ret = 0, i = 0;
        !           401:     GuestFsfreezeMountList mounts;
        !           402:     struct GuestFsfreezeMount *mount;
        !           403:     int fd;
        !           404:     char err_msg[512];
        !           405: 
        !           406:     slog("guest-fsfreeze called");
        !           407: 
        !           408:     QTAILQ_INIT(&mounts);
        !           409:     ret = guest_fsfreeze_build_mount_list(&mounts);
        !           410:     if (ret < 0) {
        !           411:         return ret;
        !           412:     }
        !           413: 
        !           414:     /* cannot risk guest agent blocking itself on a write in this state */
        !           415:     ga_set_frozen(ga_state);
        !           416: 
        !           417:     QTAILQ_FOREACH(mount, &mounts, next) {
        !           418:         fd = qemu_open(mount->dirname, O_RDONLY);
        !           419:         if (fd == -1) {
        !           420:             sprintf(err_msg, "failed to open %s, %s", mount->dirname,
        !           421:                     strerror(errno));
        !           422:             error_set(err, QERR_QGA_COMMAND_FAILED, err_msg);
        !           423:             goto error;
        !           424:         }
        !           425: 
        !           426:         /* we try to cull filesytems we know won't work in advance, but other
        !           427:          * filesytems may not implement fsfreeze for less obvious reasons.
        !           428:          * these will report EOPNOTSUPP. we simply ignore these when tallying
        !           429:          * the number of frozen filesystems.
        !           430:          *
        !           431:          * any other error means a failure to freeze a filesystem we
        !           432:          * expect to be freezable, so return an error in those cases
        !           433:          * and return system to thawed state.
        !           434:          */
        !           435:         ret = ioctl(fd, FIFREEZE);
        !           436:         if (ret == -1) {
        !           437:             if (errno != EOPNOTSUPP) {
        !           438:                 sprintf(err_msg, "failed to freeze %s, %s",
        !           439:                         mount->dirname, strerror(errno));
        !           440:                 error_set(err, QERR_QGA_COMMAND_FAILED, err_msg);
        !           441:                 close(fd);
        !           442:                 goto error;
        !           443:             }
        !           444:         } else {
        !           445:             i++;
        !           446:         }
        !           447:         close(fd);
        !           448:     }
        !           449: 
        !           450:     guest_fsfreeze_free_mount_list(&mounts);
        !           451:     return i;
        !           452: 
        !           453: error:
        !           454:     guest_fsfreeze_free_mount_list(&mounts);
        !           455:     qmp_guest_fsfreeze_thaw(NULL);
        !           456:     return 0;
        !           457: }
        !           458: 
        !           459: /*
        !           460:  * Walk list of frozen file systems in the guest, and thaw them.
        !           461:  */
        !           462: int64_t qmp_guest_fsfreeze_thaw(Error **err)
        !           463: {
        !           464:     int ret;
        !           465:     GuestFsfreezeMountList mounts;
        !           466:     GuestFsfreezeMount *mount;
        !           467:     int fd, i = 0, logged;
        !           468: 
        !           469:     QTAILQ_INIT(&mounts);
        !           470:     ret = guest_fsfreeze_build_mount_list(&mounts);
        !           471:     if (ret) {
        !           472:         error_set(err, QERR_QGA_COMMAND_FAILED,
        !           473:                   "failed to enumerate filesystems");
        !           474:         return 0;
        !           475:     }
        !           476: 
        !           477:     QTAILQ_FOREACH(mount, &mounts, next) {
        !           478:         logged = false;
        !           479:         fd = qemu_open(mount->dirname, O_RDONLY);
        !           480:         if (fd == -1) {
        !           481:             continue;
        !           482:         }
        !           483:         /* we have no way of knowing whether a filesystem was actually unfrozen
        !           484:          * as a result of a successful call to FITHAW, only that if an error
        !           485:          * was returned the filesystem was *not* unfrozen by that particular
        !           486:          * call.
        !           487:          *
        !           488:          * since multiple preceding FIFREEZEs require multiple calls to FITHAW
        !           489:          * to unfreeze, continuing issuing FITHAW until an error is returned,
        !           490:          * in which case either the filesystem is in an unfreezable state, or,
        !           491:          * more likely, it was thawed previously (and remains so afterward).
        !           492:          *
        !           493:          * also, since the most recent successful call is the one that did
        !           494:          * the actual unfreeze, we can use this to provide an accurate count
        !           495:          * of the number of filesystems unfrozen by guest-fsfreeze-thaw, which
        !           496:          * may * be useful for determining whether a filesystem was unfrozen
        !           497:          * during the freeze/thaw phase by a process other than qemu-ga.
        !           498:          */
        !           499:         do {
        !           500:             ret = ioctl(fd, FITHAW);
        !           501:             if (ret == 0 && !logged) {
        !           502:                 i++;
        !           503:                 logged = true;
        !           504:             }
        !           505:         } while (ret == 0);
        !           506:         close(fd);
        !           507:     }
        !           508: 
        !           509:     ga_unset_frozen(ga_state);
        !           510:     guest_fsfreeze_free_mount_list(&mounts);
        !           511:     return i;
        !           512: }
        !           513: 
        !           514: static void guest_fsfreeze_cleanup(void)
        !           515: {
        !           516:     int64_t ret;
        !           517:     Error *err = NULL;
        !           518: 
        !           519:     if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) {
        !           520:         ret = qmp_guest_fsfreeze_thaw(&err);
        !           521:         if (ret < 0 || err) {
        !           522:             slog("failed to clean up frozen filesystems");
        !           523:         }
        !           524:     }
        !           525: }
        !           526: #endif /* CONFIG_FSFREEZE */
        !           527: 
        !           528: #define LINUX_SYS_STATE_FILE "/sys/power/state"
        !           529: #define SUSPEND_SUPPORTED 0
        !           530: #define SUSPEND_NOT_SUPPORTED 1
        !           531: 
        !           532: static void bios_supports_mode(const char *pmutils_bin, const char *pmutils_arg,
        !           533:                                const char *sysfile_str, Error **err)
        !           534: {
        !           535:     char *pmutils_path;
        !           536:     pid_t pid, rpid;
        !           537:     int status;
        !           538: 
        !           539:     pmutils_path = g_find_program_in_path(pmutils_bin);
        !           540: 
        !           541:     pid = fork();
        !           542:     if (!pid) {
        !           543:         char buf[32]; /* hopefully big enough */
        !           544:         ssize_t ret;
        !           545:         int fd;
        !           546: 
        !           547:         setsid();
        !           548:         reopen_fd_to_null(0);
        !           549:         reopen_fd_to_null(1);
        !           550:         reopen_fd_to_null(2);
        !           551: 
        !           552:         if (pmutils_path) {
        !           553:             execle(pmutils_path, pmutils_bin, pmutils_arg, NULL, environ);
        !           554:         }
        !           555: 
        !           556:         /*
        !           557:          * If we get here either pm-utils is not installed or execle() has
        !           558:          * failed. Let's try the manual method if the caller wants it.
        !           559:          */
        !           560: 
        !           561:         if (!sysfile_str) {
        !           562:             _exit(SUSPEND_NOT_SUPPORTED);
        !           563:         }
        !           564: 
        !           565:         fd = open(LINUX_SYS_STATE_FILE, O_RDONLY);
        !           566:         if (fd < 0) {
        !           567:             _exit(SUSPEND_NOT_SUPPORTED);
        !           568:         }
        !           569: 
        !           570:         ret = read(fd, buf, sizeof(buf)-1);
        !           571:         if (ret <= 0) {
        !           572:             _exit(SUSPEND_NOT_SUPPORTED);
        !           573:         }
        !           574:         buf[ret] = '\0';
        !           575: 
        !           576:         if (strstr(buf, sysfile_str)) {
        !           577:             _exit(SUSPEND_SUPPORTED);
        !           578:         }
        !           579: 
        !           580:         _exit(SUSPEND_NOT_SUPPORTED);
        !           581:     }
        !           582: 
        !           583:     g_free(pmutils_path);
        !           584: 
        !           585:     if (pid < 0) {
        !           586:         goto undef_err;
        !           587:     }
        !           588: 
        !           589:     do {
        !           590:         rpid = waitpid(pid, &status, 0);
        !           591:     } while (rpid == -1 && errno == EINTR);
        !           592:     if (rpid == pid && WIFEXITED(status)) {
        !           593:         switch (WEXITSTATUS(status)) {
        !           594:         case SUSPEND_SUPPORTED:
        !           595:             return;
        !           596:         case SUSPEND_NOT_SUPPORTED:
        !           597:             error_set(err, QERR_UNSUPPORTED);
        !           598:             return;
        !           599:         default:
        !           600:             goto undef_err;
        !           601:         }
        !           602:     }
        !           603: 
        !           604: undef_err:
        !           605:     error_set(err, QERR_UNDEFINED_ERROR);
        !           606: }
        !           607: 
        !           608: static void guest_suspend(const char *pmutils_bin, const char *sysfile_str,
        !           609:                           Error **err)
        !           610: {
        !           611:     char *pmutils_path;
        !           612:     pid_t rpid, pid;
        !           613:     int status;
        !           614: 
        !           615:     pmutils_path = g_find_program_in_path(pmutils_bin);
        !           616: 
        !           617:     pid = fork();
        !           618:     if (pid == 0) {
        !           619:         /* child */
        !           620:         int fd;
        !           621: 
        !           622:         setsid();
        !           623:         reopen_fd_to_null(0);
        !           624:         reopen_fd_to_null(1);
        !           625:         reopen_fd_to_null(2);
        !           626: 
        !           627:         if (pmutils_path) {
        !           628:             execle(pmutils_path, pmutils_bin, NULL, environ);
        !           629:         }
        !           630: 
        !           631:         /*
        !           632:          * If we get here either pm-utils is not installed or execle() has
        !           633:          * failed. Let's try the manual method if the caller wants it.
        !           634:          */
        !           635: 
        !           636:         if (!sysfile_str) {
        !           637:             _exit(EXIT_FAILURE);
        !           638:         }
        !           639: 
        !           640:         fd = open(LINUX_SYS_STATE_FILE, O_WRONLY);
        !           641:         if (fd < 0) {
        !           642:             _exit(EXIT_FAILURE);
        !           643:         }
        !           644: 
        !           645:         if (write(fd, sysfile_str, strlen(sysfile_str)) < 0) {
        !           646:             _exit(EXIT_FAILURE);
        !           647:         }
        !           648: 
        !           649:         _exit(EXIT_SUCCESS);
        !           650:     }
        !           651: 
        !           652:     g_free(pmutils_path);
        !           653: 
        !           654:     if (pid < 0) {
        !           655:         goto exit_err;
        !           656:     }
        !           657: 
        !           658:     do {
        !           659:         rpid = waitpid(pid, &status, 0);
        !           660:     } while (rpid == -1 && errno == EINTR);
        !           661:     if (rpid == pid && WIFEXITED(status) && !WEXITSTATUS(status)) {
        !           662:         return;
        !           663:     }
        !           664: 
        !           665: exit_err:
        !           666:     error_set(err, QERR_UNDEFINED_ERROR);
        !           667: }
        !           668: 
        !           669: void qmp_guest_suspend_disk(Error **err)
        !           670: {
        !           671:     bios_supports_mode("pm-is-supported", "--hibernate", "disk", err);
        !           672:     if (error_is_set(err)) {
        !           673:         return;
        !           674:     }
        !           675: 
        !           676:     guest_suspend("pm-hibernate", "disk", err);
        !           677: }
        !           678: 
        !           679: void qmp_guest_suspend_ram(Error **err)
        !           680: {
        !           681:     bios_supports_mode("pm-is-supported", "--suspend", "mem", err);
        !           682:     if (error_is_set(err)) {
        !           683:         return;
        !           684:     }
        !           685: 
        !           686:     guest_suspend("pm-suspend", "mem", err);
        !           687: }
        !           688: 
        !           689: void qmp_guest_suspend_hybrid(Error **err)
        !           690: {
        !           691:     bios_supports_mode("pm-is-supported", "--suspend-hybrid", NULL, err);
        !           692:     if (error_is_set(err)) {
        !           693:         return;
        !           694:     }
        !           695: 
        !           696:     guest_suspend("pm-suspend-hybrid", NULL, err);
        !           697: }
        !           698: 
        !           699: static GuestNetworkInterfaceList *
        !           700: guest_find_interface(GuestNetworkInterfaceList *head,
        !           701:                      const char *name)
        !           702: {
        !           703:     for (; head; head = head->next) {
        !           704:         if (strcmp(head->value->name, name) == 0) {
        !           705:             break;
        !           706:         }
        !           707:     }
        !           708: 
        !           709:     return head;
        !           710: }
        !           711: 
        !           712: /*
        !           713:  * Build information about guest interfaces
        !           714:  */
        !           715: GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
        !           716: {
        !           717:     GuestNetworkInterfaceList *head = NULL, *cur_item = NULL;
        !           718:     struct ifaddrs *ifap, *ifa;
        !           719:     char err_msg[512];
        !           720: 
        !           721:     if (getifaddrs(&ifap) < 0) {
        !           722:         snprintf(err_msg, sizeof(err_msg),
        !           723:                  "getifaddrs failed: %s", strerror(errno));
        !           724:         error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
        !           725:         goto error;
        !           726:     }
        !           727: 
        !           728:     for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
        !           729:         GuestNetworkInterfaceList *info;
        !           730:         GuestIpAddressList **address_list = NULL, *address_item = NULL;
        !           731:         char addr4[INET_ADDRSTRLEN];
        !           732:         char addr6[INET6_ADDRSTRLEN];
        !           733:         int sock;
        !           734:         struct ifreq ifr;
        !           735:         unsigned char *mac_addr;
        !           736:         void *p;
        !           737: 
        !           738:         g_debug("Processing %s interface", ifa->ifa_name);
        !           739: 
        !           740:         info = guest_find_interface(head, ifa->ifa_name);
        !           741: 
        !           742:         if (!info) {
        !           743:             info = g_malloc0(sizeof(*info));
        !           744:             info->value = g_malloc0(sizeof(*info->value));
        !           745:             info->value->name = g_strdup(ifa->ifa_name);
        !           746: 
        !           747:             if (!cur_item) {
        !           748:                 head = cur_item = info;
        !           749:             } else {
        !           750:                 cur_item->next = info;
        !           751:                 cur_item = info;
        !           752:             }
        !           753:         }
        !           754: 
        !           755:         if (!info->value->has_hardware_address &&
        !           756:             ifa->ifa_flags & SIOCGIFHWADDR) {
        !           757:             /* we haven't obtained HW address yet */
        !           758:             sock = socket(PF_INET, SOCK_STREAM, 0);
        !           759:             if (sock == -1) {
        !           760:                 snprintf(err_msg, sizeof(err_msg),
        !           761:                          "failed to create socket: %s", strerror(errno));
        !           762:                 error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
        !           763:                 goto error;
        !           764:             }
        !           765: 
        !           766:             memset(&ifr, 0, sizeof(ifr));
        !           767:             strncpy(ifr.ifr_name,  info->value->name, IF_NAMESIZE);
        !           768:             if (ioctl(sock, SIOCGIFHWADDR, &ifr) == -1) {
        !           769:                 snprintf(err_msg, sizeof(err_msg),
        !           770:                          "failed to get MAC address of %s: %s",
        !           771:                          ifa->ifa_name,
        !           772:                          strerror(errno));
        !           773:                 error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
        !           774:                 goto error;
        !           775:             }
        !           776: 
        !           777:             mac_addr = (unsigned char *) &ifr.ifr_hwaddr.sa_data;
        !           778: 
        !           779:             if (asprintf(&info->value->hardware_address,
        !           780:                          "%02x:%02x:%02x:%02x:%02x:%02x",
        !           781:                          (int) mac_addr[0], (int) mac_addr[1],
        !           782:                          (int) mac_addr[2], (int) mac_addr[3],
        !           783:                          (int) mac_addr[4], (int) mac_addr[5]) == -1) {
        !           784:                 snprintf(err_msg, sizeof(err_msg),
        !           785:                          "failed to format MAC: %s", strerror(errno));
        !           786:                 error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
        !           787:                 goto error;
        !           788:             }
        !           789: 
        !           790:             info->value->has_hardware_address = true;
        !           791:             close(sock);
        !           792:         }
        !           793: 
        !           794:         if (ifa->ifa_addr &&
        !           795:             ifa->ifa_addr->sa_family == AF_INET) {
        !           796:             /* interface with IPv4 address */
        !           797:             address_item = g_malloc0(sizeof(*address_item));
        !           798:             address_item->value = g_malloc0(sizeof(*address_item->value));
        !           799:             p = &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
        !           800:             if (!inet_ntop(AF_INET, p, addr4, sizeof(addr4))) {
        !           801:                 snprintf(err_msg, sizeof(err_msg),
        !           802:                          "inet_ntop failed : %s", strerror(errno));
        !           803:                 error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
        !           804:                 goto error;
        !           805:             }
        !           806: 
        !           807:             address_item->value->ip_address = g_strdup(addr4);
        !           808:             address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4;
        !           809: 
        !           810:             if (ifa->ifa_netmask) {
        !           811:                 /* Count the number of set bits in netmask.
        !           812:                  * This is safe as '1' and '0' cannot be shuffled in netmask. */
        !           813:                 p = &((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr;
        !           814:                 address_item->value->prefix = ctpop32(((uint32_t *) p)[0]);
        !           815:             }
        !           816:         } else if (ifa->ifa_addr &&
        !           817:                    ifa->ifa_addr->sa_family == AF_INET6) {
        !           818:             /* interface with IPv6 address */
        !           819:             address_item = g_malloc0(sizeof(*address_item));
        !           820:             address_item->value = g_malloc0(sizeof(*address_item->value));
        !           821:             p = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr;
        !           822:             if (!inet_ntop(AF_INET6, p, addr6, sizeof(addr6))) {
        !           823:                 snprintf(err_msg, sizeof(err_msg),
        !           824:                          "inet_ntop failed : %s", strerror(errno));
        !           825:                 error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
        !           826:                 goto error;
        !           827:             }
        !           828: 
        !           829:             address_item->value->ip_address = g_strdup(addr6);
        !           830:             address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6;
        !           831: 
        !           832:             if (ifa->ifa_netmask) {
        !           833:                 /* Count the number of set bits in netmask.
        !           834:                  * This is safe as '1' and '0' cannot be shuffled in netmask. */
        !           835:                 p = &((struct sockaddr_in6 *)ifa->ifa_netmask)->sin6_addr;
        !           836:                 address_item->value->prefix =
        !           837:                     ctpop32(((uint32_t *) p)[0]) +
        !           838:                     ctpop32(((uint32_t *) p)[1]) +
        !           839:                     ctpop32(((uint32_t *) p)[2]) +
        !           840:                     ctpop32(((uint32_t *) p)[3]);
        !           841:             }
        !           842:         }
        !           843: 
        !           844:         if (!address_item) {
        !           845:             continue;
        !           846:         }
        !           847: 
        !           848:         address_list = &info->value->ip_addresses;
        !           849: 
        !           850:         while (*address_list && (*address_list)->next) {
        !           851:             address_list = &(*address_list)->next;
        !           852:         }
        !           853: 
        !           854:         if (!*address_list) {
        !           855:             *address_list = address_item;
        !           856:         } else {
        !           857:             (*address_list)->next = address_item;
        !           858:         }
        !           859: 
        !           860:         info->value->has_ip_addresses = true;
        !           861: 
        !           862: 
        !           863:     }
        !           864: 
        !           865:     freeifaddrs(ifap);
        !           866:     return head;
        !           867: 
        !           868: error:
        !           869:     freeifaddrs(ifap);
        !           870:     qapi_free_GuestNetworkInterfaceList(head);
        !           871:     return NULL;
        !           872: }
        !           873: 
        !           874: #else /* defined(__linux__) */
        !           875: 
        !           876: void qmp_guest_suspend_disk(Error **err)
        !           877: {
        !           878:     error_set(err, QERR_UNSUPPORTED);
        !           879: }
        !           880: 
        !           881: void qmp_guest_suspend_ram(Error **err)
        !           882: {
        !           883:     error_set(err, QERR_UNSUPPORTED);
        !           884: }
        !           885: 
        !           886: void qmp_guest_suspend_hybrid(Error **err)
        !           887: {
        !           888:     error_set(err, QERR_UNSUPPORTED);
        !           889: }
        !           890: 
        !           891: GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
        !           892: {
        !           893:     error_set(errp, QERR_UNSUPPORTED);
        !           894:     return NULL;
        !           895: }
        !           896: 
        !           897: #endif
        !           898: 
        !           899: #if !defined(CONFIG_FSFREEZE)
        !           900: 
        !           901: GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err)
        !           902: {
        !           903:     error_set(err, QERR_UNSUPPORTED);
        !           904: 
        !           905:     return 0;
        !           906: }
        !           907: 
        !           908: int64_t qmp_guest_fsfreeze_freeze(Error **err)
        !           909: {
        !           910:     error_set(err, QERR_UNSUPPORTED);
        !           911: 
        !           912:     return 0;
        !           913: }
        !           914: 
        !           915: int64_t qmp_guest_fsfreeze_thaw(Error **err)
        !           916: {
        !           917:     error_set(err, QERR_UNSUPPORTED);
        !           918: 
        !           919:     return 0;
        !           920: }
        !           921: 
        !           922: #endif
        !           923: 
        !           924: /* register init/cleanup routines for stateful command groups */
        !           925: void ga_command_state_init(GAState *s, GACommandState *cs)
        !           926: {
        !           927: #if defined(CONFIG_FSFREEZE)
        !           928:     ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup);
        !           929: #endif
        !           930:     ga_command_state_add(cs, guest_file_init, NULL);
        !           931: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.