2 * QEMU Guest Agent POSIX-specific command implementations
4 * Copyright IBM Corp. 2011
7 * Michael Roth <mdroth@linux.vnet.ibm.com>
8 * Michal Privoznik <mprivozn@redhat.com>
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.
15 #include <sys/types.h>
16 #include <sys/ioctl.h>
17 #include "qga/guest-agent-core.h"
18 #include "qga-qmp-commands.h"
20 #include "qemu-queue.h"
21 #include "host-utils.h"
23 #if defined(__linux__)
27 #include <arpa/inet.h>
28 #include <sys/socket.h>
32 #if defined(__linux__) && defined(FIFREEZE)
33 #define CONFIG_FSFREEZE
37 #if defined(__linux__)
38 /* TODO: use this in place of all post-fork() fclose(std*) callers */
39 static void reopen_fd_to_null(int fd
)
43 nullfd
= open("/dev/null", O_RDWR
);
54 #endif /* defined(__linux__) */
56 void qmp_guest_shutdown(bool has_mode
, const char *mode
, Error
**err
)
59 const char *shutdown_flag
;
61 slog("guest-shutdown called, mode: %s", mode
);
62 if (!has_mode
|| strcmp(mode
, "powerdown") == 0) {
64 } else if (strcmp(mode
, "halt") == 0) {
66 } else if (strcmp(mode
, "reboot") == 0) {
69 error_set(err
, QERR_INVALID_PARAMETER_VALUE
, "mode",
70 "halt|powerdown|reboot");
76 /* child, start the shutdown */
82 ret
= execl("/sbin/shutdown", "shutdown", shutdown_flag
, "+0",
83 "hypervisor initiated shutdown", (char*)NULL
);
85 slog("guest-shutdown failed: %s", strerror(errno
));
89 error_set(err
, QERR_UNDEFINED_ERROR
);
93 typedef struct GuestFileHandle
{
96 QTAILQ_ENTRY(GuestFileHandle
) next
;
100 QTAILQ_HEAD(, GuestFileHandle
) filehandles
;
103 static void guest_file_handle_add(FILE *fh
)
105 GuestFileHandle
*gfh
;
107 gfh
= g_malloc0(sizeof(GuestFileHandle
));
108 gfh
->id
= fileno(fh
);
110 QTAILQ_INSERT_TAIL(&guest_file_state
.filehandles
, gfh
, next
);
113 static GuestFileHandle
*guest_file_handle_find(int64_t id
)
115 GuestFileHandle
*gfh
;
117 QTAILQ_FOREACH(gfh
, &guest_file_state
.filehandles
, next
)
127 int64_t qmp_guest_file_open(const char *path
, bool has_mode
, const char *mode
, Error
**err
)
136 slog("guest-file-open called, filepath: %s, mode: %s", path
, mode
);
137 fh
= fopen(path
, mode
);
139 error_set(err
, QERR_OPEN_FILE_FAILED
, path
);
143 /* set fd non-blocking to avoid common use cases (like reading from a
144 * named pipe) from hanging the agent
147 ret
= fcntl(fd
, F_GETFL
);
148 ret
= fcntl(fd
, F_SETFL
, ret
| O_NONBLOCK
);
150 error_set(err
, QERR_QGA_COMMAND_FAILED
, "fcntl() failed");
155 guest_file_handle_add(fh
);
156 slog("guest-file-open, handle: %d", fd
);
160 void qmp_guest_file_close(int64_t handle
, Error
**err
)
162 GuestFileHandle
*gfh
= guest_file_handle_find(handle
);
165 slog("guest-file-close called, handle: %ld", handle
);
167 error_set(err
, QERR_FD_NOT_FOUND
, "handle");
171 ret
= fclose(gfh
->fh
);
173 error_set(err
, QERR_QGA_COMMAND_FAILED
, "fclose() failed");
177 QTAILQ_REMOVE(&guest_file_state
.filehandles
, gfh
, next
);
181 struct GuestFileRead
*qmp_guest_file_read(int64_t handle
, bool has_count
,
182 int64_t count
, Error
**err
)
184 GuestFileHandle
*gfh
= guest_file_handle_find(handle
);
185 GuestFileRead
*read_data
= NULL
;
191 error_set(err
, QERR_FD_NOT_FOUND
, "handle");
196 count
= QGA_READ_COUNT_DEFAULT
;
197 } else if (count
< 0) {
198 error_set(err
, QERR_INVALID_PARAMETER
, "count");
203 buf
= g_malloc0(count
+1);
204 read_count
= fread(buf
, 1, count
, fh
);
206 slog("guest-file-read failed, handle: %ld", handle
);
207 error_set(err
, QERR_QGA_COMMAND_FAILED
, "fread() failed");
210 read_data
= g_malloc0(sizeof(GuestFileRead
));
211 read_data
->count
= read_count
;
212 read_data
->eof
= feof(fh
);
214 read_data
->buf_b64
= g_base64_encode(buf
, read_count
);
223 GuestFileWrite
*qmp_guest_file_write(int64_t handle
, const char *buf_b64
,
224 bool has_count
, int64_t count
, Error
**err
)
226 GuestFileWrite
*write_data
= NULL
;
230 GuestFileHandle
*gfh
= guest_file_handle_find(handle
);
234 error_set(err
, QERR_FD_NOT_FOUND
, "handle");
239 buf
= g_base64_decode(buf_b64
, &buf_len
);
243 } else if (count
< 0 || count
> buf_len
) {
245 error_set(err
, QERR_INVALID_PARAMETER
, "count");
249 write_count
= fwrite(buf
, 1, count
, fh
);
251 slog("guest-file-write failed, handle: %ld", handle
);
252 error_set(err
, QERR_QGA_COMMAND_FAILED
, "fwrite() error");
254 write_data
= g_malloc0(sizeof(GuestFileWrite
));
255 write_data
->count
= write_count
;
256 write_data
->eof
= feof(fh
);
264 struct GuestFileSeek
*qmp_guest_file_seek(int64_t handle
, int64_t offset
,
265 int64_t whence
, Error
**err
)
267 GuestFileHandle
*gfh
= guest_file_handle_find(handle
);
268 GuestFileSeek
*seek_data
= NULL
;
273 error_set(err
, QERR_FD_NOT_FOUND
, "handle");
278 ret
= fseek(fh
, offset
, whence
);
280 error_set(err
, QERR_QGA_COMMAND_FAILED
, strerror(errno
));
282 seek_data
= g_malloc0(sizeof(GuestFileRead
));
283 seek_data
->position
= ftell(fh
);
284 seek_data
->eof
= feof(fh
);
291 void qmp_guest_file_flush(int64_t handle
, Error
**err
)
293 GuestFileHandle
*gfh
= guest_file_handle_find(handle
);
298 error_set(err
, QERR_FD_NOT_FOUND
, "handle");
305 error_set(err
, QERR_QGA_COMMAND_FAILED
, strerror(errno
));
309 static void guest_file_init(void)
311 QTAILQ_INIT(&guest_file_state
.filehandles
);
314 /* linux-specific implementations. avoid this if at all possible. */
315 #if defined(__linux__)
317 #if defined(CONFIG_FSFREEZE)
319 static void disable_logging(void)
321 ga_disable_logging(ga_state
);
324 static void enable_logging(void)
326 ga_enable_logging(ga_state
);
329 typedef struct GuestFsfreezeMount
{
332 QTAILQ_ENTRY(GuestFsfreezeMount
) next
;
333 } GuestFsfreezeMount
;
335 typedef QTAILQ_HEAD(, GuestFsfreezeMount
) GuestFsfreezeMountList
;
338 GuestFsfreezeStatus status
;
339 } guest_fsfreeze_state
;
341 static void guest_fsfreeze_free_mount_list(GuestFsfreezeMountList
*mounts
)
343 GuestFsfreezeMount
*mount
, *temp
;
349 QTAILQ_FOREACH_SAFE(mount
, mounts
, next
, temp
) {
350 QTAILQ_REMOVE(mounts
, mount
, next
);
351 g_free(mount
->dirname
);
352 g_free(mount
->devtype
);
358 * Walk the mount table and build a list of local file systems
360 static int guest_fsfreeze_build_mount_list(GuestFsfreezeMountList
*mounts
)
363 GuestFsfreezeMount
*mount
;
364 char const *mtab
= MOUNTED
;
367 fp
= setmntent(mtab
, "r");
369 g_warning("fsfreeze: unable to read mtab");
373 while ((ment
= getmntent(fp
))) {
375 * An entry which device name doesn't start with a '/' is
376 * either a dummy file system or a network file system.
377 * Add special handling for smbfs and cifs as is done by
380 if ((ment
->mnt_fsname
[0] != '/') ||
381 (strcmp(ment
->mnt_type
, "smbfs") == 0) ||
382 (strcmp(ment
->mnt_type
, "cifs") == 0)) {
386 mount
= g_malloc0(sizeof(GuestFsfreezeMount
));
387 mount
->dirname
= g_strdup(ment
->mnt_dir
);
388 mount
->devtype
= g_strdup(ment
->mnt_type
);
390 QTAILQ_INSERT_TAIL(mounts
, mount
, next
);
399 * Return status of freeze/thaw
401 GuestFsfreezeStatus
qmp_guest_fsfreeze_status(Error
**err
)
403 return guest_fsfreeze_state
.status
;
407 * Walk list of mounted file systems in the guest, and freeze the ones which
408 * are real local file systems.
410 int64_t qmp_guest_fsfreeze_freeze(Error
**err
)
413 GuestFsfreezeMountList mounts
;
414 struct GuestFsfreezeMount
*mount
;
418 slog("guest-fsfreeze called");
420 QTAILQ_INIT(&mounts
);
421 ret
= guest_fsfreeze_build_mount_list(&mounts
);
426 /* cannot risk guest agent blocking itself on a write in this state */
429 QTAILQ_FOREACH(mount
, &mounts
, next
) {
430 fd
= qemu_open(mount
->dirname
, O_RDONLY
);
432 sprintf(err_msg
, "failed to open %s, %s", mount
->dirname
,
434 error_set(err
, QERR_QGA_COMMAND_FAILED
, err_msg
);
438 /* we try to cull filesytems we know won't work in advance, but other
439 * filesytems may not implement fsfreeze for less obvious reasons.
440 * these will report EOPNOTSUPP. we simply ignore these when tallying
441 * the number of frozen filesystems.
443 * any other error means a failure to freeze a filesystem we
444 * expect to be freezable, so return an error in those cases
445 * and return system to thawed state.
447 ret
= ioctl(fd
, FIFREEZE
);
449 if (errno
!= EOPNOTSUPP
) {
450 sprintf(err_msg
, "failed to freeze %s, %s",
451 mount
->dirname
, strerror(errno
));
452 error_set(err
, QERR_QGA_COMMAND_FAILED
, err_msg
);
462 guest_fsfreeze_state
.status
= GUEST_FSFREEZE_STATUS_FROZEN
;
463 guest_fsfreeze_free_mount_list(&mounts
);
467 guest_fsfreeze_free_mount_list(&mounts
);
468 qmp_guest_fsfreeze_thaw(NULL
);
473 * Walk list of frozen file systems in the guest, and thaw them.
475 int64_t qmp_guest_fsfreeze_thaw(Error
**err
)
478 GuestFsfreezeMountList mounts
;
479 GuestFsfreezeMount
*mount
;
480 int fd
, i
= 0, logged
;
482 QTAILQ_INIT(&mounts
);
483 ret
= guest_fsfreeze_build_mount_list(&mounts
);
485 error_set(err
, QERR_QGA_COMMAND_FAILED
,
486 "failed to enumerate filesystems");
490 QTAILQ_FOREACH(mount
, &mounts
, next
) {
492 fd
= qemu_open(mount
->dirname
, O_RDONLY
);
496 /* we have no way of knowing whether a filesystem was actually unfrozen
497 * as a result of a successful call to FITHAW, only that if an error
498 * was returned the filesystem was *not* unfrozen by that particular
501 * since multiple preceeding FIFREEZEs require multiple calls to FITHAW
502 * to unfreeze, continuing issuing FITHAW until an error is returned,
503 * in which case either the filesystem is in an unfreezable state, or,
504 * more likely, it was thawed previously (and remains so afterward).
506 * also, since the most recent successful call is the one that did
507 * the actual unfreeze, we can use this to provide an accurate count
508 * of the number of filesystems unfrozen by guest-fsfreeze-thaw, which
509 * may * be useful for determining whether a filesystem was unfrozen
510 * during the freeze/thaw phase by a process other than qemu-ga.
513 ret
= ioctl(fd
, FITHAW
);
514 if (ret
== 0 && !logged
) {
522 guest_fsfreeze_state
.status
= GUEST_FSFREEZE_STATUS_THAWED
;
524 guest_fsfreeze_free_mount_list(&mounts
);
528 static void guest_fsfreeze_init(void)
530 guest_fsfreeze_state
.status
= GUEST_FSFREEZE_STATUS_THAWED
;
533 static void guest_fsfreeze_cleanup(void)
538 if (guest_fsfreeze_state
.status
== GUEST_FSFREEZE_STATUS_FROZEN
) {
539 ret
= qmp_guest_fsfreeze_thaw(&err
);
540 if (ret
< 0 || err
) {
541 slog("failed to clean up frozen filesystems");
545 #endif /* CONFIG_FSFREEZE */
547 #define LINUX_SYS_STATE_FILE "/sys/power/state"
548 #define SUSPEND_SUPPORTED 0
549 #define SUSPEND_NOT_SUPPORTED 1
552 * This function forks twice and the information about the mode support
553 * status is passed to the qemu-ga process via a pipe.
555 * This approach allows us to keep the way we reap terminated children
556 * in qemu-ga quite simple.
558 static void bios_supports_mode(const char *pmutils_bin
, const char *pmutils_arg
,
559 const char *sysfile_str
, Error
**err
)
564 int status
, pipefds
[2];
566 if (pipe(pipefds
) < 0) {
567 error_set(err
, QERR_UNDEFINED_ERROR
);
571 pmutils_path
= g_find_program_in_path(pmutils_bin
);
575 struct sigaction act
;
577 memset(&act
, 0, sizeof(act
));
578 act
.sa_handler
= SIG_DFL
;
579 sigaction(SIGCHLD
, &act
, NULL
);
583 reopen_fd_to_null(0);
584 reopen_fd_to_null(1);
585 reopen_fd_to_null(2);
590 char buf
[32]; /* hopefully big enough */
593 execle(pmutils_path
, pmutils_bin
, pmutils_arg
, NULL
, environ
);
597 * If we get here either pm-utils is not installed or execle() has
598 * failed. Let's try the manual method if the caller wants it.
602 _exit(SUSPEND_NOT_SUPPORTED
);
605 fd
= open(LINUX_SYS_STATE_FILE
, O_RDONLY
);
607 _exit(SUSPEND_NOT_SUPPORTED
);
610 ret
= read(fd
, buf
, sizeof(buf
)-1);
612 _exit(SUSPEND_NOT_SUPPORTED
);
616 if (strstr(buf
, sysfile_str
)) {
617 _exit(SUSPEND_SUPPORTED
);
620 _exit(SUSPEND_NOT_SUPPORTED
);
626 status
= SUSPEND_NOT_SUPPORTED
;
629 ret
= write(pipefds
[1], &status
, sizeof(status
));
630 if (ret
!= sizeof(status
)) {
638 g_free(pmutils_path
);
641 error_set(err
, QERR_UNDEFINED_ERROR
);
645 ret
= read(pipefds
[0], &status
, sizeof(status
));
646 if (ret
== sizeof(status
) && WIFEXITED(status
) &&
647 WEXITSTATUS(status
) == SUSPEND_SUPPORTED
) {
651 error_set(err
, QERR_UNSUPPORTED
);
657 static void guest_suspend(const char *pmutils_bin
, const char *sysfile_str
,
663 pmutils_path
= g_find_program_in_path(pmutils_bin
);
671 reopen_fd_to_null(0);
672 reopen_fd_to_null(1);
673 reopen_fd_to_null(2);
676 execle(pmutils_path
, pmutils_bin
, NULL
, environ
);
680 * If we get here either pm-utils is not installed or execle() has
681 * failed. Let's try the manual method if the caller wants it.
688 fd
= open(LINUX_SYS_STATE_FILE
, O_WRONLY
);
693 if (write(fd
, sysfile_str
, strlen(sysfile_str
)) < 0) {
700 g_free(pmutils_path
);
703 error_set(err
, QERR_UNDEFINED_ERROR
);
708 void qmp_guest_suspend_disk(Error
**err
)
710 bios_supports_mode("pm-is-supported", "--hibernate", "disk", err
);
711 if (error_is_set(err
)) {
715 guest_suspend("pm-hibernate", "disk", err
);
718 void qmp_guest_suspend_ram(Error
**err
)
720 bios_supports_mode("pm-is-supported", "--suspend", "mem", err
);
721 if (error_is_set(err
)) {
725 guest_suspend("pm-suspend", "mem", err
);
728 void qmp_guest_suspend_hybrid(Error
**err
)
730 bios_supports_mode("pm-is-supported", "--suspend-hybrid", NULL
, err
);
731 if (error_is_set(err
)) {
735 guest_suspend("pm-suspend-hybrid", NULL
, err
);
738 static GuestNetworkInterfaceList
*
739 guest_find_interface(GuestNetworkInterfaceList
*head
,
742 for (; head
; head
= head
->next
) {
743 if (strcmp(head
->value
->name
, name
) == 0) {
752 * Build information about guest interfaces
754 GuestNetworkInterfaceList
*qmp_guest_network_get_interfaces(Error
**errp
)
756 GuestNetworkInterfaceList
*head
= NULL
, *cur_item
= NULL
;
757 struct ifaddrs
*ifap
, *ifa
;
760 if (getifaddrs(&ifap
) < 0) {
761 snprintf(err_msg
, sizeof(err_msg
),
762 "getifaddrs failed: %s", strerror(errno
));
763 error_set(errp
, QERR_QGA_COMMAND_FAILED
, err_msg
);
767 for (ifa
= ifap
; ifa
; ifa
= ifa
->ifa_next
) {
768 GuestNetworkInterfaceList
*info
;
769 GuestIpAddressList
**address_list
= NULL
, *address_item
= NULL
;
770 char addr4
[INET_ADDRSTRLEN
];
771 char addr6
[INET6_ADDRSTRLEN
];
774 unsigned char *mac_addr
;
777 g_debug("Processing %s interface", ifa
->ifa_name
);
779 info
= guest_find_interface(head
, ifa
->ifa_name
);
782 info
= g_malloc0(sizeof(*info
));
783 info
->value
= g_malloc0(sizeof(*info
->value
));
784 info
->value
->name
= g_strdup(ifa
->ifa_name
);
787 head
= cur_item
= info
;
789 cur_item
->next
= info
;
794 if (!info
->value
->has_hardware_address
&&
795 ifa
->ifa_flags
& SIOCGIFHWADDR
) {
796 /* we haven't obtained HW address yet */
797 sock
= socket(PF_INET
, SOCK_STREAM
, 0);
799 snprintf(err_msg
, sizeof(err_msg
),
800 "failed to create socket: %s", strerror(errno
));
801 error_set(errp
, QERR_QGA_COMMAND_FAILED
, err_msg
);
805 memset(&ifr
, 0, sizeof(ifr
));
806 strncpy(ifr
.ifr_name
, info
->value
->name
, IF_NAMESIZE
);
807 if (ioctl(sock
, SIOCGIFHWADDR
, &ifr
) == -1) {
808 snprintf(err_msg
, sizeof(err_msg
),
809 "failed to get MAC addres of %s: %s",
812 error_set(errp
, QERR_QGA_COMMAND_FAILED
, err_msg
);
816 mac_addr
= (unsigned char *) &ifr
.ifr_hwaddr
.sa_data
;
818 if (asprintf(&info
->value
->hardware_address
,
819 "%02x:%02x:%02x:%02x:%02x:%02x",
820 (int) mac_addr
[0], (int) mac_addr
[1],
821 (int) mac_addr
[2], (int) mac_addr
[3],
822 (int) mac_addr
[4], (int) mac_addr
[5]) == -1) {
823 snprintf(err_msg
, sizeof(err_msg
),
824 "failed to format MAC: %s", strerror(errno
));
825 error_set(errp
, QERR_QGA_COMMAND_FAILED
, err_msg
);
829 info
->value
->has_hardware_address
= true;
834 ifa
->ifa_addr
->sa_family
== AF_INET
) {
835 /* interface with IPv4 address */
836 address_item
= g_malloc0(sizeof(*address_item
));
837 address_item
->value
= g_malloc0(sizeof(*address_item
->value
));
838 p
= &((struct sockaddr_in
*)ifa
->ifa_addr
)->sin_addr
;
839 if (!inet_ntop(AF_INET
, p
, addr4
, sizeof(addr4
))) {
840 snprintf(err_msg
, sizeof(err_msg
),
841 "inet_ntop failed : %s", strerror(errno
));
842 error_set(errp
, QERR_QGA_COMMAND_FAILED
, err_msg
);
846 address_item
->value
->ip_address
= g_strdup(addr4
);
847 address_item
->value
->ip_address_type
= GUEST_IP_ADDRESS_TYPE_IPV4
;
849 if (ifa
->ifa_netmask
) {
850 /* Count the number of set bits in netmask.
851 * This is safe as '1' and '0' cannot be shuffled in netmask. */
852 p
= &((struct sockaddr_in
*)ifa
->ifa_netmask
)->sin_addr
;
853 address_item
->value
->prefix
= ctpop32(((uint32_t *) p
)[0]);
855 } else if (ifa
->ifa_addr
&&
856 ifa
->ifa_addr
->sa_family
== AF_INET6
) {
857 /* interface with IPv6 address */
858 address_item
= g_malloc0(sizeof(*address_item
));
859 address_item
->value
= g_malloc0(sizeof(*address_item
->value
));
860 p
= &((struct sockaddr_in6
*)ifa
->ifa_addr
)->sin6_addr
;
861 if (!inet_ntop(AF_INET6
, p
, addr6
, sizeof(addr6
))) {
862 snprintf(err_msg
, sizeof(err_msg
),
863 "inet_ntop failed : %s", strerror(errno
));
864 error_set(errp
, QERR_QGA_COMMAND_FAILED
, err_msg
);
868 address_item
->value
->ip_address
= g_strdup(addr6
);
869 address_item
->value
->ip_address_type
= GUEST_IP_ADDRESS_TYPE_IPV6
;
871 if (ifa
->ifa_netmask
) {
872 /* Count the number of set bits in netmask.
873 * This is safe as '1' and '0' cannot be shuffled in netmask. */
874 p
= &((struct sockaddr_in6
*)ifa
->ifa_netmask
)->sin6_addr
;
875 address_item
->value
->prefix
=
876 ctpop32(((uint32_t *) p
)[0]) +
877 ctpop32(((uint32_t *) p
)[1]) +
878 ctpop32(((uint32_t *) p
)[2]) +
879 ctpop32(((uint32_t *) p
)[3]);
887 address_list
= &info
->value
->ip_addresses
;
889 while (*address_list
&& (*address_list
)->next
) {
890 address_list
= &(*address_list
)->next
;
893 if (!*address_list
) {
894 *address_list
= address_item
;
896 (*address_list
)->next
= address_item
;
899 info
->value
->has_ip_addresses
= true;
909 qapi_free_GuestNetworkInterfaceList(head
);
913 #else /* defined(__linux__) */
915 void qmp_guest_suspend_disk(Error
**err
)
917 error_set(err
, QERR_UNSUPPORTED
);
920 void qmp_guest_suspend_ram(Error
**err
)
922 error_set(err
, QERR_UNSUPPORTED
);
925 void qmp_guest_suspend_hybrid(Error
**err
)
927 error_set(err
, QERR_UNSUPPORTED
);
930 GuestNetworkInterfaceList
*qmp_guest_network_get_interfaces(Error
**errp
)
932 error_set(errp
, QERR_UNSUPPORTED
);
938 #if !defined(CONFIG_FSFREEZE)
940 GuestFsfreezeStatus
qmp_guest_fsfreeze_status(Error
**err
)
942 error_set(err
, QERR_UNSUPPORTED
);
947 int64_t qmp_guest_fsfreeze_freeze(Error
**err
)
949 error_set(err
, QERR_UNSUPPORTED
);
954 int64_t qmp_guest_fsfreeze_thaw(Error
**err
)
956 error_set(err
, QERR_UNSUPPORTED
);
963 /* register init/cleanup routines for stateful command groups */
964 void ga_command_state_init(GAState
*s
, GACommandState
*cs
)
966 #if defined(CONFIG_FSFREEZE)
967 ga_command_state_add(cs
, guest_fsfreeze_init
, guest_fsfreeze_cleanup
);
969 ga_command_state_add(cs
, guest_file_init
, NULL
);