proxmox-mirrors/qemu
1
0
Fork 0
mirror of https://git.proxmox.com/git/qemu synced 2025-06-18 05:33:58 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
9e8aded432
qemu/qga/commands-posix.c
Michael Roth 9e8aded432 qemu-ga: improve recovery options for fsfreeze 
guest-fsfreeze-thaw relies on state information obtained from
guest-fsfreeze-freeze to determine what filesystems to unfreeze.
This is unreliable due to the fact that that state does not account
for FIFREEZE being issued by other processes, or previous instances
of qemu-ga. This means in certain situations we cannot thaw
filesystems even with a responsive qemu-ga instance at our disposal.

This patch allows guest-fsfreeze-thaw to be issued unconditionally.
It also adds some additional logic to allow us to thaw filesystems
regardless of how many times the filesystem's "frozen" refcount has
been incremented by any guest processes.

Also, guest-fsfreeze-freeze now operates atomically: on success all
freezable filesystems are frozen, and on error all filesystems are
thawed. The ambiguous "GUEST_FSFREEZE_STATUS_ERROR" state is no
longer entered.

Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>
2012-04-30 08:41:40 -05:00

971 lines
25 KiB
C
Raw Blame History

/*
* QEMU Guest Agent POSIX-specific command implementations
*
* Copyright IBM Corp. 2011
*
* Authors:
* Michael Roth <mdroth@linux.vnet.ibm.com>
* Michal Privoznik <mprivozn@redhat.com>
*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
*/
#include <glib.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include "qga/guest-agent-core.h"
#include "qga-qmp-commands.h"
#include "qerror.h"
#include "qemu-queue.h"
#include "host-utils.h"
#if defined(__linux__)
#include <mntent.h>
#include <linux/fs.h>
#include <ifaddrs.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <net/if.h>
#include <sys/wait.h>
#if defined(__linux__) && defined(FIFREEZE)
#define CONFIG_FSFREEZE
#endif
#endif
#if defined(__linux__)
/* TODO: use this in place of all post-fork() fclose(std*) callers */
static void reopen_fd_to_null(int fd)
{
int nullfd;
nullfd = open("/dev/null", O_RDWR);
if (nullfd < 0) {
return;
}
dup2(nullfd, fd);
if (nullfd != fd) {
close(nullfd);
}
}
#endif /* defined(__linux__) */
void qmp_guest_shutdown(bool has_mode, const char *mode, Error **err)
{
int ret;
const char *shutdown_flag;
slog("guest-shutdown called, mode: %s", mode);
if (!has_mode || strcmp(mode, "powerdown") == 0) {
shutdown_flag = "-P";
} else if (strcmp(mode, "halt") == 0) {
shutdown_flag = "-H";
} else if (strcmp(mode, "reboot") == 0) {
shutdown_flag = "-r";
} else {
error_set(err, QERR_INVALID_PARAMETER_VALUE, "mode",
"halt|powerdown|reboot");
return;
}
ret = fork();
if (ret == 0) {
/* child, start the shutdown */
setsid();
fclose(stdin);
fclose(stdout);
fclose(stderr);
ret = execl("/sbin/shutdown", "shutdown", shutdown_flag, "+0",
"hypervisor initiated shutdown", (char*)NULL);
if (ret) {
slog("guest-shutdown failed: %s", strerror(errno));
}
exit(!!ret);
} else if (ret < 0) {
error_set(err, QERR_UNDEFINED_ERROR);
}
}
typedef struct GuestFileHandle {
uint64_t id;
FILE *fh;
QTAILQ_ENTRY(GuestFileHandle) next;
} GuestFileHandle;
static struct {
QTAILQ_HEAD(, GuestFileHandle) filehandles;
} guest_file_state;
static void guest_file_handle_add(FILE *fh)
{
GuestFileHandle *gfh;
gfh = g_malloc0(sizeof(GuestFileHandle));
gfh->id = fileno(fh);
gfh->fh = fh;
QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);
}
static GuestFileHandle *guest_file_handle_find(int64_t id)
{
GuestFileHandle *gfh;
QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next)
{
if (gfh->id == id) {
return gfh;
}
}
return NULL;
}
int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, Error **err)
{
FILE *fh;
int fd;
int64_t ret = -1;
if (!has_mode) {
mode = "r";
}
slog("guest-file-open called, filepath: %s, mode: %s", path, mode);
fh = fopen(path, mode);
if (!fh) {
error_set(err, QERR_OPEN_FILE_FAILED, path);
return -1;
}
/* set fd non-blocking to avoid common use cases (like reading from a
* named pipe) from hanging the agent
*/
fd = fileno(fh);
ret = fcntl(fd, F_GETFL);
ret = fcntl(fd, F_SETFL, ret | O_NONBLOCK);
if (ret == -1) {
error_set(err, QERR_QGA_COMMAND_FAILED, "fcntl() failed");
fclose(fh);
return -1;
}
guest_file_handle_add(fh);
slog("guest-file-open, handle: %d", fd);
return fd;
}
void qmp_guest_file_close(int64_t handle, Error **err)
{
GuestFileHandle *gfh = guest_file_handle_find(handle);
int ret;
slog("guest-file-close called, handle: %ld", handle);
if (!gfh) {
error_set(err, QERR_FD_NOT_FOUND, "handle");
return;
}
ret = fclose(gfh->fh);
if (ret == -1) {
error_set(err, QERR_QGA_COMMAND_FAILED, "fclose() failed");
return;
}
QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next);
g_free(gfh);
}
struct GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count,
int64_t count, Error **err)
{
GuestFileHandle *gfh = guest_file_handle_find(handle);
GuestFileRead *read_data = NULL;
guchar *buf;
FILE *fh;
size_t read_count;
if (!gfh) {
error_set(err, QERR_FD_NOT_FOUND, "handle");
return NULL;
}
if (!has_count) {
count = QGA_READ_COUNT_DEFAULT;
} else if (count < 0) {
error_set(err, QERR_INVALID_PARAMETER, "count");
return NULL;
}
fh = gfh->fh;
buf = g_malloc0(count+1);
read_count = fread(buf, 1, count, fh);
if (ferror(fh)) {
slog("guest-file-read failed, handle: %ld", handle);
error_set(err, QERR_QGA_COMMAND_FAILED, "fread() failed");
} else {
buf[read_count] = 0;
read_data = g_malloc0(sizeof(GuestFileRead));
read_data->count = read_count;
read_data->eof = feof(fh);
if (read_count) {
read_data->buf_b64 = g_base64_encode(buf, read_count);
}
}
g_free(buf);
clearerr(fh);
return read_data;
}
GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
bool has_count, int64_t count, Error **err)
{
GuestFileWrite *write_data = NULL;
guchar *buf;
gsize buf_len;
int write_count;
GuestFileHandle *gfh = guest_file_handle_find(handle);
FILE *fh;
if (!gfh) {
error_set(err, QERR_FD_NOT_FOUND, "handle");
return NULL;
}
fh = gfh->fh;
buf = g_base64_decode(buf_b64, &buf_len);
if (!has_count) {
count = buf_len;
} else if (count < 0 || count > buf_len) {
g_free(buf);
error_set(err, QERR_INVALID_PARAMETER, "count");
return NULL;
}
write_count = fwrite(buf, 1, count, fh);
if (ferror(fh)) {
slog("guest-file-write failed, handle: %ld", handle);
error_set(err, QERR_QGA_COMMAND_FAILED, "fwrite() error");
} else {
write_data = g_malloc0(sizeof(GuestFileWrite));
write_data->count = write_count;
write_data->eof = feof(fh);
}
g_free(buf);
clearerr(fh);
return write_data;
}
struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
int64_t whence, Error **err)
{
GuestFileHandle *gfh = guest_file_handle_find(handle);
GuestFileSeek *seek_data = NULL;
FILE *fh;
int ret;
if (!gfh) {
error_set(err, QERR_FD_NOT_FOUND, "handle");
return NULL;
}
fh = gfh->fh;
ret = fseek(fh, offset, whence);
if (ret == -1) {
error_set(err, QERR_QGA_COMMAND_FAILED, strerror(errno));
} else {
seek_data = g_malloc0(sizeof(GuestFileRead));
seek_data->position = ftell(fh);
seek_data->eof = feof(fh);
}
clearerr(fh);
return seek_data;
}
void qmp_guest_file_flush(int64_t handle, Error **err)
{
GuestFileHandle *gfh = guest_file_handle_find(handle);
FILE *fh;
int ret;
if (!gfh) {
error_set(err, QERR_FD_NOT_FOUND, "handle");
return;
}
fh = gfh->fh;
ret = fflush(fh);
if (ret == EOF) {
error_set(err, QERR_QGA_COMMAND_FAILED, strerror(errno));
}
}
static void guest_file_init(void)
{
QTAILQ_INIT(&guest_file_state.filehandles);
}
/* linux-specific implementations. avoid this if at all possible. */
#if defined(__linux__)
#if defined(CONFIG_FSFREEZE)
static void disable_logging(void)
{
ga_disable_logging(ga_state);
}
static void enable_logging(void)
{
ga_enable_logging(ga_state);
}
typedef struct GuestFsfreezeMount {
char *dirname;
char *devtype;
QTAILQ_ENTRY(GuestFsfreezeMount) next;
} GuestFsfreezeMount;
typedef QTAILQ_HEAD(, GuestFsfreezeMount) GuestFsfreezeMountList;
struct {
GuestFsfreezeStatus status;
} guest_fsfreeze_state;
static void guest_fsfreeze_free_mount_list(GuestFsfreezeMountList *mounts)
{
GuestFsfreezeMount *mount, *temp;
if (!mounts) {
return;
}
QTAILQ_FOREACH_SAFE(mount, mounts, next, temp) {
QTAILQ_REMOVE(mounts, mount, next);
g_free(mount->dirname);
g_free(mount->devtype);
g_free(mount);
}
}
/*
* Walk the mount table and build a list of local file systems
*/
static int guest_fsfreeze_build_mount_list(GuestFsfreezeMountList *mounts)
{
struct mntent *ment;
GuestFsfreezeMount *mount;
char const *mtab = MOUNTED;
FILE *fp;
fp = setmntent(mtab, "r");
if (!fp) {
g_warning("fsfreeze: unable to read mtab");
return -1;
}
while ((ment = getmntent(fp))) {
/*
* An entry which device name doesn't start with a '/' is
* either a dummy file system or a network file system.
* Add special handling for smbfs and cifs as is done by
* coreutils as well.
*/
if ((ment->mnt_fsname[0] != '/') ||
(strcmp(ment->mnt_type, "smbfs") == 0) ||
(strcmp(ment->mnt_type, "cifs") == 0)) {
continue;
}
mount = g_malloc0(sizeof(GuestFsfreezeMount));
mount->dirname = g_strdup(ment->mnt_dir);
mount->devtype = g_strdup(ment->mnt_type);
QTAILQ_INSERT_TAIL(mounts, mount, next);
}
endmntent(fp);
return 0;
}
/*
* Return status of freeze/thaw
*/
GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err)
{
return guest_fsfreeze_state.status;
}
/*
* Walk list of mounted file systems in the guest, and freeze the ones which
* are real local file systems.
*/
int64_t qmp_guest_fsfreeze_freeze(Error **err)
{
int ret = 0, i = 0;
GuestFsfreezeMountList mounts;
struct GuestFsfreezeMount *mount;
int fd;
char err_msg[512];
slog("guest-fsfreeze called");
QTAILQ_INIT(&mounts);
ret = guest_fsfreeze_build_mount_list(&mounts);
if (ret < 0) {
return ret;
}
/* cannot risk guest agent blocking itself on a write in this state */
disable_logging();
QTAILQ_FOREACH(mount, &mounts, next) {
fd = qemu_open(mount->dirname, O_RDONLY);
if (fd == -1) {
sprintf(err_msg, "failed to open %s, %s", mount->dirname,
strerror(errno));
error_set(err, QERR_QGA_COMMAND_FAILED, err_msg);
goto error;
}
/* we try to cull filesytems we know won't work in advance, but other
* filesytems may not implement fsfreeze for less obvious reasons.
* these will report EOPNOTSUPP. we simply ignore these when tallying
* the number of frozen filesystems.
*
* any other error means a failure to freeze a filesystem we
* expect to be freezable, so return an error in those cases
* and return system to thawed state.
*/
ret = ioctl(fd, FIFREEZE);
if (ret == -1) {
if (errno != EOPNOTSUPP) {
sprintf(err_msg, "failed to freeze %s, %s",
mount->dirname, strerror(errno));
error_set(err, QERR_QGA_COMMAND_FAILED, err_msg);
close(fd);
goto error;
}
} else {
i++;
}
close(fd);
}
guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_FROZEN;
guest_fsfreeze_free_mount_list(&mounts);
return i;
error:
guest_fsfreeze_free_mount_list(&mounts);
qmp_guest_fsfreeze_thaw(NULL);
return 0;
}
/*
* Walk list of frozen file systems in the guest, and thaw them.
*/
int64_t qmp_guest_fsfreeze_thaw(Error **err)
{
int ret;
GuestFsfreezeMountList mounts;
GuestFsfreezeMount *mount;
int fd, i = 0, logged;
QTAILQ_INIT(&mounts);
ret = guest_fsfreeze_build_mount_list(&mounts);
if (ret) {
error_set(err, QERR_QGA_COMMAND_FAILED,
"failed to enumerate filesystems");
return 0;
}
QTAILQ_FOREACH(mount, &mounts, next) {
logged = false;
fd = qemu_open(mount->dirname, O_RDONLY);
if (fd == -1) {
continue;
}
/* we have no way of knowing whether a filesystem was actually unfrozen
* as a result of a successful call to FITHAW, only that if an error
* was returned the filesystem was *not* unfrozen by that particular
* call.
*
* since multiple preceeding FIFREEZEs require multiple calls to FITHAW
* to unfreeze, continuing issuing FITHAW until an error is returned,
* in which case either the filesystem is in an unfreezable state, or,
* more likely, it was thawed previously (and remains so afterward).
*
* also, since the most recent successful call is the one that did
* the actual unfreeze, we can use this to provide an accurate count
* of the number of filesystems unfrozen by guest-fsfreeze-thaw, which
* may * be useful for determining whether a filesystem was unfrozen
* during the freeze/thaw phase by a process other than qemu-ga.
*/
do {
ret = ioctl(fd, FITHAW);
if (ret == 0 && !logged) {
i++;
logged = true;
}
} while (ret == 0);
close(fd);
}
guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_THAWED;
enable_logging();
guest_fsfreeze_free_mount_list(&mounts);
return i;
}
static void guest_fsfreeze_init(void)
{
guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_THAWED;
}
static void guest_fsfreeze_cleanup(void)
{
int64_t ret;
Error *err = NULL;
if (guest_fsfreeze_state.status == GUEST_FSFREEZE_STATUS_FROZEN) {
ret = qmp_guest_fsfreeze_thaw(&err);
if (ret < 0 || err) {
slog("failed to clean up frozen filesystems");
}
}
}
#endif /* CONFIG_FSFREEZE */
#define LINUX_SYS_STATE_FILE "/sys/power/state"
#define SUSPEND_SUPPORTED 0
#define SUSPEND_NOT_SUPPORTED 1
/**
* This function forks twice and the information about the mode support
* status is passed to the qemu-ga process via a pipe.
*
* This approach allows us to keep the way we reap terminated children
* in qemu-ga quite simple.
*/
static void bios_supports_mode(const char *pmutils_bin, const char *pmutils_arg,
const char *sysfile_str, Error **err)
{
pid_t pid;
ssize_t ret;
char *pmutils_path;
int status, pipefds[2];
if (pipe(pipefds) < 0) {
error_set(err, QERR_UNDEFINED_ERROR);
return;
}
pmutils_path = g_find_program_in_path(pmutils_bin);
pid = fork();
if (!pid) {
struct sigaction act;
memset(&act, 0, sizeof(act));
act.sa_handler = SIG_DFL;
sigaction(SIGCHLD, &act, NULL);
setsid();
close(pipefds[0]);
reopen_fd_to_null(0);
reopen_fd_to_null(1);
reopen_fd_to_null(2);
pid = fork();
if (!pid) {
int fd;
char buf[32]; /* hopefully big enough */
if (pmutils_path) {
execle(pmutils_path, pmutils_bin, pmutils_arg, NULL, environ);
}
/*
* If we get here either pm-utils is not installed or execle() has
* failed. Let's try the manual method if the caller wants it.
*/
if (!sysfile_str) {
_exit(SUSPEND_NOT_SUPPORTED);
}
fd = open(LINUX_SYS_STATE_FILE, O_RDONLY);
if (fd < 0) {
_exit(SUSPEND_NOT_SUPPORTED);
}
ret = read(fd, buf, sizeof(buf)-1);
if (ret <= 0) {
_exit(SUSPEND_NOT_SUPPORTED);
}
buf[ret] = '\0';
if (strstr(buf, sysfile_str)) {
_exit(SUSPEND_SUPPORTED);
}
_exit(SUSPEND_NOT_SUPPORTED);
}
if (pid > 0) {
wait(&status);
} else {
status = SUSPEND_NOT_SUPPORTED;
}
ret = write(pipefds[1], &status, sizeof(status));
if (ret != sizeof(status)) {
_exit(EXIT_FAILURE);
}
_exit(EXIT_SUCCESS);
}
close(pipefds[1]);
g_free(pmutils_path);
if (pid < 0) {
error_set(err, QERR_UNDEFINED_ERROR);
goto out;
}
ret = read(pipefds[0], &status, sizeof(status));
if (ret == sizeof(status) && WIFEXITED(status) &&
WEXITSTATUS(status) == SUSPEND_SUPPORTED) {
goto out;
}
error_set(err, QERR_UNSUPPORTED);
out:
close(pipefds[0]);
}
static void guest_suspend(const char *pmutils_bin, const char *sysfile_str,
Error **err)
{
pid_t pid;
char *pmutils_path;
pmutils_path = g_find_program_in_path(pmutils_bin);
pid = fork();
if (pid == 0) {
/* child */
int fd;
setsid();
reopen_fd_to_null(0);
reopen_fd_to_null(1);
reopen_fd_to_null(2);
if (pmutils_path) {
execle(pmutils_path, pmutils_bin, NULL, environ);
}
/*
* If we get here either pm-utils is not installed or execle() has
* failed. Let's try the manual method if the caller wants it.
*/
if (!sysfile_str) {
_exit(EXIT_FAILURE);
}
fd = open(LINUX_SYS_STATE_FILE, O_WRONLY);
if (fd < 0) {
_exit(EXIT_FAILURE);
}
if (write(fd, sysfile_str, strlen(sysfile_str)) < 0) {
_exit(EXIT_FAILURE);
}
_exit(EXIT_SUCCESS);
}
g_free(pmutils_path);
if (pid < 0) {
error_set(err, QERR_UNDEFINED_ERROR);
return;
}
}
void qmp_guest_suspend_disk(Error **err)
{
bios_supports_mode("pm-is-supported", "--hibernate", "disk", err);
if (error_is_set(err)) {
return;
}
guest_suspend("pm-hibernate", "disk", err);
}
void qmp_guest_suspend_ram(Error **err)
{
bios_supports_mode("pm-is-supported", "--suspend", "mem", err);
if (error_is_set(err)) {
return;
}
guest_suspend("pm-suspend", "mem", err);
}
void qmp_guest_suspend_hybrid(Error **err)
{
bios_supports_mode("pm-is-supported", "--suspend-hybrid", NULL, err);
if (error_is_set(err)) {
return;
}
guest_suspend("pm-suspend-hybrid", NULL, err);
}
static GuestNetworkInterfaceList *
guest_find_interface(GuestNetworkInterfaceList *head,
const char *name)
{
for (; head; head = head->next) {
if (strcmp(head->value->name, name) == 0) {
break;
}
}
return head;
}
/*
* Build information about guest interfaces
*/
GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
{
GuestNetworkInterfaceList *head = NULL, *cur_item = NULL;
struct ifaddrs *ifap, *ifa;
char err_msg[512];
if (getifaddrs(&ifap) < 0) {
snprintf(err_msg, sizeof(err_msg),
"getifaddrs failed: %s", strerror(errno));
error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
goto error;
}
for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
GuestNetworkInterfaceList *info;
GuestIpAddressList **address_list = NULL, *address_item = NULL;
char addr4[INET_ADDRSTRLEN];
char addr6[INET6_ADDRSTRLEN];
int sock;
struct ifreq ifr;
unsigned char *mac_addr;
void *p;
g_debug("Processing %s interface", ifa->ifa_name);
info = guest_find_interface(head, ifa->ifa_name);
if (!info) {
info = g_malloc0(sizeof(*info));
info->value = g_malloc0(sizeof(*info->value));
info->value->name = g_strdup(ifa->ifa_name);
if (!cur_item) {
head = cur_item = info;
} else {
cur_item->next = info;
cur_item = info;
}
}
if (!info->value->has_hardware_address &&
ifa->ifa_flags & SIOCGIFHWADDR) {
/* we haven't obtained HW address yet */
sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock == -1) {
snprintf(err_msg, sizeof(err_msg),
"failed to create socket: %s", strerror(errno));
error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
goto error;
}
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, info->value->name, IF_NAMESIZE);
if (ioctl(sock, SIOCGIFHWADDR, &ifr) == -1) {
snprintf(err_msg, sizeof(err_msg),
"failed to get MAC addres of %s: %s",
ifa->ifa_name,
strerror(errno));
error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
goto error;
}
mac_addr = (unsigned char *) &ifr.ifr_hwaddr.sa_data;
if (asprintf(&info->value->hardware_address,
"%02x:%02x:%02x:%02x:%02x:%02x",
(int) mac_addr[0], (int) mac_addr[1],
(int) mac_addr[2], (int) mac_addr[3],
(int) mac_addr[4], (int) mac_addr[5]) == -1) {
snprintf(err_msg, sizeof(err_msg),
"failed to format MAC: %s", strerror(errno));
error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
goto error;
}
info->value->has_hardware_address = true;
close(sock);
}
if (ifa->ifa_addr &&
ifa->ifa_addr->sa_family == AF_INET) {
/* interface with IPv4 address */
address_item = g_malloc0(sizeof(*address_item));
address_item->value = g_malloc0(sizeof(*address_item->value));
p = &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
if (!inet_ntop(AF_INET, p, addr4, sizeof(addr4))) {
snprintf(err_msg, sizeof(err_msg),
"inet_ntop failed : %s", strerror(errno));
error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
goto error;
}
address_item->value->ip_address = g_strdup(addr4);
address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4;
if (ifa->ifa_netmask) {
/* Count the number of set bits in netmask.
* This is safe as '1' and '0' cannot be shuffled in netmask. */
p = &((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr;
address_item->value->prefix = ctpop32(((uint32_t *) p)[0]);
}
} else if (ifa->ifa_addr &&
ifa->ifa_addr->sa_family == AF_INET6) {
/* interface with IPv6 address */
address_item = g_malloc0(sizeof(*address_item));
address_item->value = g_malloc0(sizeof(*address_item->value));
p = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr;
if (!inet_ntop(AF_INET6, p, addr6, sizeof(addr6))) {
snprintf(err_msg, sizeof(err_msg),
"inet_ntop failed : %s", strerror(errno));
error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
goto error;
}
address_item->value->ip_address = g_strdup(addr6);
address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6;
if (ifa->ifa_netmask) {
/* Count the number of set bits in netmask.
* This is safe as '1' and '0' cannot be shuffled in netmask. */
p = &((struct sockaddr_in6 *)ifa->ifa_netmask)->sin6_addr;
address_item->value->prefix =
ctpop32(((uint32_t *) p)[0]) +
ctpop32(((uint32_t *) p)[1]) +
ctpop32(((uint32_t *) p)[2]) +
ctpop32(((uint32_t *) p)[3]);
}
}
if (!address_item) {
continue;
}
address_list = &info->value->ip_addresses;
while (*address_list && (*address_list)->next) {
address_list = &(*address_list)->next;
}
if (!*address_list) {
*address_list = address_item;
} else {
(*address_list)->next = address_item;
}
info->value->has_ip_addresses = true;
}
freeifaddrs(ifap);
return head;
error:
freeifaddrs(ifap);
qapi_free_GuestNetworkInterfaceList(head);
return NULL;
}
#else /* defined(__linux__) */
void qmp_guest_suspend_disk(Error **err)
{
error_set(err, QERR_UNSUPPORTED);
}
void qmp_guest_suspend_ram(Error **err)
{
error_set(err, QERR_UNSUPPORTED);
}
void qmp_guest_suspend_hybrid(Error **err)
{
error_set(err, QERR_UNSUPPORTED);
}
GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
{
error_set(errp, QERR_UNSUPPORTED);
return NULL;
}
#endif
#if !defined(CONFIG_FSFREEZE)
GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err)
{
error_set(err, QERR_UNSUPPORTED);
return 0;
}
int64_t qmp_guest_fsfreeze_freeze(Error **err)
{
error_set(err, QERR_UNSUPPORTED);
return 0;
}
int64_t qmp_guest_fsfreeze_thaw(Error **err)
{
error_set(err, QERR_UNSUPPORTED);
return 0;
}
#endif
/* register init/cleanup routines for stateful command groups */
void ga_command_state_init(GAState *s, GACommandState *cs)
{
#if defined(CONFIG_FSFREEZE)
ga_command_state_add(cs, guest_fsfreeze_init, guest_fsfreeze_cleanup);
#endif
ga_command_state_add(cs, guest_file_init, NULL);
}
Reference in New Issue View Git Blame Copy Permalink