diff options
Diffstat (limited to 'qga')
| -rw-r--r-- | qga/Makefile.objs | 2 | ||||
| -rw-r--r-- | qga/channel-posix.c | 4 | ||||
| -rw-r--r-- | qga/commands-posix.c | 6 | ||||
| -rw-r--r-- | qga/commands-win32.c | 2 | ||||
| -rw-r--r-- | qga/commands.c | 2 | ||||
| -rw-r--r-- | qga/guest-agent-core.h | 2 | ||||
| -rw-r--r-- | qga/main.c | 901 | ||||
| -rw-r--r-- | qga/qapi-schema.json | 517 |
8 files changed, 1427 insertions, 9 deletions
diff --git a/qga/Makefile.objs b/qga/Makefile.objs index cd3e135..b8d7cd0 100644 --- a/qga/Makefile.objs +++ b/qga/Makefile.objs @@ -1,4 +1,4 @@ -qga-obj-y = commands.o guest-agent-command-state.o +qga-obj-y = commands.o guest-agent-command-state.o main.o qga-obj-$(CONFIG_POSIX) += commands-posix.o channel-posix.o qga-obj-$(CONFIG_WIN32) += commands-win32.o channel-win32.o service-win32.o qga-obj-y += qapi-generated/qga-qapi-types.o qapi-generated/qga-qapi-visit.o diff --git a/qga/channel-posix.c b/qga/channel-posix.c index 769a559..d4fd628 100644 --- a/qga/channel-posix.c +++ b/qga/channel-posix.c @@ -4,8 +4,8 @@ #include <unistd.h> #include <fcntl.h> #include <stdlib.h> -#include "osdep.h" -#include "qemu_socket.h" +#include "qemu/osdep.h" +#include "qemu/sockets.h" #include "qga/channel.h" #ifdef CONFIG_SOLARIS diff --git a/qga/commands-posix.c b/qga/commands-posix.c index 726930a..a657201 100644 --- a/qga/commands-posix.c +++ b/qga/commands-posix.c @@ -17,9 +17,9 @@ #include <sys/wait.h> #include "qga/guest-agent-core.h" #include "qga-qmp-commands.h" -#include "qerror.h" -#include "qemu-queue.h" -#include "host-utils.h" +#include "qapi/qmp/qerror.h" +#include "qemu/queue.h" +#include "qemu/host-utils.h" #ifndef CONFIG_HAS_ENVIRON #ifdef __APPLE__ diff --git a/qga/commands-win32.c b/qga/commands-win32.c index 5bd8fb2..7e8ecb3 100644 --- a/qga/commands-win32.c +++ b/qga/commands-win32.c @@ -16,7 +16,7 @@ #include <powrprof.h> #include "qga/guest-agent-core.h" #include "qga-qmp-commands.h" -#include "qerror.h" +#include "qapi/qmp/qerror.h" #ifndef SHTDN_REASON_FLAG_PLANNED #define SHTDN_REASON_FLAG_PLANNED 0x80000000 diff --git a/qga/commands.c b/qga/commands.c index 46b0b08..7ffb35e 100644 --- a/qga/commands.c +++ b/qga/commands.c @@ -13,7 +13,7 @@ #include <glib.h> #include "qga/guest-agent-core.h" #include "qga-qmp-commands.h" -#include "qerror.h" +#include "qapi/qmp/qerror.h" /* Note: in some situations, like with the fsfreeze, logging may be * temporarilly disabled. if it is necessary that a command be able diff --git a/qga/guest-agent-core.h b/qga/guest-agent-core.h index 49a7abe..8934163 100644 --- a/qga/guest-agent-core.h +++ b/qga/guest-agent-core.h @@ -10,7 +10,7 @@ * 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 "qapi/qmp-core.h" +#include "qapi/qmp/dispatch.h" #include "qemu-common.h" #define QGA_READ_COUNT_DEFAULT 4096 diff --git a/qga/main.c b/qga/main.c new file mode 100644 index 0000000..ba5fa1c --- /dev/null +++ b/qga/main.c @@ -0,0 +1,901 @@ +/* + * QEMU Guest Agent + * + * Copyright IBM Corp. 2011 + * + * Authors: + * Adam Litke <aglitke@linux.vnet.ibm.com> + * 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 <stdlib.h> +#include <stdio.h> +#include <stdbool.h> +#include <glib.h> +#include <getopt.h> +#ifndef _WIN32 +#include <syslog.h> +#include <sys/wait.h> +#include <sys/stat.h> +#endif +#include "qapi/qmp/json-streamer.h" +#include "qapi/qmp/json-parser.h" +#include "qapi/qmp/qint.h" +#include "qapi/qmp/qjson.h" +#include "qga/guest-agent-core.h" +#include "qemu/module.h" +#include "signal.h" +#include "qapi/qmp/qerror.h" +#include "qapi/qmp/dispatch.h" +#include "qga/channel.h" +#ifdef _WIN32 +#include "qga/service-win32.h" +#include <windows.h> +#endif + +#ifndef _WIN32 +#define QGA_VIRTIO_PATH_DEFAULT "/dev/virtio-ports/org.qemu.guest_agent.0" +#else +#define QGA_VIRTIO_PATH_DEFAULT "\\\\.\\Global\\org.qemu.guest_agent.0" +#endif +#define QGA_STATEDIR_DEFAULT CONFIG_QEMU_LOCALSTATEDIR "/run" +#define QGA_PIDFILE_DEFAULT QGA_STATEDIR_DEFAULT "/qemu-ga.pid" +#define QGA_SENTINEL_BYTE 0xFF + +struct GAState { + JSONMessageParser parser; + GMainLoop *main_loop; + GAChannel *channel; + bool virtio; /* fastpath to check for virtio to deal with poll() quirks */ + GACommandState *command_state; + GLogLevelFlags log_level; + FILE *log_file; + bool logging_enabled; +#ifdef _WIN32 + GAService service; +#endif + bool delimit_response; + bool frozen; + GList *blacklist; + const char *state_filepath_isfrozen; + struct { + const char *log_filepath; + const char *pid_filepath; + } deferred_options; +}; + +struct GAState *ga_state; + +/* commands that are safe to issue while filesystems are frozen */ +static const char *ga_freeze_whitelist[] = { + "guest-ping", + "guest-info", + "guest-sync", + "guest-fsfreeze-status", + "guest-fsfreeze-thaw", + NULL +}; + +#ifdef _WIN32 +DWORD WINAPI service_ctrl_handler(DWORD ctrl, DWORD type, LPVOID data, + LPVOID ctx); +VOID WINAPI service_main(DWORD argc, TCHAR *argv[]); +#endif + +static void quit_handler(int sig) +{ + /* if we're frozen, don't exit unless we're absolutely forced to, + * because it's basically impossible for graceful exit to complete + * unless all log/pid files are on unfreezable filesystems. there's + * also a very likely chance killing the agent before unfreezing + * the filesystems is a mistake (or will be viewed as one later). + */ + if (ga_is_frozen(ga_state)) { + return; + } + g_debug("received signal num %d, quitting", sig); + + if (g_main_loop_is_running(ga_state->main_loop)) { + g_main_loop_quit(ga_state->main_loop); + } +} + +#ifndef _WIN32 +static gboolean register_signal_handlers(void) +{ + struct sigaction sigact; + int ret; + + memset(&sigact, 0, sizeof(struct sigaction)); + sigact.sa_handler = quit_handler; + + ret = sigaction(SIGINT, &sigact, NULL); + if (ret == -1) { + g_error("error configuring signal handler: %s", strerror(errno)); + } + ret = sigaction(SIGTERM, &sigact, NULL); + if (ret == -1) { + g_error("error configuring signal handler: %s", strerror(errno)); + } + + return true; +} + +/* TODO: use this in place of all post-fork() fclose(std*) callers */ +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 + +static void usage(const char *cmd) +{ + printf( +"Usage: %s [-m <method> -p <path>] [<options>]\n" +"QEMU Guest Agent %s\n" +"\n" +" -m, --method transport method: one of unix-listen, virtio-serial, or\n" +" isa-serial (virtio-serial is the default)\n" +" -p, --path device/socket path (the default for virtio-serial is:\n" +" %s)\n" +" -l, --logfile set logfile path, logs to stderr by default\n" +" -f, --pidfile specify pidfile (default is %s)\n" +" -t, --statedir specify dir to store state information (absolute paths\n" +" only, default is %s)\n" +" -v, --verbose log extra debugging information\n" +" -V, --version print version information and exit\n" +" -d, --daemonize become a daemon\n" +#ifdef _WIN32 +" -s, --service service commands: install, uninstall\n" +#endif +" -b, --blacklist comma-separated list of RPCs to disable (no spaces, \"?\"\n" +" to list available RPCs)\n" +" -h, --help display this help and exit\n" +"\n" +"Report bugs to <mdroth@linux.vnet.ibm.com>\n" + , cmd, QEMU_VERSION, QGA_VIRTIO_PATH_DEFAULT, QGA_PIDFILE_DEFAULT, + QGA_STATEDIR_DEFAULT); +} + +static const char *ga_log_level_str(GLogLevelFlags level) +{ + switch (level & G_LOG_LEVEL_MASK) { + case G_LOG_LEVEL_ERROR: + return "error"; + case G_LOG_LEVEL_CRITICAL: + return "critical"; + case G_LOG_LEVEL_WARNING: + return "warning"; + case G_LOG_LEVEL_MESSAGE: + return "message"; + case G_LOG_LEVEL_INFO: + return "info"; + case G_LOG_LEVEL_DEBUG: + return "debug"; + default: + return "user"; + } +} + +bool ga_logging_enabled(GAState *s) +{ + return s->logging_enabled; +} + +void ga_disable_logging(GAState *s) +{ + s->logging_enabled = false; +} + +void ga_enable_logging(GAState *s) +{ + s->logging_enabled = true; +} + +static void ga_log(const gchar *domain, GLogLevelFlags level, + const gchar *msg, gpointer opaque) +{ + GAState *s = opaque; + GTimeVal time; + const char *level_str = ga_log_level_str(level); + + if (!ga_logging_enabled(s)) { + return; + } + + level &= G_LOG_LEVEL_MASK; +#ifndef _WIN32 + if (domain && strcmp(domain, "syslog") == 0) { + syslog(LOG_INFO, "%s: %s", level_str, msg); + } else if (level & s->log_level) { +#else + if (level & s->log_level) { +#endif + g_get_current_time(&time); + fprintf(s->log_file, + "%lu.%lu: %s: %s\n", time.tv_sec, time.tv_usec, level_str, msg); + fflush(s->log_file); + } +} + +void ga_set_response_delimited(GAState *s) +{ + s->delimit_response = true; +} + +#ifndef _WIN32 +static bool ga_open_pidfile(const char *pidfile) +{ + int pidfd; + char pidstr[32]; + + pidfd = open(pidfile, O_CREAT|O_WRONLY, S_IRUSR|S_IWUSR); + if (pidfd == -1 || lockf(pidfd, F_TLOCK, 0)) { + g_critical("Cannot lock pid file, %s", strerror(errno)); + if (pidfd != -1) { + close(pidfd); + } + return false; + } + + if (ftruncate(pidfd, 0) || lseek(pidfd, 0, SEEK_SET)) { + g_critical("Failed to truncate pid file"); + goto fail; + } + snprintf(pidstr, sizeof(pidstr), "%d\n", getpid()); + if (write(pidfd, pidstr, strlen(pidstr)) != strlen(pidstr)) { + g_critical("Failed to write pid file"); + goto fail; + } + + return true; + +fail: + unlink(pidfile); + return false; +} +#else /* _WIN32 */ +static bool ga_open_pidfile(const char *pidfile) +{ + return true; +} +#endif + +static gint ga_strcmp(gconstpointer str1, gconstpointer str2) +{ + return strcmp(str1, str2); +} + +/* disable commands that aren't safe for fsfreeze */ +static void ga_disable_non_whitelisted(void) +{ + char **list_head, **list; + bool whitelisted; + int i; + + list_head = list = qmp_get_command_list(); + while (*list != NULL) { + whitelisted = false; + i = 0; + while (ga_freeze_whitelist[i] != NULL) { + if (strcmp(*list, ga_freeze_whitelist[i]) == 0) { + whitelisted = true; + } + i++; + } + if (!whitelisted) { + g_debug("disabling command: %s", *list); + qmp_disable_command(*list); + } + g_free(*list); + list++; + } + g_free(list_head); +} + +/* [re-]enable all commands, except those explicitly blacklisted by user */ +static void ga_enable_non_blacklisted(GList *blacklist) +{ + char **list_head, **list; + + list_head = list = qmp_get_command_list(); + while (*list != NULL) { + if (g_list_find_custom(blacklist, *list, ga_strcmp) == NULL && + !qmp_command_is_enabled(*list)) { + g_debug("enabling command: %s", *list); + qmp_enable_command(*list); + } + g_free(*list); + list++; + } + g_free(list_head); +} + +static bool ga_create_file(const char *path) +{ + int fd = open(path, O_CREAT | O_WRONLY, S_IWUSR | S_IRUSR); + if (fd == -1) { + g_warning("unable to open/create file %s: %s", path, strerror(errno)); + return false; + } + close(fd); + return true; +} + +static bool ga_delete_file(const char *path) +{ + int ret = unlink(path); + if (ret == -1) { + g_warning("unable to delete file: %s: %s", path, strerror(errno)); + return false; + } + + return true; +} + +bool ga_is_frozen(GAState *s) +{ + return s->frozen; +} + +void ga_set_frozen(GAState *s) +{ + if (ga_is_frozen(s)) { + return; + } + /* disable all non-whitelisted (for frozen state) commands */ + ga_disable_non_whitelisted(); + g_warning("disabling logging due to filesystem freeze"); + ga_disable_logging(s); + s->frozen = true; + if (!ga_create_file(s->state_filepath_isfrozen)) { + g_warning("unable to create %s, fsfreeze may not function properly", + s->state_filepath_isfrozen); + } +} + +void ga_unset_frozen(GAState *s) +{ + if (!ga_is_frozen(s)) { + return; + } + + /* if we delayed creation/opening of pid/log files due to being + * in a frozen state at start up, do it now + */ + if (s->deferred_options.log_filepath) { + s->log_file = fopen(s->deferred_options.log_filepath, "a"); + if (!s->log_file) { + s->log_file = stderr; + } + s->deferred_options.log_filepath = NULL; + } + ga_enable_logging(s); + g_warning("logging re-enabled due to filesystem unfreeze"); + if (s->deferred_options.pid_filepath) { + if (!ga_open_pidfile(s->deferred_options.pid_filepath)) { + g_warning("failed to create/open pid file"); + } + s->deferred_options.pid_filepath = NULL; + } + + /* enable all disabled, non-blacklisted commands */ + ga_enable_non_blacklisted(s->blacklist); + s->frozen = false; + if (!ga_delete_file(s->state_filepath_isfrozen)) { + g_warning("unable to delete %s, fsfreeze may not function properly", + s->state_filepath_isfrozen); + } +} + +static void become_daemon(const char *pidfile) +{ +#ifndef _WIN32 + pid_t pid, sid; + + pid = fork(); + if (pid < 0) { + exit(EXIT_FAILURE); + } + if (pid > 0) { + exit(EXIT_SUCCESS); + } + + if (pidfile) { + if (!ga_open_pidfile(pidfile)) { + g_critical("failed to create pidfile"); + exit(EXIT_FAILURE); + } + } + + umask(0); + sid = setsid(); + if (sid < 0) { + goto fail; + } + if ((chdir("/")) < 0) { + goto fail; + } + + reopen_fd_to_null(STDIN_FILENO); + reopen_fd_to_null(STDOUT_FILENO); + reopen_fd_to_null(STDERR_FILENO); + return; + +fail: + if (pidfile) { + unlink(pidfile); + } + g_critical("failed to daemonize"); + exit(EXIT_FAILURE); +#endif +} + +static int send_response(GAState *s, QObject *payload) +{ + const char *buf; + QString *payload_qstr, *response_qstr; + GIOStatus status; + + g_assert(payload && s->channel); + + payload_qstr = qobject_to_json(payload); + if (!payload_qstr) { + return -EINVAL; + } + + if (s->delimit_response) { + s->delimit_response = false; + response_qstr = qstring_new(); + qstring_append_chr(response_qstr, QGA_SENTINEL_BYTE); + qstring_append(response_qstr, qstring_get_str(payload_qstr)); + QDECREF(payload_qstr); + } else { + response_qstr = payload_qstr; + } + + qstring_append_chr(response_qstr, '\n'); + buf = qstring_get_str(response_qstr); + status = ga_channel_write_all(s->channel, buf, strlen(buf)); + QDECREF(response_qstr); + if (status != G_IO_STATUS_NORMAL) { + return -EIO; + } + + return 0; +} + +static void process_command(GAState *s, QDict *req) +{ + QObject *rsp = NULL; + int ret; + + g_assert(req); + g_debug("processing command"); + rsp = qmp_dispatch(QOBJECT(req)); + if (rsp) { + ret = send_response(s, rsp); + if (ret) { + g_warning("error sending response: %s", strerror(ret)); + } + qobject_decref(rsp); + } +} + +/* handle requests/control events coming in over the channel */ +static void process_event(JSONMessageParser *parser, QList *tokens) +{ + GAState *s = container_of(parser, GAState, parser); + QObject *obj; + QDict *qdict; + Error *err = NULL; + int ret; + + g_assert(s && parser); + + g_debug("process_event: called"); + obj = json_parser_parse_err(tokens, NULL, &err); + if (err || !obj || qobject_type(obj) != QTYPE_QDICT) { + qobject_decref(obj); + qdict = qdict_new(); + if (!err) { + g_warning("failed to parse event: unknown error"); + error_set(&err, QERR_JSON_PARSING); + } else { + g_warning("failed to parse event: %s", error_get_pretty(err)); + } + qdict_put_obj(qdict, "error", qmp_build_error_object(err)); + error_free(err); + } else { + qdict = qobject_to_qdict(obj); + } + + g_assert(qdict); + + /* handle host->guest commands */ + if (qdict_haskey(qdict, "execute")) { + process_command(s, qdict); + } else { + if (!qdict_haskey(qdict, "error")) { + QDECREF(qdict); + qdict = qdict_new(); + g_warning("unrecognized payload format"); + error_set(&err, QERR_UNSUPPORTED); + qdict_put_obj(qdict, "error", qmp_build_error_object(err)); + error_free(err); + } + ret = send_response(s, QOBJECT(qdict)); + if (ret) { + g_warning("error sending error response: %s", strerror(ret)); + } + } + + QDECREF(qdict); +} + +/* false return signals GAChannel to close the current client connection */ +static gboolean channel_event_cb(GIOCondition condition, gpointer data) +{ + GAState *s = data; + gchar buf[QGA_READ_COUNT_DEFAULT+1]; + gsize count; + GError *err = NULL; + GIOStatus status = ga_channel_read(s->channel, buf, QGA_READ_COUNT_DEFAULT, &count); + if (err != NULL) { + g_warning("error reading channel: %s", err->message); + g_error_free(err); + return false; + } + switch (status) { + case G_IO_STATUS_ERROR: + g_warning("error reading channel"); + return false; + case G_IO_STATUS_NORMAL: + buf[count] = 0; + g_debug("read data, count: %d, data: %s", (int)count, buf); + json_message_parser_feed(&s->parser, (char *)buf, (int)count); + break; + case G_IO_STATUS_EOF: + g_debug("received EOF"); + if (!s->virtio) { + return false; + } + case G_IO_STATUS_AGAIN: + /* virtio causes us to spin here when no process is attached to + * host-side chardev. sleep a bit to mitigate this + */ + if (s->virtio) { + usleep(100*1000); + } + return true; + default: + g_warning("unknown channel read status, closing"); + return false; + } + return true; +} + +static gboolean channel_init(GAState *s, const gchar *method, const gchar *path) +{ + GAChannelMethod channel_method; + + if (method == NULL) { + method = "virtio-serial"; + } + + if (path == NULL) { + if (strcmp(method, "virtio-serial") != 0) { + g_critical("must specify a path for this channel"); + return false; + } + /* try the default path for the virtio-serial port */ + path = QGA_VIRTIO_PATH_DEFAULT; + } + + if (strcmp(method, "virtio-serial") == 0) { + s->virtio = true; /* virtio requires special handling in some cases */ + channel_method = GA_CHANNEL_VIRTIO_SERIAL; + } else if (strcmp(method, "isa-serial") == 0) { + channel_method = GA_CHANNEL_ISA_SERIAL; + } else if (strcmp(method, "unix-listen") == 0) { + channel_method = GA_CHANNEL_UNIX_LISTEN; + } else { + g_critical("unsupported channel method/type: %s", method); + return false; + } + + s->channel = ga_channel_new(channel_method, path, channel_event_cb, s); + if (!s->channel) { + g_critical("failed to create guest agent channel"); + return false; + } + + return true; +} + +#ifdef _WIN32 +DWORD WINAPI service_ctrl_handler(DWORD ctrl, DWORD type, LPVOID data, + LPVOID ctx) +{ + DWORD ret = NO_ERROR; + GAService *service = &ga_state->service; + + switch (ctrl) + { + case SERVICE_CONTROL_STOP: + case SERVICE_CONTROL_SHUTDOWN: + quit_handler(SIGTERM); + service->status.dwCurrentState = SERVICE_STOP_PENDING; + SetServiceStatus(service->status_handle, &service->status); + break; + + default: + ret = ERROR_CALL_NOT_IMPLEMENTED; + } + return ret; +} + +VOID WINAPI service_main(DWORD argc, TCHAR *argv[]) +{ + GAService *service = &ga_state->service; + + service->status_handle = RegisterServiceCtrlHandlerEx(QGA_SERVICE_NAME, + service_ctrl_handler, NULL); + + if (service->status_handle == 0) { + g_critical("Failed to register extended requests function!\n"); + return; + } + + service->status.dwServiceType = SERVICE_WIN32; + service->status.dwCurrentState = SERVICE_RUNNING; + service->status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN; + service->status.dwWin32ExitCode = NO_ERROR; + service->status.dwServiceSpecificExitCode = NO_ERROR; + service->status.dwCheckPoint = 0; + service->status.dwWaitHint = 0; + SetServiceStatus(service->status_handle, &service->status); + + g_main_loop_run(ga_state->main_loop); + + service->status.dwCurrentState = SERVICE_STOPPED; + SetServiceStatus(service->status_handle, &service->status); +} +#endif + +int main(int argc, char **argv) +{ + const char *sopt = "hVvdm:p:l:f:b:s:t:"; + const char *method = NULL, *path = NULL; + const char *log_filepath = NULL; + const char *pid_filepath = QGA_PIDFILE_DEFAULT; + const char *state_dir = QGA_STATEDIR_DEFAULT; +#ifdef _WIN32 + const char *service = NULL; +#endif + const struct option lopt[] = { + { "help", 0, NULL, 'h' }, + { "version", 0, NULL, 'V' }, + { "logfile", 1, NULL, 'l' }, + { "pidfile", 1, NULL, 'f' }, + { "verbose", 0, NULL, 'v' }, + { "method", 1, NULL, 'm' }, + { "path", 1, NULL, 'p' }, + { "daemonize", 0, NULL, 'd' }, + { "blacklist", 1, NULL, 'b' }, +#ifdef _WIN32 + { "service", 1, NULL, 's' }, +#endif + { "statedir", 1, NULL, 't' }, + { NULL, 0, NULL, 0 } + }; + int opt_ind = 0, ch, daemonize = 0, i, j, len; + GLogLevelFlags log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL; + GList *blacklist = NULL; + GAState *s; + + module_call_init(MODULE_INIT_QAPI); + + while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) { + switch (ch) { + case 'm': + method = optarg; + break; + case 'p': + path = optarg; + break; + case 'l': + log_filepath = optarg; + break; + case 'f': + pid_filepath = optarg; + break; + case 't': + state_dir = optarg; + break; + case 'v': + /* enable all log levels */ + log_level = G_LOG_LEVEL_MASK; + break; + case 'V': + printf("QEMU Guest Agent %s\n", QEMU_VERSION); + return 0; + case 'd': + daemonize = 1; + break; + case 'b': { + char **list_head, **list; + if (is_help_option(optarg)) { + list_head = list = qmp_get_command_list(); + while (*list != NULL) { + printf("%s\n", *list); + g_free(*list); + list++; + } + g_free(list_head); + return 0; + } + for (j = 0, i = 0, len = strlen(optarg); i < len; i++) { + if (optarg[i] == ',') { + optarg[i] = 0; + blacklist = g_list_append(blacklist, &optarg[j]); + j = i + 1; + } + } + if (j < i) { + blacklist = g_list_append(blacklist, &optarg[j]); + } + break; + } +#ifdef _WIN32 + case 's': + service = optarg; + if (strcmp(service, "install") == 0) { + return ga_install_service(path, log_filepath); + } else if (strcmp(service, "uninstall") == 0) { + return ga_uninstall_service(); + } else { + printf("Unknown service command.\n"); + return EXIT_FAILURE; + } + break; +#endif + case 'h': + usage(argv[0]); + return 0; + case '?': + g_print("Unknown option, try '%s --help' for more information.\n", + argv[0]); + return EXIT_FAILURE; + } + } + + s = g_malloc0(sizeof(GAState)); + s->log_level = log_level; + s->log_file = stderr; + g_log_set_default_handler(ga_log, s); + g_log_set_fatal_mask(NULL, G_LOG_LEVEL_ERROR); + ga_enable_logging(s); + s->state_filepath_isfrozen = g_strdup_printf("%s/qga.state.isfrozen", + state_dir); + s->frozen = false; +#ifndef _WIN32 + /* check if a previous instance of qemu-ga exited with filesystems' state + * marked as frozen. this could be a stale value (a non-qemu-ga process + * or reboot may have since unfrozen them), but better to require an + * uneeded unfreeze than to risk hanging on start-up + */ + struct stat st; + if (stat(s->state_filepath_isfrozen, &st) == -1) { + /* it's okay if the file doesn't exist, but if we can't access for + * some other reason, such as permissions, there's a configuration + * that needs to be addressed. so just bail now before we get into + * more trouble later + */ + if (errno != ENOENT) { + g_critical("unable to access state file at path %s: %s", + s->state_filepath_isfrozen, strerror(errno)); + return EXIT_FAILURE; + } + } else { + g_warning("previous instance appears to have exited with frozen" + " filesystems. deferring logging/pidfile creation and" + " disabling non-fsfreeze-safe commands until" + " guest-fsfreeze-thaw is issued, or filesystems are" + " manually unfrozen and the file %s is removed", + s->state_filepath_isfrozen); + s->frozen = true; + } +#endif + + if (ga_is_frozen(s)) { + if (daemonize) { + /* delay opening/locking of pidfile till filesystem are unfrozen */ + s->deferred_options.pid_filepath = pid_filepath; + become_daemon(NULL); + } + if (log_filepath) { + /* delay opening the log file till filesystems are unfrozen */ + s->deferred_options.log_filepath = log_filepath; + } + ga_disable_logging(s); + ga_disable_non_whitelisted(); + } else { + if (daemonize) { + become_daemon(pid_filepath); + } + if (log_filepath) { + FILE *log_file = fopen(log_filepath, "a"); + if (!log_file) { + g_critical("unable to open specified log file: %s", + strerror(errno)); + goto out_bad; + } + s->log_file = log_file; + } + } + + if (blacklist) { + s->blacklist = blacklist; + do { + g_debug("disabling command: %s", (char *)blacklist->data); + qmp_disable_command(blacklist->data); + blacklist = g_list_next(blacklist); + } while (blacklist); + } + s->command_state = ga_command_state_new(); + ga_command_state_init(s, s->command_state); + ga_command_state_init_all(s->command_state); + json_message_parser_init(&s->parser, process_event); + ga_state = s; +#ifndef _WIN32 + if (!register_signal_handlers()) { + g_critical("failed to register signal handlers"); + goto out_bad; + } +#endif + + s->main_loop = g_main_loop_new(NULL, false); + if (!channel_init(ga_state, method, path)) { + g_critical("failed to initialize guest agent channel"); + goto out_bad; + } +#ifndef _WIN32 + g_main_loop_run(ga_state->main_loop); +#else + if (daemonize) { + SERVICE_TABLE_ENTRY service_table[] = { + { (char *)QGA_SERVICE_NAME, service_main }, { NULL, NULL } }; + StartServiceCtrlDispatcher(service_table); + } else { + g_main_loop_run(ga_state->main_loop); + } +#endif + + ga_command_state_cleanup_all(ga_state->command_state); + ga_channel_free(ga_state->channel); + + if (daemonize) { + unlink(pid_filepath); + } + return 0; + +out_bad: + if (daemonize) { + unlink(pid_filepath); + } + return EXIT_FAILURE; +} diff --git a/qga/qapi-schema.json b/qga/qapi-schema.json new file mode 100644 index 0000000..ed0eb69 --- /dev/null +++ b/qga/qapi-schema.json @@ -0,0 +1,517 @@ +# *-*- Mode: Python -*-* + +## +# +# Echo back a unique integer value, and prepend to response a +# leading sentinel byte (0xFF) the client can check scan for. +# +# 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. It must be issued upon initial +# connection, and after any client-side timeouts (including +# timeouts on receiving a response to this command). +# +# After issuing this request, all guest agent responses should be +# ignored until the response containing the unique integer value +# the client passed in is returned. Receival of the 0xFF sentinel +# byte must be handled as an indication that the client's +# lexer/tokenizer/parser state should be flushed/reset in +# preparation for reliably receiving the subsequent response. As +# an optimization, clients may opt to ignore all data until a +# sentinel value is receiving to avoid unnecessary processing of +# stale data. +# +# Similarly, clients should also precede this *request* +# with a 0xFF byte to make sure the guest agent flushes any +# partially read JSON data from a previous client connection. +# +# @id: randomly generated 64-bit integer +# +# Returns: The unique integer id passed in by the client +# +# Since: 1.1 +# ## +{ 'command': 'guest-sync-delimited' + 'data': { 'id': 'int' }, + 'returns': 'int' } + +## +# @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. +# +# In cases where a partial stale response was previously +# received by the client, this cannot always be done reliably. +# One particular scenario being if qemu-ga responses are fed +# character-by-character into a JSON parser. In these situations, +# using guest-sync-delimited may be optimal. +# +# For clients that fetch responses line by line and convert them +# to JSON objects, guest-sync should be sufficient, but note that +# in cases where the channel is dirty some attempts at parsing the +# response may result in a parser error. +# +# Such clients should also precede this command +# with a 0xFF byte to make sure 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' } + +## +# @GuestAgentCommandInfo: +# +# Information about guest agent commands. +# +# @name: name of the command +# +# @enabled: whether command is currently enabled by guest admin +# +# Since 1.1.0 +## +{ 'type': 'GuestAgentCommandInfo', + 'data': { 'name': 'str', 'enabled': 'bool' } } + +## +# @GuestAgentInfo +# +# Information about guest agent. +# +# @version: guest agent version +# +# @supported_commands: Information about guest agent commands +# +# Since 0.15.0 +## +{ 'type': 'GuestAgentInfo', + 'data': { 'version': 'str', + 'supported_commands': ['GuestAgentCommandInfo'] } } +## +# @guest-info: +# +# Get some information about the guest agent. +# +# Returns: @GuestAgentInfo +# +# Since: 0.15.0 +## +{ 'command': 'guest-info', + 'returns': 'GuestAgentInfo' } + +## +# @guest-shutdown: +# +# Initiate guest-activated shutdown. Note: this is an asynchronous +# shutdown request, with no guarantee of successful shutdown. +# +# @mode: #optional "halt", "powerdown" (default), or "reboot" +# +# This command does NOT return a response on success. Success condition +# is indicated by the VM exiting with a zero exit status or, when +# running with --no-shutdown, by issuing the query-status QMP command +# to confirm the VM status is "shutdown". +# +# Since: 0.15.0 +## +{ 'command': 'guest-shutdown', 'data': { '*mode': 'str' }, + 'success-response': 'no' } + +## +# @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' } } + +## +# @GuestFileRead +# +# Result of guest agent file-read operation +# +# @count: number of bytes read (note: count is *before* +# base64-encoding is applied) +# +# @buf-b64: base64-encoded bytes read +# +# @eof: whether EOF was encountered during read operation. +# +# Since: 0.15.0 +## +{ 'type': 'GuestFileRead', + 'data': { 'count': 'int', 'buf-b64': 'str', 'eof': 'bool' } } + +## +# @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. +# +# Since: 0.15.0 +## +{ 'command': 'guest-file-read', + 'data': { 'handle': 'int', '*count': 'int' }, + 'returns': 'GuestFileRead' } + +## +# @GuestFileWrite +# +# Result of guest agent file-write operation +# +# @count: number of bytes written (note: count is actual bytes +# written, after base64-decoding of provided buffer) +# +# @eof: whether EOF was encountered during write operation. +# +# Since: 0.15.0 +## +{ 'type': 'GuestFileWrite', + 'data': { 'count': 'int', 'eof': 'bool' } } + +## +# @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. +# +# Since: 0.15.0 +## +{ 'command': 'guest-file-write', + 'data': { 'handle': 'int', 'buf-b64': 'str', '*count': 'int' }, + 'returns': 'GuestFileWrite' } + + +## +# @GuestFileSeek +# +# Result of guest agent file-seek operation +# +# @position: current file position +# +# @eof: whether EOF was encountered during file seek +# +# Since: 0.15.0 +## +{ 'type': 'GuestFileSeek', + 'data': { 'position': 'int', 'eof': 'bool' } } + +## +# @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 +## +{ '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' } } + +## +# @GuestFsFreezeStatus +# +# An enumeration of filesystem freeze states +# +# @thawed: filesystems thawed/unfrozen +# +# @frozen: all non-network guest filesystems frozen +# +# Since: 0.15.0 +## +{ 'enum': 'GuestFsfreezeStatus', + 'data': [ 'thawed', 'frozen' ] } + +## +# @guest-fsfreeze-status: +# +# Get guest fsfreeze state. error state indicates +# +# Returns: GuestFsfreezeStatus ("thawed", "frozen", etc., as defined below) +# +# Note: This may fail to properly report the current state as a result of +# some other guest processes having issued an fs freeze/thaw. +# +# Since: 0.15.0 +## +{ 'command': 'guest-fsfreeze-status', + 'returns': 'GuestFsfreezeStatus' } + +## +# @guest-fsfreeze-freeze: +# +# Sync and freeze all freezable, local guest filesystems +# +# Returns: Number of file systems currently frozen. On error, all filesystems +# will be thawed. +# +# Since: 0.15.0 +## +{ 'command': 'guest-fsfreeze-freeze', + 'returns': 'int' } + +## +# @guest-fsfreeze-thaw: +# +# Unfreeze all frozen guest filesystems +# +# Returns: Number of file systems thawed by this call +# +# Note: if return value does not match the previous call to +# guest-fsfreeze-freeze, this likely means some freezable +# filesystems were unfrozen before this call, and that the +# filesystem state may have changed before issuing this +# command. +# +# Since: 0.15.0 +## +{ 'command': 'guest-fsfreeze-thaw', + 'returns': 'int' } + +## +# @guest-fstrim: +# +# Discard (or "trim") blocks which are not in use by the filesystem. +# +# @minimum: +# Minimum contiguous free range to discard, in bytes. Free ranges +# smaller than this may be ignored (this is a hint and the guest +# may not respect it). By increasing this value, the fstrim +# operation will complete more quickly for filesystems with badly +# fragmented free space, although not all blocks will be discarded. +# The default value is zero, meaning "discard every free block". +# +# Returns: Nothing. +# +# Since: 1.2 +## +{ 'command': 'guest-fstrim', + 'data': { '*minimum': 'int' } } + +## +# @guest-suspend-disk +# +# Suspend guest to disk. +# +# This command tries to execute the scripts provided by the pm-utils package. +# If it's not available, the suspend operation will be performed by manually +# writing to a sysfs file. +# +# For the best results it's strongly recommended to have the pm-utils +# package installed in the guest. +# +# This command does NOT return a response on success. There is a high chance +# the command succeeded if the VM exits with a zero exit status or, when +# running with --no-shutdown, by issuing the query-status QMP command to +# to confirm the VM status is "shutdown". However, the VM could also exit +# (or set its status to "shutdown") due to other reasons. +# +# The following errors may be returned: +# If suspend to disk is not supported, Unsupported +# +# Notes: It's strongly recommended to issue the guest-sync command before +# sending commands when the guest resumes +# +# Since: 1.1 +## +{ 'command': 'guest-suspend-disk', 'success-response': 'no' } + +## +# @guest-suspend-ram +# +# Suspend guest to ram. +# +# This command tries to execute the scripts provided by the pm-utils package. +# If it's not available, the suspend operation will be performed by manually +# writing to a sysfs file. +# +# For the best results it's strongly recommended to have the pm-utils +# package installed in the guest. +# +# IMPORTANT: guest-suspend-ram requires QEMU to support the 'system_wakeup' +# command. Thus, it's *required* to query QEMU for the presence of the +# 'system_wakeup' command before issuing guest-suspend-ram. +# +# This command does NOT return a response on success. There are two options +# to check for success: +# 1. Wait for the SUSPEND QMP event from QEMU +# 2. Issue the query-status QMP command to confirm the VM status is +# "suspended" +# +# The following errors may be returned: +# If suspend to ram is not supported, Unsupported +# +# Notes: It's strongly recommended to issue the guest-sync command before +# sending commands when the guest resumes +# +# Since: 1.1 +## +{ 'command': 'guest-suspend-ram', 'success-response': 'no' } + +## +# @guest-suspend-hybrid +# +# Save guest state to disk and suspend to ram. +# +# This command requires the pm-utils package to be installed in the guest. +# +# IMPORTANT: guest-suspend-hybrid requires QEMU to support the 'system_wakeup' +# command. Thus, it's *required* to query QEMU for the presence of the +# 'system_wakeup' command before issuing guest-suspend-hybrid. +# +# This command does NOT return a response on success. There are two options +# to check for success: +# 1. Wait for the SUSPEND QMP event from QEMU +# 2. Issue the query-status QMP command to confirm the VM status is +# "suspended" +# +# The following errors may be returned: +# If hybrid suspend is not supported, Unsupported +# +# Notes: It's strongly recommended to issue the guest-sync command before +# sending commands when the guest resumes +# +# Since: 1.1 +## +{ 'command': 'guest-suspend-hybrid', 'success-response': 'no' } + +## +# @GuestIpAddressType: +# +# An enumeration of supported IP address types +# +# @ipv4: IP version 4 +# +# @ipv6: IP version 6 +# +# Since: 1.1 +## +{ 'enum': 'GuestIpAddressType', + 'data': [ 'ipv4', 'ipv6' ] } + +## +# @GuestIpAddress: +# +# @ip-address: IP address +# +# @ip-address-type: Type of @ip-address (e.g. ipv4, ipv6) +# +# @prefix: Network prefix length of @ip-address +# +# Since: 1.1 +## +{ 'type': 'GuestIpAddress', + 'data': {'ip-address': 'str', + 'ip-address-type': 'GuestIpAddressType', + 'prefix': 'int'} } + +## +# @GuestNetworkInterface: +# +# @name: The name of interface for which info are being delivered +# +# @hardware-address: Hardware address of @name +# +# @ip-addresses: List of addresses assigned to @name +# +# Since: 1.1 +## +{ 'type': 'GuestNetworkInterface', + 'data': {'name': 'str', + '*hardware-address': 'str', + '*ip-addresses': ['GuestIpAddress'] } } + +## +# @guest-network-get-interfaces: +# +# Get list of guest IP addresses, MAC addresses +# and netmasks. +# +# Returns: List of GuestNetworkInfo on success. +# +# Since: 1.1 +## +{ 'command': 'guest-network-get-interfaces', + 'returns': ['GuestNetworkInterface'] } |