X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=qemu-ga.c;h=216be39072b926c90d57eb324118c08a8dfdbba4;hb=b3412b09e9a437f1e16ca6e63ea78ce97e2dd54c;hp=29e4f642b7d7dd6b1f147915afe1a25f30e5f348;hpb=515689235c4c3d9c3f0406ddcdd21ed8da77062b;p=qemu.git diff --git a/qemu-ga.c b/qemu-ga.c index 29e4f642b..216be3907 100644 --- a/qemu-ga.c +++ b/qemu-ga.c @@ -15,9 +15,11 @@ #include #include #include -#include +#ifndef _WIN32 #include -#include "qemu_socket.h" +#include +#include +#endif #include "json-streamer.h" #include "json-parser.h" #include "qint.h" @@ -28,30 +30,72 @@ #include "qerror.h" #include "error_int.h" #include "qapi/qmp-core.h" +#include "qga/channel.h" +#ifdef _WIN32 +#include "qga/service-win32.h" +#include +#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_PIDFILE_DEFAULT "/var/run/qemu-ga.pid" -#define QGA_BAUDRATE_DEFAULT B38400 /* for isa-serial channels */ -#define QGA_TIMEOUT_DEFAULT 30*1000 /* ms */ +#define QGA_STATEDIR_DEFAULT "/tmp" +#define QGA_SENTINEL_BYTE 0xFF struct GAState { JSONMessageParser parser; GMainLoop *main_loop; - GIOChannel *conn_channel; - GIOChannel *listen_channel; - const char *path; - const char *method; + 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; }; -static struct GAState *ga_state; +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)) { @@ -59,9 +103,17 @@ static void quit_handler(int sig) } } -static void register_signal_handlers(void) +#ifndef _WIN32 +/* reap _all_ terminated children */ +static void child_handler(int sig) +{ + int status; + while (waitpid(-1, &status, WNOHANG) > 0) /* NOTHING */; +} + +static gboolean register_signal_handlers(void) { - struct sigaction sigact; + struct sigaction sigact, sigact_chld; int ret; memset(&sigact, 0, sizeof(struct sigaction)); @@ -70,38 +122,55 @@ static void register_signal_handlers(void) ret = sigaction(SIGINT, &sigact, NULL); if (ret == -1) { g_error("error configuring signal handler: %s", strerror(errno)); - exit(EXIT_FAILURE); + return false; } ret = sigaction(SIGTERM, &sigact, NULL); + if (ret == -1) { + g_error("error configuring signal handler: %s", strerror(errno)); + return false; + } + + memset(&sigact_chld, 0, sizeof(struct sigaction)); + sigact_chld.sa_handler = child_handler; + sigact_chld.sa_flags = SA_NOCLDSTOP; + ret = sigaction(SIGCHLD, &sigact_chld, NULL); if (ret == -1) { g_error("error configuring signal handler: %s", strerror(errno)); } + + return true; } +#endif static void usage(const char *cmd) { printf( -"Usage: %s -c \n" +"Usage: %s [-m -p ] []\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 (%s is the default for virtio-serial)\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" -" -b, --blacklist comma-separated list of RPCs to disable (no spaces, \"?\"" +#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 \n" - , cmd, QGA_VERSION, QGA_VIRTIO_PATH_DEFAULT, QGA_PIDFILE_DEFAULT); + , cmd, QGA_VERSION, QGA_VIRTIO_PATH_DEFAULT, QGA_PIDFILE_DEFAULT, + QGA_STATEDIR_DEFAULT); } -static void conn_channel_close(GAState *s); - static const char *ga_log_level_str(GLogLevelFlags level) { switch (level & G_LOG_LEVEL_MASK) { @@ -149,9 +218,13 @@ static void ga_log(const gchar *domain, GLogLevelFlags level, } 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); @@ -159,11 +232,177 @@ static void ga_log(const gchar *domain, GLogLevelFlags level, } } +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)); + return false; + } + + if (ftruncate(pidfd, 0) || lseek(pidfd, 0, SEEK_SET)) { + g_critical("Failed to truncate pid file"); + goto fail; + } + sprintf(pidstr, "%d", 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 explictly 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; - int pidfd; - char *pidstr = NULL; pid = fork(); if (pid < 0) { @@ -173,20 +412,11 @@ static void become_daemon(const char *pidfile) exit(EXIT_SUCCESS); } - pidfd = open(pidfile, O_CREAT|O_WRONLY|O_EXCL, S_IRUSR|S_IWUSR); - if (pidfd == -1) { - g_critical("Cannot create pid file, %s", strerror(errno)); - exit(EXIT_FAILURE); - } - - if (asprintf(&pidstr, "%d", getpid()) == -1) { - g_critical("Cannot allocate memory"); - goto fail; - } - if (write(pidfd, pidstr, strlen(pidstr)) != strlen(pidstr)) { - free(pidstr); - g_critical("Failed to write pid file"); - goto fail; + if (pidfile) { + if (!ga_open_pidfile(pidfile)) { + g_critical("failed to create pidfile"); + exit(EXIT_FAILURE); + } } umask(0); @@ -201,75 +431,47 @@ static void become_daemon(const char *pidfile) close(STDIN_FILENO); close(STDOUT_FILENO); close(STDERR_FILENO); - free(pidstr); return; fail: unlink(pidfile); g_critical("failed to daemonize"); exit(EXIT_FAILURE); +#endif } -static int conn_channel_send_buf(GIOChannel *channel, const char *buf, - gsize count) -{ - GError *err = NULL; - gsize written = 0; - GIOStatus status; - - while (count) { - status = g_io_channel_write_chars(channel, buf, count, &written, &err); - g_debug("sending data, count: %d", (int)count); - if (err != NULL) { - g_warning("error sending newline: %s", err->message); - return err->code; - } - if (status == G_IO_STATUS_ERROR || status == G_IO_STATUS_EOF) { - return -EPIPE; - } - - if (status == G_IO_STATUS_NORMAL) { - count -= written; - } - } - - return 0; -} - -static int conn_channel_send_payload(GIOChannel *channel, QObject *payload) +static int send_response(GAState *s, QObject *payload) { - int ret = 0; const char *buf; - QString *payload_qstr; - GError *err = NULL; + QString *payload_qstr, *response_qstr; + GIOStatus status; - g_assert(payload && channel); + g_assert(payload && s->channel); payload_qstr = qobject_to_json(payload); if (!payload_qstr) { return -EINVAL; } - qstring_append_chr(payload_qstr, '\n'); - buf = qstring_get_str(payload_qstr); - ret = conn_channel_send_buf(channel, buf, strlen(buf)); - if (ret) { - goto out_free; + 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; } - g_io_channel_flush(channel, &err); - if (err != NULL) { - g_warning("error flushing payload: %s", err->message); - ret = err->code; - goto out_free; + 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; } -out_free: - QDECREF(payload_qstr); - if (err) { - g_error_free(err); - } - return ret; + return 0; } static void process_command(GAState *s, QDict *req) @@ -281,9 +483,9 @@ static void process_command(GAState *s, QDict *req) g_debug("processing command"); rsp = qmp_dispatch(QOBJECT(req)); if (rsp) { - ret = conn_channel_send_payload(s->conn_channel, rsp); + ret = send_response(s, rsp); if (ret) { - g_warning("error sending payload: %s", strerror(ret)); + g_warning("error sending response: %s", strerror(ret)); } qobject_decref(rsp); } else { @@ -333,38 +535,42 @@ static void process_event(JSONMessageParser *parser, QList *tokens) qdict_put_obj(qdict, "error", error_get_qobject(err)); error_free(err); } - ret = conn_channel_send_payload(s->conn_channel, QOBJECT(qdict)); + ret = send_response(s, QOBJECT(qdict)); if (ret) { - g_warning("error sending payload: %s", strerror(ret)); + g_warning("error sending error response: %s", strerror(ret)); } } QDECREF(qdict); } -static gboolean conn_channel_read(GIOChannel *channel, GIOCondition condition, - gpointer data) +/* false return signals GAChannel to close the current client connection */ +static gboolean channel_event_cb(GIOCondition condition, gpointer data) { GAState *s = data; - gchar buf[1024]; + gchar buf[QGA_READ_COUNT_DEFAULT+1]; gsize count; GError *err = NULL; - memset(buf, 0, 1024); - GIOStatus status = g_io_channel_read_chars(channel, buf, 1024, - &count, &err); + GIOStatus status = ga_channel_read(s->channel, buf, QGA_READ_COUNT_DEFAULT, &count); if (err != NULL) { g_warning("error reading channel: %s", err->message); - conn_channel_close(s); g_error_free(err); return false; } switch (status) { case G_IO_STATUS_ERROR: - g_warning("problem"); + 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 @@ -373,201 +579,130 @@ static gboolean conn_channel_read(GIOChannel *channel, GIOCondition condition, usleep(100*1000); } return true; - case G_IO_STATUS_EOF: - g_debug("received EOF"); - conn_channel_close(s); - if (s->virtio) { - return true; - } - return false; default: g_warning("unknown channel read status, closing"); - conn_channel_close(s); return false; } return true; } -static int conn_channel_add(GAState *s, int fd) +static gboolean channel_init(GAState *s, const gchar *method, const gchar *path) { - GIOChannel *conn_channel; - GError *err = NULL; + GAChannelMethod channel_method; - g_assert(s && !s->conn_channel); - conn_channel = g_io_channel_unix_new(fd); - g_assert(conn_channel); - g_io_channel_set_encoding(conn_channel, NULL, &err); - if (err != NULL) { - g_warning("error setting channel encoding to binary"); - g_error_free(err); - return -1; + if (method == NULL) { + method = "virtio-serial"; } - g_io_add_watch(conn_channel, G_IO_IN | G_IO_HUP, - conn_channel_read, s); - s->conn_channel = conn_channel; - return 0; -} -static gboolean listen_channel_accept(GIOChannel *channel, - GIOCondition condition, gpointer data) -{ - GAState *s = data; - g_assert(channel != NULL); - int ret, conn_fd; - bool accepted = false; - struct sockaddr_un addr; - socklen_t addrlen = sizeof(addr); - - conn_fd = qemu_accept(g_io_channel_unix_get_fd(s->listen_channel), - (struct sockaddr *)&addr, &addrlen); - if (conn_fd == -1) { - g_warning("error converting fd to gsocket: %s", strerror(errno)); - goto out; - } - fcntl(conn_fd, F_SETFL, O_NONBLOCK); - ret = conn_channel_add(s, conn_fd); - if (ret) { - g_warning("error setting up connection"); - goto out; - } - accepted = true; - -out: - /* only accept 1 connection at a time */ - return !accepted; -} + 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; + } -/* start polling for readable events on listen fd, new==true - * indicates we should use the existing s->listen_channel - */ -static int listen_channel_add(GAState *s, int listen_fd, bool new) -{ - if (new) { - s->listen_channel = g_io_channel_unix_new(listen_fd); + 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; } - g_io_add_watch(s->listen_channel, G_IO_IN, - listen_channel_accept, s); - return 0; + + 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; } -/* cleanup state for closed connection/session, start accepting new - * connections if we're in listening mode - */ -static void conn_channel_close(GAState *s) +#ifdef _WIN32 +DWORD WINAPI service_ctrl_handler(DWORD ctrl, DWORD type, LPVOID data, + LPVOID ctx) { - if (strcmp(s->method, "unix-listen") == 0) { - g_io_channel_shutdown(s->conn_channel, true, NULL); - listen_channel_add(s, 0, false); - } else if (strcmp(s->method, "virtio-serial") == 0) { - /* we spin on EOF for virtio-serial, so back off a bit. also, - * dont close the connection in this case, it'll resume normal - * operation when another process connects to host chardev - */ - usleep(100*1000); - goto out_noclose; + 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; } - g_io_channel_unref(s->conn_channel); - s->conn_channel = NULL; -out_noclose: - return; + return ret; } -static void init_guest_agent(GAState *s) +VOID WINAPI service_main(DWORD argc, TCHAR *argv[]) { - struct termios tio; - int ret, fd; + GAService *service = &ga_state->service; - if (s->method == NULL) { - /* try virtio-serial as our default */ - s->method = "virtio-serial"; - } + service->status_handle = RegisterServiceCtrlHandlerEx(QGA_SERVICE_NAME, + service_ctrl_handler, NULL); - if (s->path == NULL) { - if (strcmp(s->method, "virtio-serial") != 0) { - g_critical("must specify a path for this channel"); - exit(EXIT_FAILURE); - } - /* try the default path for the virtio-serial port */ - s->path = QGA_VIRTIO_PATH_DEFAULT; + if (service->status_handle == 0) { + g_critical("Failed to register extended requests function!\n"); + return; } - if (strcmp(s->method, "virtio-serial") == 0) { - s->virtio = true; - fd = qemu_open(s->path, O_RDWR | O_NONBLOCK | O_ASYNC); - if (fd == -1) { - g_critical("error opening channel: %s", strerror(errno)); - exit(EXIT_FAILURE); - } - ret = conn_channel_add(s, fd); - if (ret) { - g_critical("error adding channel to main loop"); - exit(EXIT_FAILURE); - } - } else if (strcmp(s->method, "isa-serial") == 0) { - fd = qemu_open(s->path, O_RDWR | O_NOCTTY); - if (fd == -1) { - g_critical("error opening channel: %s", strerror(errno)); - exit(EXIT_FAILURE); - } - tcgetattr(fd, &tio); - /* set up serial port for non-canonical, dumb byte streaming */ - tio.c_iflag &= ~(IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP | - INLCR | IGNCR | ICRNL | IXON | IXOFF | IXANY | - IMAXBEL); - tio.c_oflag = 0; - tio.c_lflag = 0; - tio.c_cflag |= QGA_BAUDRATE_DEFAULT; - /* 1 available byte min or reads will block (we'll set non-blocking - * elsewhere, else we have to deal with read()=0 instead) - */ - tio.c_cc[VMIN] = 1; - tio.c_cc[VTIME] = 0; - /* flush everything waiting for read/xmit, it's garbage at this point */ - tcflush(fd, TCIFLUSH); - tcsetattr(fd, TCSANOW, &tio); - ret = conn_channel_add(s, fd); - if (ret) { - g_error("error adding channel to main loop"); - } - } else if (strcmp(s->method, "unix-listen") == 0) { - fd = unix_listen(s->path, NULL, strlen(s->path)); - if (fd == -1) { - g_critical("error opening path: %s", strerror(errno)); - exit(EXIT_FAILURE); - } - ret = listen_channel_add(s, fd, true); - if (ret) { - g_critical("error binding/listening to specified socket"); - exit(EXIT_FAILURE); - } - } else { - g_critical("unsupported channel method/type: %s", s->method); - exit(EXIT_FAILURE); - } + 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); - json_message_parser_init(&s->parser, process_event); - s->main_loop = g_main_loop_new(NULL, false); + 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:"; - const char *method = NULL, *path = NULL, *pidfile = QGA_PIDFILE_DEFAULT; + 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", 0, NULL, 'l' }, - { "pidfile", 0, NULL, 'f' }, + { "logfile", 1, NULL, 'l' }, + { "pidfile", 1, NULL, 'f' }, { "verbose", 0, NULL, 'v' }, - { "method", 0, NULL, 'm' }, - { "path", 0, NULL, 'p' }, + { "method", 1, NULL, 'm' }, + { "path", 1, NULL, 'p' }, { "daemonize", 0, NULL, 'd' }, - { "blacklist", 0, NULL, 'b' }, + { "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; - FILE *log_file = stderr; + GList *blacklist = NULL; GAState *s; module_call_init(MODULE_INIT_QAPI); @@ -581,16 +716,14 @@ int main(int argc, char **argv) path = optarg; break; case 'l': - log_file = fopen(optarg, "a"); - if (!log_file) { - g_critical("unable to open specified log file: %s", - strerror(errno)); - return EXIT_FAILURE; - } + log_filepath = optarg; break; case 'f': - pidfile = optarg; + pid_filepath = optarg; break; + case 't': + state_dir = optarg; + break; case 'v': /* enable all log levels */ log_level = G_LOG_LEVEL_MASK; @@ -616,17 +749,28 @@ int main(int argc, char **argv) for (j = 0, i = 0, len = strlen(optarg); i < len; i++) { if (optarg[i] == ',') { optarg[i] = 0; - qmp_disable_command(&optarg[j]); - g_debug("disabling command: %s", &optarg[j]); + blacklist = g_list_append(blacklist, &optarg[j]); j = i + 1; } } if (j < i) { - qmp_disable_command(&optarg[j]); - g_debug("disabling command: %s", &optarg[j]); + 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; @@ -637,32 +781,118 @@ int main(int argc, char **argv) } } - if (daemonize) { - g_debug("starting daemon"); - become_daemon(pidfile); - } - s = g_malloc0(sizeof(GAState)); - s->conn_channel = NULL; - s->path = path; - s->method = method; - s->log_file = log_file; 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); - s->logging_enabled = true; + 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) { + s->log_file = fopen(log_filepath, "a"); + if (!s->log_file) { + g_critical("unable to open specified log file: %s", + strerror(errno)); + goto out_bad; + } + } + } + + 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 - init_guest_agent(ga_state); - register_signal_handlers(); - + 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); - unlink(pidfile); + ga_channel_free(ga_state->channel); + if (daemonize) { + unlink(pid_filepath); + } return 0; + +out_bad: + if (daemonize) { + unlink(pid_filepath); + } + return EXIT_FAILURE; }