Archipelago » qemu

test-visitor.o test-qmp-commands.o qemu-ga$(EXESUF): QEMU_CFLAGS += -I $(qapi-dir)

$(qapi-dir)/qga-qapi-types.c: $(qapi-dir)/qga-qapi-types.h

$(qapi-dir)/qga-qapi-types.h: $(SRC_PATH)/qapi-schema-guest.json $(SRC_PATH)/scripts/qapi-types.py

	$(call quiet-command,python $(SRC_PATH)/scripts/qapi-types.py -o "$(qapi-dir)" -p "qga-" < $<, "  GEN   $@")

$(qapi-dir)/qga-qapi-visit.c: $(qapi-dir)/qga-qapi-visit.h

$(qapi-dir)/qga-qapi-visit.h: $(SRC_PATH)/qapi-schema-guest.json $(SRC_PATH)/scripts/qapi-visit.py

	$(call quiet-command,python $(SRC_PATH)/scripts/qapi-visit.py -o "$(qapi-dir)" -p "qga-" < $<, "  GEN   $@")

$(qapi-dir)/qga-qmp-marshal.c: $(SRC_PATH)/qapi-schema-guest.json $(SRC_PATH)/scripts/qapi-commands.py

	$(call quiet-command,python $(SRC_PATH)/scripts/qapi-commands.py -o "$(qapi-dir)" -p "qga-" < $<, "  GEN   $@")

QGALIB=qga/guest-agent-command-state.o qga/guest-agent-commands.o

qemu-ga.o: $(addprefix $(qapi-dir)/, qga-qapi-types.c qga-qapi-types.h qga-qapi-visit.c qga-qmp-marshal.c) $(qapi-obj-y)

qemu-ga$(EXESUF): qemu-ga.o $(QGALIB) qemu-tool.o qemu-error.o error.o $(oslib-obj-y) $(trace-obj-y) $(block-obj-y) $(qobject-obj-y) $(version-obj-y) $(qapi-obj-y) qemu-timer-common.o qemu-sockets.o module.o qapi/qmp-dispatch.o qapi/qmp-registry.o $(qapi-dir)/qga-qapi-visit.o $(qapi-dir)/qga-qapi-types.o $(qapi-dir)/qga-qmp-marshal.o

# *-*- Mode: Python -*-*

##

# @guest-sync:

#

# Echo back a unique integer value

#

# This is used by clients talking to the guest agent over the

# wire to ensure the stream is in sync and doesn't contain stale

# data from previous client. All guest agent responses should be

# ignored until the provided unique integer value is returned,

# and it is up to the client to handle stale whole or

# partially-delivered JSON text in such a way that this response

# can be obtained.

#

# Such clients should also preceed this command

# with a 0xFF byte to make such the guest agent flushes any

# partially read JSON data from a previous session.

#

# @id: randomly generated 64-bit integer

#

# Returns: The unique integer id passed in by the client

#

# Since: 0.15.0

##

{ 'command': 'guest-sync'

  'data':    { 'id': 'int' },

  'returns': 'int' }

##

# @guest-ping:

#

# Ping the guest agent, a non-error return implies success

#

# Since: 0.15.0

##

{ 'command': 'guest-ping' }

##

# @guest-info:

#

# Get some information about the guest agent.

#

# Since: 0.15.0

##

{ 'type': 'GuestAgentInfo', 'data': {'version': 'str'} }

{ 'command': 'guest-info',

  'returns': 'GuestAgentInfo' }

##

# @guest-shutdown:

#

# Initiate guest-activated shutdown. Note: this is an asynchronous

# shutdown request, with no guaruntee of successful shutdown. Errors

# will be logged to guest's syslog.

#

# @mode: #optional "halt", "powerdown" (default), or "reboot"

#

# Returns: Nothing on success

#

# Since: 0.15.0

##

{ 'command': 'guest-shutdown', 'data': { '*mode': 'str' } }

##

# @guest-file-open:

#

# Open a file in the guest and retrieve a file handle for it

#

# @filepath: Full path to the file in the guest to open.

#

# @mode: #optional open mode, as per fopen(), "r" is the default.

#

# Returns: Guest file handle on success.

#

# Since: 0.15.0

##

{ 'command': 'guest-file-open',

  'data':    { 'path': 'str', '*mode': 'str' },

  'returns': 'int' }

##

# @guest-file-close:

#

# Close an open file in the guest

#

# @handle: filehandle returned by guest-file-open

#

# Returns: Nothing on success.

#

# Since: 0.15.0

##

{ 'command': 'guest-file-close',

  'data': { 'handle': 'int' } }

##

# @guest-file-read:

#

# Read from an open file in the guest. Data will be base64-encoded

#

# @handle: filehandle returned by guest-file-open

#

# @count: #optional maximum number of bytes to read (default is 4KB)

#

# Returns: GuestFileRead on success. Note: count is number of bytes read

#          *before* base64 encoding bytes read.

#

# Since: 0.15.0

##

{ 'type': 'GuestFileRead',

  'data': { 'count': 'int', 'buf-b64': 'str', 'eof': 'bool' } }

{ 'command': 'guest-file-read',

  'data':    { 'handle': 'int', '*count': 'int' },

  'returns': 'GuestFileRead' }

##

# @guest-file-write:

#

# Write to an open file in the guest.

#

# @handle: filehandle returned by guest-file-open

#

# @buf-b64: base64-encoded string representing data to be written

#

# @count: #optional bytes to write (actual bytes, after base64-decode),

#         default is all content in buf-b64 buffer after base64 decoding

#

# Returns: GuestFileWrite on success. Note: count is the number of bytes

#          base64-decoded bytes written

#

# Since: 0.15.0

##

{ 'type': 'GuestFileWrite',

  'data': { 'count': 'int', 'eof': 'bool' } }

{ 'command': 'guest-file-write',

  'data':    { 'handle': 'int', 'buf-b64': 'str', '*count': 'int' },

  'returns': 'GuestFileWrite' }

##

# @guest-file-seek:

#

# Seek to a position in the file, as with fseek(), and return the

# current file position afterward. Also encapsulates ftell()'s

# functionality, just Set offset=0, whence=SEEK_CUR.

#

# @handle: filehandle returned by guest-file-open

#

# @offset: bytes to skip over in the file stream

#

# @whence: SEEK_SET, SEEK_CUR, or SEEK_END, as with fseek()

#

# Returns: GuestFileSeek on success.

#

# Since: 0.15.0

##

{ 'type': 'GuestFileSeek',

  'data': { 'position': 'int', 'eof': 'bool' } }

{ 'command': 'guest-file-seek',

  'data':    { 'handle': 'int', 'offset': 'int', 'whence': 'int' },

  'returns': 'GuestFileSeek' }

##

# @guest-file-flush:

#

# Write file changes bufferred in userspace to disk/kernel buffers

#

# @handle: filehandle returned by guest-file-open

#

# Returns: Nothing on success.

#

# Since: 0.15.0

##

{ 'command': 'guest-file-flush',

  'data': { 'handle': 'int' } }

##

# @guest-fsfreeze-status:

#

# Get guest fsfreeze state. error state indicates failure to thaw 1 or more

# previously frozen filesystems, or failure to open a previously cached

# filesytem (filesystem unmounted/directory changes, etc).

#

# Returns: GuestFsfreezeStatus ("thawed", "frozen", etc., as defined below)

#

# Since: 0.15.0

##

{ 'enum': 'GuestFsfreezeStatus',

  'data': [ 'thawed', 'frozen', 'error' ] }

{ 'command': 'guest-fsfreeze-status',

  'returns': 'GuestFsfreezeStatus' }

##

# @guest-fsfreeze-freeze:

#

# Sync and freeze all non-network guest filesystems

#

# Returns: Number of file systems frozen on success

#

# Since: 0.15.0

##

{ 'command': 'guest-fsfreeze-freeze',

  'returns': 'int' }

##

# @guest-fsfreeze-thaw:

#

# Unfreeze frozen guest fileystems

#

# Returns: Number of file systems thawed

#          If error, -1 (unknown error) or -errno

#

# Since: 0.15.0

##

{ 'command': 'guest-fsfreeze-thaw',

  'returns': 'int' }

    s->command_state = ga_command_state_new();

    ga_command_state_init(s, s->command_state);

    ga_command_state_init_all(s->command_state);

    ga_command_state_cleanup_all(ga_state->command_state);

    {

        .error_fmt = QERR_QGA_LOGGING_FAILED,

        .desc      = "Guest agent failed to log non-optional log statement",

    },

    {

        .error_fmt = QERR_QGA_COMMAND_FAILED,

        .desc      = "Guest agent command failed, error was '%(message)'",

    },

#define QERR_QGA_LOGGING_FAILED \

    "{ 'class': 'QgaLoggingFailed', 'data': {} }"

#define QERR_QGA_COMMAND_FAILED \

    "{ 'class': 'QgaCommandFailed', 'data': { 'message': %s } }"

/*

 * QEMU Guest Agent commands

 *

 * Copyright IBM Corp. 2011

 *

 * Authors:

 *  Michael Roth      <mdroth@linux.vnet.ibm.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 <mntent.h>

#include <sys/types.h>

#include <sys/ioctl.h>

#include <linux/fs.h>

#include "qga/guest-agent-core.h"

#include "qga-qmp-commands.h"

#include "qerror.h"

#include "qemu-queue.h"

static GAState *ga_state;

static void disable_logging(void)

{

    ga_disable_logging(ga_state);

}

static void enable_logging(void)

{

    ga_enable_logging(ga_state);

}

/* Note: in some situations, like with the fsfreeze, logging may be

 * temporarilly disabled. if it is necessary that a command be able

 * to log for accounting purposes, check ga_logging_enabled() beforehand,

 * and use the QERR_QGA_LOGGING_DISABLED to generate an error

 */

static void slog(const char *fmt, ...)

{

    va_list ap;

    va_start(ap, fmt);

    g_logv("syslog", G_LOG_LEVEL_INFO, fmt, ap);

    va_end(ap);

}

int64_t qmp_guest_sync(int64_t id, Error **errp)

{

    return id;

}

void qmp_guest_ping(Error **err)

{

    slog("guest-ping called");

}

struct GuestAgentInfo *qmp_guest_info(Error **err)

{

    GuestAgentInfo *info = qemu_mallocz(sizeof(GuestAgentInfo));

    info->version = g_strdup(QGA_VERSION);

    return info;

}

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 = qemu_mallocz(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);

    qemu_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 = qemu_mallocz(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 = qemu_mallocz(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);

        }

    }

    qemu_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) {

        qemu_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 = qemu_mallocz(sizeof(GuestFileWrite));

        write_data->count = write_count;

        write_data->eof = feof(fh);

    }

    qemu_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 = qemu_mallocz(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);

}

typedef struct GuestFsfreezeMount {

    char *dirname;

    char *devtype;

    QTAILQ_ENTRY(GuestFsfreezeMount) next;

} GuestFsfreezeMount;

struct {

    GuestFsfreezeStatus status;

    QTAILQ_HEAD(, GuestFsfreezeMount) mount_list;

} guest_fsfreeze_state;

/*

 * Walk the mount table and build a list of local file systems

 */

static int guest_fsfreeze_build_mount_list(void)

{

    struct mntent *ment;

    GuestFsfreezeMount *mount, *temp;

    char const *mtab = MOUNTED;

    FILE *fp;

    QTAILQ_FOREACH_SAFE(mount, &guest_fsfreeze_state.mount_list, next, temp) {

        QTAILQ_REMOVE(&guest_fsfreeze_state.mount_list, mount, next);

        qemu_free(mount->dirname);

        qemu_free(mount->devtype);

        qemu_free(mount);

    }

    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 = qemu_mallocz(sizeof(GuestFsfreezeMount));

        mount->dirname = qemu_strdup(ment->mnt_dir);

        mount->devtype = qemu_strdup(ment->mnt_type);

        QTAILQ_INSERT_TAIL(&guest_fsfreeze_state.mount_list, 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;

    struct GuestFsfreezeMount *mount, *temp;

    int fd;

    char err_msg[512];

    slog("guest-fsfreeze called");

    if (guest_fsfreeze_state.status == GUEST_FSFREEZE_STATUS_FROZEN) {

        return 0;

    }

    ret = guest_fsfreeze_build_mount_list();

    if (ret < 0) {

        return ret;

    }

    /* cannot risk guest agent blocking itself on a write in this state */

    disable_logging();

    QTAILQ_FOREACH_SAFE(mount, &guest_fsfreeze_state.mount_list, next, temp) {

        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, so we simply ignore them. when

         * thawing, these filesystems will return an EINVAL instead, due to

         * not being in a frozen state. Other filesystem-specific

         * errors may result in EINVAL, however, so the user should check the

         * number * of filesystems returned here against those returned by the

         * thaw operation to determine whether everything completed

         * successfully

         */

        ret = ioctl(fd, FIFREEZE);

        if (ret < 0 && 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;

        }

        close(fd);

        i++;

    }

    guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_FROZEN;

    return i;

error:

    if (i > 0) {

        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;

    GuestFsfreezeMount *mount, *temp;

    int fd, i = 0;

    bool has_error = false;

    QTAILQ_FOREACH_SAFE(mount, &guest_fsfreeze_state.mount_list, next, temp) {

        fd = qemu_open(mount->dirname, O_RDONLY);

        if (fd == -1) {

            has_error = true;

            continue;

        }

        ret = ioctl(fd, FITHAW);

        if (ret < 0 && errno != EOPNOTSUPP && errno != EINVAL) {

            has_error = true;

            close(fd);

            continue;

        }

        close(fd);

        i++;

    }

    if (has_error) {

        guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_ERROR;

    } else {

        guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_THAWED;

    }

    enable_logging();

    return i;

}

static void guest_fsfreeze_init(void)

{

    guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_THAWED;

    QTAILQ_INIT(&guest_fsfreeze_state.mount_list);

}

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");

        }

    }

}

/* register init/cleanup routines for stateful command groups */

void ga_command_state_init(GAState *s, GACommandState *cs)

{

    ga_state = s;

    ga_command_state_add(cs, guest_fsfreeze_init, guest_fsfreeze_cleanup);

    ga_command_state_add(cs, guest_file_init, NULL);

}

#define QGA_READ_COUNT_DEFAULT 4 << 10

void ga_command_state_init(GAState *s, GACommandState *cs);