]> git.proxmox.com Git - mirror_qemu.git/blame - qga/main.c
qga: vss-win32: Fix interference with snapshot creation by other VSS requesters
[mirror_qemu.git] / qga / main.c
CommitLineData
48ff7a62
MR
1/*
2 * QEMU Guest Agent
3 *
4 * Copyright IBM Corp. 2011
5 *
6 * Authors:
7 * Adam Litke <aglitke@linux.vnet.ibm.com>
8 * Michael Roth <mdroth@linux.vnet.ibm.com>
9 *
10 * This work is licensed under the terms of the GNU GPL, version 2 or later.
11 * See the COPYING file in the top-level directory.
12 */
13#include <stdlib.h>
14#include <stdio.h>
15#include <stdbool.h>
16#include <glib.h>
48ff7a62 17#include <getopt.h>
39097daf 18#include <glib/gstdio.h>
d8ca685a 19#ifndef _WIN32
48ff7a62 20#include <syslog.h>
11d0f125 21#include <sys/wait.h>
f789aa7b 22#include <sys/stat.h>
d8ca685a 23#endif
7b1b5d19
PB
24#include "qapi/qmp/json-streamer.h"
25#include "qapi/qmp/json-parser.h"
26#include "qapi/qmp/qint.h"
27#include "qapi/qmp/qjson.h"
48ff7a62 28#include "qga/guest-agent-core.h"
1de7afc9 29#include "qemu/module.h"
48ff7a62 30#include "signal.h"
7b1b5d19
PB
31#include "qapi/qmp/qerror.h"
32#include "qapi/qmp/dispatch.h"
125b310e 33#include "qga/channel.h"
39097daf 34#include "qemu/bswap.h"
bc62fa03
MR
35#ifdef _WIN32
36#include "qga/service-win32.h"
f311f2c2 37#include "qga/vss-win32.h"
bc62fa03
MR
38#include <windows.h>
39#endif
ec0f694c
TS
40#ifdef __linux__
41#include <linux/fs.h>
42#ifdef FIFREEZE
43#define CONFIG_FSFREEZE
44#endif
45#endif
48ff7a62 46
7868e26e 47#ifndef _WIN32
48ff7a62 48#define QGA_VIRTIO_PATH_DEFAULT "/dev/virtio-ports/org.qemu.guest_agent.0"
c394ecb7 49#define QGA_STATE_RELATIVE_DIR "run"
7868e26e
MR
50#else
51#define QGA_VIRTIO_PATH_DEFAULT "\\\\.\\Global\\org.qemu.guest_agent.0"
c394ecb7 52#define QGA_STATE_RELATIVE_DIR "qemu-ga"
7868e26e 53#endif
ec0f694c
TS
54#ifdef CONFIG_FSFREEZE
55#define QGA_FSFREEZE_HOOK_DEFAULT CONFIG_QEMU_CONFDIR "/fsfreeze-hook"
56#endif
3cf0bed8 57#define QGA_SENTINEL_BYTE 0xFF
48ff7a62 58
c394ecb7
LE
59static struct {
60 const char *state_dir;
61 const char *pidfile;
62} dfl_pathnames;
63
39097daf
MR
64typedef struct GAPersistentState {
65#define QGA_PSTATE_DEFAULT_FD_COUNTER 1000
66 int64_t fd_counter;
67} GAPersistentState;
68
48ff7a62
MR
69struct GAState {
70 JSONMessageParser parser;
71 GMainLoop *main_loop;
125b310e 72 GAChannel *channel;
48ff7a62
MR
73 bool virtio; /* fastpath to check for virtio to deal with poll() quirks */
74 GACommandState *command_state;
75 GLogLevelFlags log_level;
76 FILE *log_file;
77 bool logging_enabled;
bc62fa03
MR
78#ifdef _WIN32
79 GAService service;
80#endif
3cf0bed8 81 bool delimit_response;
f22d85e9
MR
82 bool frozen;
83 GList *blacklist;
f789aa7b
MR
84 const char *state_filepath_isfrozen;
85 struct {
86 const char *log_filepath;
87 const char *pid_filepath;
88 } deferred_options;
ec0f694c
TS
89#ifdef CONFIG_FSFREEZE
90 const char *fsfreeze_hook;
91#endif
39097daf
MR
92 const gchar *pstate_filepath;
93 GAPersistentState pstate;
48ff7a62
MR
94};
95
3cf0bed8 96struct GAState *ga_state;
48ff7a62 97
f22d85e9
MR
98/* commands that are safe to issue while filesystems are frozen */
99static const char *ga_freeze_whitelist[] = {
100 "guest-ping",
101 "guest-info",
102 "guest-sync",
c5dcb6ae 103 "guest-sync-delimited",
f22d85e9
MR
104 "guest-fsfreeze-status",
105 "guest-fsfreeze-thaw",
106 NULL
107};
108
bc62fa03
MR
109#ifdef _WIN32
110DWORD WINAPI service_ctrl_handler(DWORD ctrl, DWORD type, LPVOID data,
111 LPVOID ctx);
112VOID WINAPI service_main(DWORD argc, TCHAR *argv[]);
113#endif
114
c394ecb7
LE
115static void
116init_dfl_pathnames(void)
117{
118 g_assert(dfl_pathnames.state_dir == NULL);
119 g_assert(dfl_pathnames.pidfile == NULL);
120 dfl_pathnames.state_dir = qemu_get_local_state_pathname(
121 QGA_STATE_RELATIVE_DIR);
122 dfl_pathnames.pidfile = qemu_get_local_state_pathname(
123 QGA_STATE_RELATIVE_DIR G_DIR_SEPARATOR_S "qemu-ga.pid");
124}
125
48ff7a62
MR
126static void quit_handler(int sig)
127{
f22d85e9
MR
128 /* if we're frozen, don't exit unless we're absolutely forced to,
129 * because it's basically impossible for graceful exit to complete
130 * unless all log/pid files are on unfreezable filesystems. there's
131 * also a very likely chance killing the agent before unfreezing
132 * the filesystems is a mistake (or will be viewed as one later).
133 */
134 if (ga_is_frozen(ga_state)) {
135 return;
136 }
2542bfd5 137 g_debug("received signal num %d, quitting", sig);
48ff7a62
MR
138
139 if (g_main_loop_is_running(ga_state->main_loop)) {
140 g_main_loop_quit(ga_state->main_loop);
141 }
142}
143
bc62fa03 144#ifndef _WIN32
125b310e 145static gboolean register_signal_handlers(void)
48ff7a62 146{
dc8764f0 147 struct sigaction sigact;
48ff7a62
MR
148 int ret;
149
150 memset(&sigact, 0, sizeof(struct sigaction));
151 sigact.sa_handler = quit_handler;
152
153 ret = sigaction(SIGINT, &sigact, NULL);
154 if (ret == -1) {
155 g_error("error configuring signal handler: %s", strerror(errno));
48ff7a62
MR
156 }
157 ret = sigaction(SIGTERM, &sigact, NULL);
158 if (ret == -1) {
159 g_error("error configuring signal handler: %s", strerror(errno));
160 }
11d0f125 161
125b310e 162 return true;
48ff7a62 163}
04b4e75f
LC
164
165/* TODO: use this in place of all post-fork() fclose(std*) callers */
166void reopen_fd_to_null(int fd)
167{
168 int nullfd;
169
170 nullfd = open("/dev/null", O_RDWR);
171 if (nullfd < 0) {
172 return;
173 }
174
175 dup2(nullfd, fd);
176
177 if (nullfd != fd) {
178 close(nullfd);
179 }
180}
d8ca685a 181#endif
48ff7a62
MR
182
183static void usage(const char *cmd)
184{
185 printf(
4bdd0416 186"Usage: %s [-m <method> -p <path>] [<options>]\n"
48ff7a62
MR
187"QEMU Guest Agent %s\n"
188"\n"
189" -m, --method transport method: one of unix-listen, virtio-serial, or\n"
190" isa-serial (virtio-serial is the default)\n"
4bdd0416
MR
191" -p, --path device/socket path (the default for virtio-serial is:\n"
192" %s)\n"
48ff7a62
MR
193" -l, --logfile set logfile path, logs to stderr by default\n"
194" -f, --pidfile specify pidfile (default is %s)\n"
ec0f694c
TS
195#ifdef CONFIG_FSFREEZE
196" -F, --fsfreeze-hook\n"
197" enable fsfreeze hook. Accepts an optional argument that\n"
198" specifies script to run on freeze/thaw. Script will be\n"
199" called with 'freeze'/'thaw' arguments accordingly.\n"
200" (default is %s)\n"
201" If using -F with an argument, do not follow -F with a\n"
202" space.\n"
203" (for example: -F/var/run/fsfreezehook.sh)\n"
204#endif
f789aa7b
MR
205" -t, --statedir specify dir to store state information (absolute paths\n"
206" only, default is %s)\n"
48ff7a62
MR
207" -v, --verbose log extra debugging information\n"
208" -V, --version print version information and exit\n"
209" -d, --daemonize become a daemon\n"
bc62fa03
MR
210#ifdef _WIN32
211" -s, --service service commands: install, uninstall\n"
d8ca685a 212#endif
4bdd0416 213" -b, --blacklist comma-separated list of RPCs to disable (no spaces, \"?\"\n"
abd6cf6d 214" to list available RPCs)\n"
48ff7a62
MR
215" -h, --help display this help and exit\n"
216"\n"
217"Report bugs to <mdroth@linux.vnet.ibm.com>\n"
c394ecb7 218 , cmd, QEMU_VERSION, QGA_VIRTIO_PATH_DEFAULT, dfl_pathnames.pidfile,
ec0f694c
TS
219#ifdef CONFIG_FSFREEZE
220 QGA_FSFREEZE_HOOK_DEFAULT,
221#endif
c394ecb7 222 dfl_pathnames.state_dir);
48ff7a62
MR
223}
224
48ff7a62
MR
225static const char *ga_log_level_str(GLogLevelFlags level)
226{
227 switch (level & G_LOG_LEVEL_MASK) {
228 case G_LOG_LEVEL_ERROR:
229 return "error";
230 case G_LOG_LEVEL_CRITICAL:
231 return "critical";
232 case G_LOG_LEVEL_WARNING:
233 return "warning";
234 case G_LOG_LEVEL_MESSAGE:
235 return "message";
236 case G_LOG_LEVEL_INFO:
237 return "info";
238 case G_LOG_LEVEL_DEBUG:
239 return "debug";
240 default:
241 return "user";
242 }
243}
244
245bool ga_logging_enabled(GAState *s)
246{
247 return s->logging_enabled;
248}
249
250void ga_disable_logging(GAState *s)
251{
252 s->logging_enabled = false;
253}
254
255void ga_enable_logging(GAState *s)
256{
257 s->logging_enabled = true;
258}
259
260static void ga_log(const gchar *domain, GLogLevelFlags level,
261 const gchar *msg, gpointer opaque)
262{
263 GAState *s = opaque;
264 GTimeVal time;
265 const char *level_str = ga_log_level_str(level);
266
267 if (!ga_logging_enabled(s)) {
268 return;
269 }
270
271 level &= G_LOG_LEVEL_MASK;
d8ca685a 272#ifndef _WIN32
8f477478 273 if (domain && strcmp(domain, "syslog") == 0) {
48ff7a62
MR
274 syslog(LOG_INFO, "%s: %s", level_str, msg);
275 } else if (level & s->log_level) {
d8ca685a
MR
276#else
277 if (level & s->log_level) {
278#endif
48ff7a62
MR
279 g_get_current_time(&time);
280 fprintf(s->log_file,
281 "%lu.%lu: %s: %s\n", time.tv_sec, time.tv_usec, level_str, msg);
282 fflush(s->log_file);
283 }
284}
285
3cf0bed8
MR
286void ga_set_response_delimited(GAState *s)
287{
288 s->delimit_response = true;
289}
290
9e92f6d4
LC
291static FILE *ga_open_logfile(const char *logfile)
292{
293 FILE *f;
294
295 f = fopen(logfile, "a");
296 if (!f) {
297 return NULL;
298 }
299
300 qemu_set_cloexec(fileno(f));
301 return f;
302}
303
f789aa7b
MR
304#ifndef _WIN32
305static bool ga_open_pidfile(const char *pidfile)
306{
307 int pidfd;
308 char pidstr[32];
309
6ffacc5d 310 pidfd = qemu_open(pidfile, O_CREAT|O_WRONLY, S_IRUSR|S_IWUSR);
f789aa7b
MR
311 if (pidfd == -1 || lockf(pidfd, F_TLOCK, 0)) {
312 g_critical("Cannot lock pid file, %s", strerror(errno));
4144f122
JM
313 if (pidfd != -1) {
314 close(pidfd);
315 }
f789aa7b
MR
316 return false;
317 }
318
5d27f9ce 319 if (ftruncate(pidfd, 0)) {
f789aa7b
MR
320 g_critical("Failed to truncate pid file");
321 goto fail;
322 }
9d6f1b73 323 snprintf(pidstr, sizeof(pidstr), "%d\n", getpid());
f789aa7b
MR
324 if (write(pidfd, pidstr, strlen(pidstr)) != strlen(pidstr)) {
325 g_critical("Failed to write pid file");
326 goto fail;
327 }
328
03ac10f1 329 /* keep pidfile open & locked forever */
f789aa7b
MR
330 return true;
331
332fail:
333 unlink(pidfile);
03ac10f1 334 close(pidfd);
f789aa7b
MR
335 return false;
336}
337#else /* _WIN32 */
338static bool ga_open_pidfile(const char *pidfile)
339{
340 return true;
341}
342#endif
343
f22d85e9
MR
344static gint ga_strcmp(gconstpointer str1, gconstpointer str2)
345{
346 return strcmp(str1, str2);
347}
348
349/* disable commands that aren't safe for fsfreeze */
8dc4d915 350static void ga_disable_non_whitelisted(QmpCommand *cmd, void *opaque)
f22d85e9 351{
8dc4d915
MW
352 bool whitelisted = false;
353 int i = 0;
354 const char *name = qmp_command_name(cmd);
355
356 while (ga_freeze_whitelist[i] != NULL) {
357 if (strcmp(name, ga_freeze_whitelist[i]) == 0) {
358 whitelisted = true;
f22d85e9 359 }
8dc4d915
MW
360 i++;
361 }
362 if (!whitelisted) {
363 g_debug("disabling command: %s", name);
364 qmp_disable_command(name);
f22d85e9 365 }
f22d85e9
MR
366}
367
a31f0531 368/* [re-]enable all commands, except those explicitly blacklisted by user */
8dc4d915 369static void ga_enable_non_blacklisted(QmpCommand *cmd, void *opaque)
f22d85e9 370{
8dc4d915
MW
371 GList *blacklist = opaque;
372 const char *name = qmp_command_name(cmd);
373
374 if (g_list_find_custom(blacklist, name, ga_strcmp) == NULL &&
375 !qmp_command_is_enabled(cmd)) {
376 g_debug("enabling command: %s", name);
377 qmp_enable_command(name);
f22d85e9 378 }
f22d85e9
MR
379}
380
f789aa7b
MR
381static bool ga_create_file(const char *path)
382{
383 int fd = open(path, O_CREAT | O_WRONLY, S_IWUSR | S_IRUSR);
384 if (fd == -1) {
385 g_warning("unable to open/create file %s: %s", path, strerror(errno));
386 return false;
387 }
388 close(fd);
389 return true;
390}
391
392static bool ga_delete_file(const char *path)
393{
394 int ret = unlink(path);
395 if (ret == -1) {
396 g_warning("unable to delete file: %s: %s", path, strerror(errno));
397 return false;
398 }
399
400 return true;
401}
402
f22d85e9
MR
403bool ga_is_frozen(GAState *s)
404{
405 return s->frozen;
406}
407
408void ga_set_frozen(GAState *s)
409{
410 if (ga_is_frozen(s)) {
411 return;
412 }
413 /* disable all non-whitelisted (for frozen state) commands */
8dc4d915 414 qmp_for_each_command(ga_disable_non_whitelisted, NULL);
f22d85e9
MR
415 g_warning("disabling logging due to filesystem freeze");
416 ga_disable_logging(s);
417 s->frozen = true;
f789aa7b
MR
418 if (!ga_create_file(s->state_filepath_isfrozen)) {
419 g_warning("unable to create %s, fsfreeze may not function properly",
420 s->state_filepath_isfrozen);
421 }
f22d85e9
MR
422}
423
424void ga_unset_frozen(GAState *s)
425{
426 if (!ga_is_frozen(s)) {
427 return;
428 }
429
f789aa7b
MR
430 /* if we delayed creation/opening of pid/log files due to being
431 * in a frozen state at start up, do it now
432 */
433 if (s->deferred_options.log_filepath) {
9e92f6d4 434 s->log_file = ga_open_logfile(s->deferred_options.log_filepath);
f789aa7b
MR
435 if (!s->log_file) {
436 s->log_file = stderr;
437 }
438 s->deferred_options.log_filepath = NULL;
439 }
f22d85e9 440 ga_enable_logging(s);
f789aa7b
MR
441 g_warning("logging re-enabled due to filesystem unfreeze");
442 if (s->deferred_options.pid_filepath) {
443 if (!ga_open_pidfile(s->deferred_options.pid_filepath)) {
444 g_warning("failed to create/open pid file");
445 }
446 s->deferred_options.pid_filepath = NULL;
447 }
f22d85e9
MR
448
449 /* enable all disabled, non-blacklisted commands */
8dc4d915 450 qmp_for_each_command(ga_enable_non_blacklisted, s->blacklist);
f22d85e9 451 s->frozen = false;
f789aa7b
MR
452 if (!ga_delete_file(s->state_filepath_isfrozen)) {
453 g_warning("unable to delete %s, fsfreeze may not function properly",
454 s->state_filepath_isfrozen);
455 }
f22d85e9
MR
456}
457
ec0f694c
TS
458#ifdef CONFIG_FSFREEZE
459const char *ga_fsfreeze_hook(GAState *s)
460{
461 return s->fsfreeze_hook;
462}
463#endif
464
48ff7a62
MR
465static void become_daemon(const char *pidfile)
466{
f789aa7b 467#ifndef _WIN32
48ff7a62 468 pid_t pid, sid;
48ff7a62
MR
469
470 pid = fork();
471 if (pid < 0) {
472 exit(EXIT_FAILURE);
473 }
474 if (pid > 0) {
475 exit(EXIT_SUCCESS);
476 }
477
f789aa7b
MR
478 if (pidfile) {
479 if (!ga_open_pidfile(pidfile)) {
480 g_critical("failed to create pidfile");
481 exit(EXIT_FAILURE);
482 }
48ff7a62
MR
483 }
484
c689b4f1 485 umask(S_IRWXG | S_IRWXO);
48ff7a62
MR
486 sid = setsid();
487 if (sid < 0) {
488 goto fail;
489 }
490 if ((chdir("/")) < 0) {
491 goto fail;
492 }
493
226a4894
LC
494 reopen_fd_to_null(STDIN_FILENO);
495 reopen_fd_to_null(STDOUT_FILENO);
496 reopen_fd_to_null(STDERR_FILENO);
48ff7a62
MR
497 return;
498
499fail:
4bdb1a30
SW
500 if (pidfile) {
501 unlink(pidfile);
502 }
48ff7a62
MR
503 g_critical("failed to daemonize");
504 exit(EXIT_FAILURE);
d8ca685a 505#endif
f789aa7b 506}
48ff7a62 507
125b310e 508static int send_response(GAState *s, QObject *payload)
48ff7a62 509{
48ff7a62 510 const char *buf;
3cf0bed8 511 QString *payload_qstr, *response_qstr;
125b310e 512 GIOStatus status;
48ff7a62 513
125b310e 514 g_assert(payload && s->channel);
48ff7a62
MR
515
516 payload_qstr = qobject_to_json(payload);
517 if (!payload_qstr) {
518 return -EINVAL;
519 }
520
3cf0bed8
MR
521 if (s->delimit_response) {
522 s->delimit_response = false;
523 response_qstr = qstring_new();
524 qstring_append_chr(response_qstr, QGA_SENTINEL_BYTE);
525 qstring_append(response_qstr, qstring_get_str(payload_qstr));
526 QDECREF(payload_qstr);
527 } else {
528 response_qstr = payload_qstr;
529 }
530
531 qstring_append_chr(response_qstr, '\n');
532 buf = qstring_get_str(response_qstr);
125b310e 533 status = ga_channel_write_all(s->channel, buf, strlen(buf));
3cf0bed8 534 QDECREF(response_qstr);
125b310e
MR
535 if (status != G_IO_STATUS_NORMAL) {
536 return -EIO;
48ff7a62 537 }
125b310e
MR
538
539 return 0;
48ff7a62
MR
540}
541
542static void process_command(GAState *s, QDict *req)
543{
544 QObject *rsp = NULL;
545 int ret;
546
547 g_assert(req);
548 g_debug("processing command");
549 rsp = qmp_dispatch(QOBJECT(req));
550 if (rsp) {
125b310e 551 ret = send_response(s, rsp);
48ff7a62 552 if (ret) {
125b310e 553 g_warning("error sending response: %s", strerror(ret));
48ff7a62
MR
554 }
555 qobject_decref(rsp);
48ff7a62
MR
556 }
557}
558
559/* handle requests/control events coming in over the channel */
560static void process_event(JSONMessageParser *parser, QList *tokens)
561{
562 GAState *s = container_of(parser, GAState, parser);
563 QObject *obj;
564 QDict *qdict;
565 Error *err = NULL;
566 int ret;
567
568 g_assert(s && parser);
569
570 g_debug("process_event: called");
571 obj = json_parser_parse_err(tokens, NULL, &err);
572 if (err || !obj || qobject_type(obj) != QTYPE_QDICT) {
573 qobject_decref(obj);
574 qdict = qdict_new();
575 if (!err) {
576 g_warning("failed to parse event: unknown error");
577 error_set(&err, QERR_JSON_PARSING);
578 } else {
579 g_warning("failed to parse event: %s", error_get_pretty(err));
580 }
93b91c59 581 qdict_put_obj(qdict, "error", qmp_build_error_object(err));
48ff7a62
MR
582 error_free(err);
583 } else {
584 qdict = qobject_to_qdict(obj);
585 }
586
587 g_assert(qdict);
588
589 /* handle host->guest commands */
590 if (qdict_haskey(qdict, "execute")) {
591 process_command(s, qdict);
592 } else {
593 if (!qdict_haskey(qdict, "error")) {
594 QDECREF(qdict);
595 qdict = qdict_new();
596 g_warning("unrecognized payload format");
597 error_set(&err, QERR_UNSUPPORTED);
93b91c59 598 qdict_put_obj(qdict, "error", qmp_build_error_object(err));
48ff7a62
MR
599 error_free(err);
600 }
125b310e 601 ret = send_response(s, QOBJECT(qdict));
48ff7a62 602 if (ret) {
125b310e 603 g_warning("error sending error response: %s", strerror(ret));
48ff7a62
MR
604 }
605 }
606
607 QDECREF(qdict);
608}
609
125b310e
MR
610/* false return signals GAChannel to close the current client connection */
611static gboolean channel_event_cb(GIOCondition condition, gpointer data)
48ff7a62
MR
612{
613 GAState *s = data;
125b310e 614 gchar buf[QGA_READ_COUNT_DEFAULT+1];
48ff7a62
MR
615 gsize count;
616 GError *err = NULL;
125b310e 617 GIOStatus status = ga_channel_read(s->channel, buf, QGA_READ_COUNT_DEFAULT, &count);
48ff7a62
MR
618 if (err != NULL) {
619 g_warning("error reading channel: %s", err->message);
48ff7a62
MR
620 g_error_free(err);
621 return false;
622 }
623 switch (status) {
624 case G_IO_STATUS_ERROR:
125b310e 625 g_warning("error reading channel");
48ff7a62
MR
626 return false;
627 case G_IO_STATUS_NORMAL:
125b310e 628 buf[count] = 0;
48ff7a62
MR
629 g_debug("read data, count: %d, data: %s", (int)count, buf);
630 json_message_parser_feed(&s->parser, (char *)buf, (int)count);
125b310e
MR
631 break;
632 case G_IO_STATUS_EOF:
633 g_debug("received EOF");
634 if (!s->virtio) {
635 return false;
636 }
f5b79578 637 /* fall through */
48ff7a62
MR
638 case G_IO_STATUS_AGAIN:
639 /* virtio causes us to spin here when no process is attached to
640 * host-side chardev. sleep a bit to mitigate this
641 */
642 if (s->virtio) {
643 usleep(100*1000);
644 }
645 return true;
48ff7a62
MR
646 default:
647 g_warning("unknown channel read status, closing");
48ff7a62
MR
648 return false;
649 }
650 return true;
651}
652
125b310e 653static gboolean channel_init(GAState *s, const gchar *method, const gchar *path)
48ff7a62 654{
125b310e 655 GAChannelMethod channel_method;
48ff7a62 656
125b310e
MR
657 if (method == NULL) {
658 method = "virtio-serial";
48ff7a62
MR
659 }
660
125b310e
MR
661 if (path == NULL) {
662 if (strcmp(method, "virtio-serial") != 0) {
48ff7a62 663 g_critical("must specify a path for this channel");
125b310e 664 return false;
48ff7a62
MR
665 }
666 /* try the default path for the virtio-serial port */
125b310e 667 path = QGA_VIRTIO_PATH_DEFAULT;
48ff7a62
MR
668 }
669
125b310e
MR
670 if (strcmp(method, "virtio-serial") == 0) {
671 s->virtio = true; /* virtio requires special handling in some cases */
672 channel_method = GA_CHANNEL_VIRTIO_SERIAL;
673 } else if (strcmp(method, "isa-serial") == 0) {
674 channel_method = GA_CHANNEL_ISA_SERIAL;
675 } else if (strcmp(method, "unix-listen") == 0) {
676 channel_method = GA_CHANNEL_UNIX_LISTEN;
48ff7a62 677 } else {
125b310e
MR
678 g_critical("unsupported channel method/type: %s", method);
679 return false;
48ff7a62
MR
680 }
681
125b310e
MR
682 s->channel = ga_channel_new(channel_method, path, channel_event_cb, s);
683 if (!s->channel) {
684 g_critical("failed to create guest agent channel");
685 return false;
686 }
687
688 return true;
48ff7a62
MR
689}
690
bc62fa03
MR
691#ifdef _WIN32
692DWORD WINAPI service_ctrl_handler(DWORD ctrl, DWORD type, LPVOID data,
693 LPVOID ctx)
694{
695 DWORD ret = NO_ERROR;
696 GAService *service = &ga_state->service;
697
698 switch (ctrl)
699 {
700 case SERVICE_CONTROL_STOP:
701 case SERVICE_CONTROL_SHUTDOWN:
702 quit_handler(SIGTERM);
703 service->status.dwCurrentState = SERVICE_STOP_PENDING;
704 SetServiceStatus(service->status_handle, &service->status);
705 break;
706
707 default:
708 ret = ERROR_CALL_NOT_IMPLEMENTED;
709 }
710 return ret;
711}
712
713VOID WINAPI service_main(DWORD argc, TCHAR *argv[])
714{
715 GAService *service = &ga_state->service;
716
717 service->status_handle = RegisterServiceCtrlHandlerEx(QGA_SERVICE_NAME,
718 service_ctrl_handler, NULL);
719
720 if (service->status_handle == 0) {
721 g_critical("Failed to register extended requests function!\n");
722 return;
723 }
724
725 service->status.dwServiceType = SERVICE_WIN32;
726 service->status.dwCurrentState = SERVICE_RUNNING;
727 service->status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
728 service->status.dwWin32ExitCode = NO_ERROR;
729 service->status.dwServiceSpecificExitCode = NO_ERROR;
730 service->status.dwCheckPoint = 0;
731 service->status.dwWaitHint = 0;
732 SetServiceStatus(service->status_handle, &service->status);
733
734 g_main_loop_run(ga_state->main_loop);
735
736 service->status.dwCurrentState = SERVICE_STOPPED;
737 SetServiceStatus(service->status_handle, &service->status);
738}
739#endif
740
39097daf
MR
741static void set_persistent_state_defaults(GAPersistentState *pstate)
742{
743 g_assert(pstate);
744 pstate->fd_counter = QGA_PSTATE_DEFAULT_FD_COUNTER;
745}
746
747static void persistent_state_from_keyfile(GAPersistentState *pstate,
748 GKeyFile *keyfile)
749{
750 g_assert(pstate);
751 g_assert(keyfile);
752 /* if any fields are missing, either because the file was tampered with
753 * by agents of chaos, or because the field wasn't present at the time the
754 * file was created, the best we can ever do is start over with the default
755 * values. so load them now, and ignore any errors in accessing key-value
756 * pairs
757 */
758 set_persistent_state_defaults(pstate);
759
760 if (g_key_file_has_key(keyfile, "global", "fd_counter", NULL)) {
761 pstate->fd_counter =
4f306496 762 g_key_file_get_integer(keyfile, "global", "fd_counter", NULL);
39097daf
MR
763 }
764}
765
766static void persistent_state_to_keyfile(const GAPersistentState *pstate,
767 GKeyFile *keyfile)
768{
769 g_assert(pstate);
770 g_assert(keyfile);
771
4f306496 772 g_key_file_set_integer(keyfile, "global", "fd_counter", pstate->fd_counter);
39097daf
MR
773}
774
775static gboolean write_persistent_state(const GAPersistentState *pstate,
776 const gchar *path)
777{
778 GKeyFile *keyfile = g_key_file_new();
779 GError *gerr = NULL;
780 gboolean ret = true;
781 gchar *data = NULL;
782 gsize data_len;
783
784 g_assert(pstate);
785
786 persistent_state_to_keyfile(pstate, keyfile);
787 data = g_key_file_to_data(keyfile, &data_len, &gerr);
788 if (gerr) {
789 g_critical("failed to convert persistent state to string: %s",
790 gerr->message);
791 ret = false;
792 goto out;
793 }
794
795 g_file_set_contents(path, data, data_len, &gerr);
796 if (gerr) {
797 g_critical("failed to write persistent state to %s: %s",
798 path, gerr->message);
799 ret = false;
800 goto out;
801 }
802
803out:
804 if (gerr) {
805 g_error_free(gerr);
806 }
807 if (keyfile) {
808 g_key_file_free(keyfile);
809 }
810 g_free(data);
811 return ret;
812}
813
814static gboolean read_persistent_state(GAPersistentState *pstate,
815 const gchar *path, gboolean frozen)
816{
817 GKeyFile *keyfile = NULL;
818 GError *gerr = NULL;
819 struct stat st;
820 gboolean ret = true;
821
822 g_assert(pstate);
823
824 if (stat(path, &st) == -1) {
825 /* it's okay if state file doesn't exist, but any other error
826 * indicates a permissions issue or some other misconfiguration
827 * that we likely won't be able to recover from.
828 */
829 if (errno != ENOENT) {
830 g_critical("unable to access state file at path %s: %s",
831 path, strerror(errno));
832 ret = false;
833 goto out;
834 }
835
836 /* file doesn't exist. initialize state to default values and
837 * attempt to save now. (we could wait till later when we have
838 * modified state we need to commit, but if there's a problem,
839 * such as a missing parent directory, we want to catch it now)
840 *
841 * there is a potential scenario where someone either managed to
842 * update the agent from a version that didn't use a key store
843 * while qemu-ga thought the filesystem was frozen, or
844 * deleted the key store prior to issuing a fsfreeze, prior
845 * to restarting the agent. in this case we go ahead and defer
846 * initial creation till we actually have modified state to
847 * write, otherwise fail to recover from freeze.
848 */
849 set_persistent_state_defaults(pstate);
850 if (!frozen) {
851 ret = write_persistent_state(pstate, path);
852 if (!ret) {
853 g_critical("unable to create state file at path %s", path);
854 ret = false;
855 goto out;
856 }
857 }
858 ret = true;
859 goto out;
860 }
861
862 keyfile = g_key_file_new();
863 g_key_file_load_from_file(keyfile, path, 0, &gerr);
864 if (gerr) {
865 g_critical("error loading persistent state from path: %s, %s",
866 path, gerr->message);
867 ret = false;
868 goto out;
869 }
870
871 persistent_state_from_keyfile(pstate, keyfile);
872
873out:
874 if (keyfile) {
875 g_key_file_free(keyfile);
876 }
877 if (gerr) {
878 g_error_free(gerr);
879 }
880
881 return ret;
882}
883
884int64_t ga_get_fd_handle(GAState *s, Error **errp)
885{
886 int64_t handle;
887
888 g_assert(s->pstate_filepath);
889 /* we blacklist commands and avoid operations that potentially require
890 * writing to disk when we're in a frozen state. this includes opening
891 * new files, so we should never get here in that situation
892 */
893 g_assert(!ga_is_frozen(s));
894
895 handle = s->pstate.fd_counter++;
ce7f7cc2
LC
896
897 /* This should never happen on a reasonable timeframe, as guest-file-open
898 * would have to be issued 2^63 times */
899 if (s->pstate.fd_counter == INT64_MAX) {
900 abort();
39097daf 901 }
ce7f7cc2 902
39097daf
MR
903 if (!write_persistent_state(&s->pstate, s->pstate_filepath)) {
904 error_setg(errp, "failed to commit persistent state to disk");
905 }
906
907 return handle;
908}
909
8dc4d915
MW
910static void ga_print_cmd(QmpCommand *cmd, void *opaque)
911{
912 printf("%s\n", qmp_command_name(cmd));
913}
914
48ff7a62
MR
915int main(int argc, char **argv)
916{
ec0f694c 917 const char *sopt = "hVvdm:p:l:f:F::b:s:t:";
f789aa7b
MR
918 const char *method = NULL, *path = NULL;
919 const char *log_filepath = NULL;
c394ecb7 920 const char *pid_filepath;
ec0f694c
TS
921#ifdef CONFIG_FSFREEZE
922 const char *fsfreeze_hook = NULL;
923#endif
c394ecb7 924 const char *state_dir;
bc62fa03
MR
925#ifdef _WIN32
926 const char *service = NULL;
927#endif
48ff7a62
MR
928 const struct option lopt[] = {
929 { "help", 0, NULL, 'h' },
930 { "version", 0, NULL, 'V' },
bc62fa03
MR
931 { "logfile", 1, NULL, 'l' },
932 { "pidfile", 1, NULL, 'f' },
ec0f694c
TS
933#ifdef CONFIG_FSFREEZE
934 { "fsfreeze-hook", 2, NULL, 'F' },
935#endif
48ff7a62 936 { "verbose", 0, NULL, 'v' },
bc62fa03
MR
937 { "method", 1, NULL, 'm' },
938 { "path", 1, NULL, 'p' },
48ff7a62 939 { "daemonize", 0, NULL, 'd' },
bc62fa03
MR
940 { "blacklist", 1, NULL, 'b' },
941#ifdef _WIN32
942 { "service", 1, NULL, 's' },
f22d85e9 943#endif
f789aa7b 944 { "statedir", 1, NULL, 't' },
48ff7a62
MR
945 { NULL, 0, NULL, 0 }
946 };
abd6cf6d 947 int opt_ind = 0, ch, daemonize = 0, i, j, len;
48ff7a62 948 GLogLevelFlags log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL;
f22d85e9 949 GList *blacklist = NULL;
48ff7a62
MR
950 GAState *s;
951
abd6cf6d
MR
952 module_call_init(MODULE_INIT_QAPI);
953
c394ecb7
LE
954 init_dfl_pathnames();
955 pid_filepath = dfl_pathnames.pidfile;
956 state_dir = dfl_pathnames.state_dir;
957
48ff7a62
MR
958 while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) {
959 switch (ch) {
960 case 'm':
961 method = optarg;
962 break;
963 case 'p':
964 path = optarg;
965 break;
966 case 'l':
f789aa7b 967 log_filepath = optarg;
48ff7a62
MR
968 break;
969 case 'f':
f789aa7b 970 pid_filepath = optarg;
48ff7a62 971 break;
ec0f694c
TS
972#ifdef CONFIG_FSFREEZE
973 case 'F':
974 fsfreeze_hook = optarg ? optarg : QGA_FSFREEZE_HOOK_DEFAULT;
975 break;
976#endif
f789aa7b
MR
977 case 't':
978 state_dir = optarg;
979 break;
48ff7a62
MR
980 case 'v':
981 /* enable all log levels */
982 log_level = G_LOG_LEVEL_MASK;
983 break;
984 case 'V':
8efacc43 985 printf("QEMU Guest Agent %s\n", QEMU_VERSION);
48ff7a62
MR
986 return 0;
987 case 'd':
988 daemonize = 1;
989 break;
abd6cf6d 990 case 'b': {
c8057f95 991 if (is_help_option(optarg)) {
8dc4d915 992 qmp_for_each_command(ga_print_cmd, NULL);
abd6cf6d
MR
993 return 0;
994 }
995 for (j = 0, i = 0, len = strlen(optarg); i < len; i++) {
996 if (optarg[i] == ',') {
997 optarg[i] = 0;
f22d85e9 998 blacklist = g_list_append(blacklist, &optarg[j]);
abd6cf6d
MR
999 j = i + 1;
1000 }
1001 }
1002 if (j < i) {
f22d85e9 1003 blacklist = g_list_append(blacklist, &optarg[j]);
abd6cf6d
MR
1004 }
1005 break;
1006 }
bc62fa03
MR
1007#ifdef _WIN32
1008 case 's':
1009 service = optarg;
1010 if (strcmp(service, "install") == 0) {
a839ee77
LE
1011 const char *fixed_state_dir;
1012
1013 /* If the user passed the "-t" option, we save that state dir
1014 * in the service. Otherwise we let the service fetch the state
1015 * dir from the environment when it starts.
1016 */
1017 fixed_state_dir = (state_dir == dfl_pathnames.state_dir) ?
1018 NULL :
1019 state_dir;
f311f2c2
TS
1020 if (ga_install_vss_provider()) {
1021 return EXIT_FAILURE;
1022 }
1023 if (ga_install_service(path, log_filepath, fixed_state_dir)) {
1024 return EXIT_FAILURE;
1025 }
1026 return 0;
bc62fa03 1027 } else if (strcmp(service, "uninstall") == 0) {
f311f2c2 1028 ga_uninstall_vss_provider();
bc62fa03
MR
1029 return ga_uninstall_service();
1030 } else {
1031 printf("Unknown service command.\n");
1032 return EXIT_FAILURE;
1033 }
1034 break;
1035#endif
48ff7a62
MR
1036 case 'h':
1037 usage(argv[0]);
1038 return 0;
1039 case '?':
1040 g_print("Unknown option, try '%s --help' for more information.\n",
1041 argv[0]);
1042 return EXIT_FAILURE;
1043 }
1044 }
1045
bf12c1fa
LE
1046#ifdef _WIN32
1047 /* On win32 the state directory is application specific (be it the default
1048 * or a user override). We got past the command line parsing; let's create
1049 * the directory (with any intermediate directories). If we run into an
1050 * error later on, we won't try to clean up the directory, it is considered
1051 * persistent.
1052 */
1053 if (g_mkdir_with_parents(state_dir, S_IRWXU) == -1) {
1054 g_critical("unable to create (an ancestor of) the state directory"
1055 " '%s': %s", state_dir, strerror(errno));
1056 return EXIT_FAILURE;
1057 }
1058#endif
1059
7267c094 1060 s = g_malloc0(sizeof(GAState));
48ff7a62 1061 s->log_level = log_level;
f789aa7b 1062 s->log_file = stderr;
ec0f694c
TS
1063#ifdef CONFIG_FSFREEZE
1064 s->fsfreeze_hook = fsfreeze_hook;
1065#endif
48ff7a62
MR
1066 g_log_set_default_handler(ga_log, s);
1067 g_log_set_fatal_mask(NULL, G_LOG_LEVEL_ERROR);
f789aa7b
MR
1068 ga_enable_logging(s);
1069 s->state_filepath_isfrozen = g_strdup_printf("%s/qga.state.isfrozen",
1070 state_dir);
39097daf 1071 s->pstate_filepath = g_strdup_printf("%s/qga.state", state_dir);
f22d85e9 1072 s->frozen = false;
39097daf 1073
f789aa7b
MR
1074#ifndef _WIN32
1075 /* check if a previous instance of qemu-ga exited with filesystems' state
1076 * marked as frozen. this could be a stale value (a non-qemu-ga process
1077 * or reboot may have since unfrozen them), but better to require an
1078 * uneeded unfreeze than to risk hanging on start-up
1079 */
1080 struct stat st;
1081 if (stat(s->state_filepath_isfrozen, &st) == -1) {
1082 /* it's okay if the file doesn't exist, but if we can't access for
1083 * some other reason, such as permissions, there's a configuration
1084 * that needs to be addressed. so just bail now before we get into
1085 * more trouble later
1086 */
1087 if (errno != ENOENT) {
1088 g_critical("unable to access state file at path %s: %s",
1089 s->state_filepath_isfrozen, strerror(errno));
1090 return EXIT_FAILURE;
1091 }
1092 } else {
1093 g_warning("previous instance appears to have exited with frozen"
1094 " filesystems. deferring logging/pidfile creation and"
1095 " disabling non-fsfreeze-safe commands until"
1096 " guest-fsfreeze-thaw is issued, or filesystems are"
1097 " manually unfrozen and the file %s is removed",
1098 s->state_filepath_isfrozen);
1099 s->frozen = true;
1100 }
1101#endif
1102
1103 if (ga_is_frozen(s)) {
1104 if (daemonize) {
1105 /* delay opening/locking of pidfile till filesystem are unfrozen */
1106 s->deferred_options.pid_filepath = pid_filepath;
1107 become_daemon(NULL);
1108 }
1109 if (log_filepath) {
1110 /* delay opening the log file till filesystems are unfrozen */
1111 s->deferred_options.log_filepath = log_filepath;
1112 }
1113 ga_disable_logging(s);
8dc4d915 1114 qmp_for_each_command(ga_disable_non_whitelisted, NULL);
f789aa7b
MR
1115 } else {
1116 if (daemonize) {
1117 become_daemon(pid_filepath);
1118 }
1119 if (log_filepath) {
9e92f6d4 1120 FILE *log_file = ga_open_logfile(log_filepath);
6c615ec5 1121 if (!log_file) {
f789aa7b
MR
1122 g_critical("unable to open specified log file: %s",
1123 strerror(errno));
1124 goto out_bad;
1125 }
6c615ec5 1126 s->log_file = log_file;
f789aa7b
MR
1127 }
1128 }
1129
39097daf
MR
1130 /* load persistent state from disk */
1131 if (!read_persistent_state(&s->pstate,
1132 s->pstate_filepath,
1133 ga_is_frozen(s))) {
1134 g_critical("failed to load persistent state");
1135 goto out_bad;
1136 }
1137
f22d85e9
MR
1138 if (blacklist) {
1139 s->blacklist = blacklist;
1140 do {
1141 g_debug("disabling command: %s", (char *)blacklist->data);
1142 qmp_disable_command(blacklist->data);
1143 blacklist = g_list_next(blacklist);
1144 } while (blacklist);
1145 }
e3d4d252
MR
1146 s->command_state = ga_command_state_new();
1147 ga_command_state_init(s, s->command_state);
1148 ga_command_state_init_all(s->command_state);
125b310e 1149 json_message_parser_init(&s->parser, process_event);
48ff7a62 1150 ga_state = s;
d8ca685a 1151#ifndef _WIN32
125b310e
MR
1152 if (!register_signal_handlers()) {
1153 g_critical("failed to register signal handlers");
1154 goto out_bad;
1155 }
d8ca685a 1156#endif
48ff7a62 1157
125b310e
MR
1158 s->main_loop = g_main_loop_new(NULL, false);
1159 if (!channel_init(ga_state, method, path)) {
1160 g_critical("failed to initialize guest agent channel");
1161 goto out_bad;
1162 }
bc62fa03 1163#ifndef _WIN32
48ff7a62 1164 g_main_loop_run(ga_state->main_loop);
bc62fa03
MR
1165#else
1166 if (daemonize) {
1167 SERVICE_TABLE_ENTRY service_table[] = {
1168 { (char *)QGA_SERVICE_NAME, service_main }, { NULL, NULL } };
1169 StartServiceCtrlDispatcher(service_table);
1170 } else {
1171 g_main_loop_run(ga_state->main_loop);
1172 }
1173#endif
48ff7a62 1174
e3d4d252 1175 ga_command_state_cleanup_all(ga_state->command_state);
125b310e 1176 ga_channel_free(ga_state->channel);
48ff7a62 1177
125b310e 1178 if (daemonize) {
f789aa7b 1179 unlink(pid_filepath);
125b310e 1180 }
48ff7a62 1181 return 0;
125b310e
MR
1182
1183out_bad:
1184 if (daemonize) {
f789aa7b 1185 unlink(pid_filepath);
125b310e
MR
1186 }
1187 return EXIT_FAILURE;
48ff7a62 1188}