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