4 * Copyright IBM Corp. 2011
7 * Adam Litke <aglitke@linux.vnet.ibm.com>
8 * Michael Roth <mdroth@linux.vnet.ibm.com>
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.
18 #include <glib/gstdio.h>
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"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/qmp/dispatch.h"
33 #include "qga/channel.h"
34 #include "qemu/bswap.h"
36 #include "qga/service-win32.h"
37 #include "qga/vss-win32.h"
42 #define CONFIG_FSFREEZE
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"
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"
55 #ifdef CONFIG_FSFREEZE
56 #define QGA_FSFREEZE_HOOK_DEFAULT CONFIG_QEMU_CONFDIR "/fsfreeze-hook"
58 #define QGA_SENTINEL_BYTE 0xFF
61 const char *state_dir
;
65 typedef struct GAPersistentState
{
66 #define QGA_PSTATE_DEFAULT_FD_COUNTER 1000
71 JSONMessageParser parser
;
74 bool virtio
; /* fastpath to check for virtio to deal with poll() quirks */
75 GACommandState
*command_state
;
76 GLogLevelFlags log_level
;
82 bool delimit_response
;
85 char *state_filepath_isfrozen
;
87 const char *log_filepath
;
88 const char *pid_filepath
;
90 #ifdef CONFIG_FSFREEZE
91 const char *fsfreeze_hook
;
93 gchar
*pstate_filepath
;
94 GAPersistentState pstate
;
97 struct GAState
*ga_state
;
99 /* commands that are safe to issue while filesystems are frozen */
100 static const char *ga_freeze_whitelist
[] = {
104 "guest-sync-delimited",
105 "guest-fsfreeze-status",
106 "guest-fsfreeze-thaw",
111 DWORD WINAPI
service_ctrl_handler(DWORD ctrl
, DWORD type
, LPVOID data
,
113 VOID WINAPI
service_main(DWORD argc
, TCHAR
*argv
[]);
117 init_dfl_pathnames(void)
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");
127 static void quit_handler(int sig
)
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).
135 if (ga_is_frozen(ga_state
)) {
138 g_debug("received signal num %d, quitting", sig
);
140 if (g_main_loop_is_running(ga_state
->main_loop
)) {
141 g_main_loop_quit(ga_state
->main_loop
);
146 static gboolean
register_signal_handlers(void)
148 struct sigaction sigact
;
151 memset(&sigact
, 0, sizeof(struct sigaction
));
152 sigact
.sa_handler
= quit_handler
;
154 ret
= sigaction(SIGINT
, &sigact
, NULL
);
156 g_error("error configuring signal handler: %s", strerror(errno
));
158 ret
= sigaction(SIGTERM
, &sigact
, NULL
);
160 g_error("error configuring signal handler: %s", strerror(errno
));
166 /* TODO: use this in place of all post-fork() fclose(std*) callers */
167 void reopen_fd_to_null(int fd
)
171 nullfd
= open("/dev/null", O_RDWR
);
184 static void usage(const char *cmd
)
187 "Usage: %s [-m <method> -p <path>] [<options>]\n"
188 "QEMU Guest Agent %s\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"
194 " the default for isa-serial is:\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"
204 " If using -F with an argument, do not follow -F with a\n"
206 " (for example: -F/var/run/fsfreezehook.sh)\n"
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"
214 " -s, --service service commands: install, uninstall, vss-install, vss-uninstall\n"
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"
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
,
226 dfl_pathnames
.state_dir
);
229 static const char *ga_log_level_str(GLogLevelFlags level
)
231 switch (level
& G_LOG_LEVEL_MASK
) {
232 case G_LOG_LEVEL_ERROR
:
234 case G_LOG_LEVEL_CRITICAL
:
236 case G_LOG_LEVEL_WARNING
:
238 case G_LOG_LEVEL_MESSAGE
:
240 case G_LOG_LEVEL_INFO
:
242 case G_LOG_LEVEL_DEBUG
:
249 bool ga_logging_enabled(GAState
*s
)
251 return s
->logging_enabled
;
254 void ga_disable_logging(GAState
*s
)
256 s
->logging_enabled
= false;
259 void ga_enable_logging(GAState
*s
)
261 s
->logging_enabled
= true;
264 static void ga_log(const gchar
*domain
, GLogLevelFlags level
,
265 const gchar
*msg
, gpointer opaque
)
269 const char *level_str
= ga_log_level_str(level
);
271 if (!ga_logging_enabled(s
)) {
275 level
&= G_LOG_LEVEL_MASK
;
277 if (g_strcmp0(domain
, "syslog") == 0) {
278 syslog(LOG_INFO
, "%s: %s", level_str
, msg
);
279 } else if (level
& s
->log_level
) {
281 if (level
& s
->log_level
) {
283 g_get_current_time(&time
);
285 "%lu.%lu: %s: %s\n", time
.tv_sec
, time
.tv_usec
, level_str
, msg
);
290 void ga_set_response_delimited(GAState
*s
)
292 s
->delimit_response
= true;
295 static FILE *ga_open_logfile(const char *logfile
)
299 f
= fopen(logfile
, "a");
304 qemu_set_cloexec(fileno(f
));
309 static bool ga_open_pidfile(const char *pidfile
)
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
));
323 if (ftruncate(pidfd
, 0)) {
324 g_critical("Failed to truncate pid file");
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");
333 /* keep pidfile open & locked forever */
342 static bool ga_open_pidfile(const char *pidfile
)
348 static gint
ga_strcmp(gconstpointer str1
, gconstpointer str2
)
350 return strcmp(str1
, str2
);
353 /* disable commands that aren't safe for fsfreeze */
354 static void ga_disable_non_whitelisted(QmpCommand
*cmd
, void *opaque
)
356 bool whitelisted
= false;
358 const char *name
= qmp_command_name(cmd
);
360 while (ga_freeze_whitelist
[i
] != NULL
) {
361 if (strcmp(name
, ga_freeze_whitelist
[i
]) == 0) {
367 g_debug("disabling command: %s", name
);
368 qmp_disable_command(name
);
372 /* [re-]enable all commands, except those explicitly blacklisted by user */
373 static void ga_enable_non_blacklisted(QmpCommand
*cmd
, void *opaque
)
375 GList
*blacklist
= opaque
;
376 const char *name
= qmp_command_name(cmd
);
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
);
385 static bool ga_create_file(const char *path
)
387 int fd
= open(path
, O_CREAT
| O_WRONLY
, S_IWUSR
| S_IRUSR
);
389 g_warning("unable to open/create file %s: %s", path
, strerror(errno
));
396 static bool ga_delete_file(const char *path
)
398 int ret
= unlink(path
);
400 g_warning("unable to delete file: %s: %s", path
, strerror(errno
));
407 bool ga_is_frozen(GAState
*s
)
412 void ga_set_frozen(GAState
*s
)
414 if (ga_is_frozen(s
)) {
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
);
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
);
428 void ga_unset_frozen(GAState
*s
)
430 if (!ga_is_frozen(s
)) {
434 /* if we delayed creation/opening of pid/log files due to being
435 * in a frozen state at start up, do it now
437 if (s
->deferred_options
.log_filepath
) {
438 s
->log_file
= ga_open_logfile(s
->deferred_options
.log_filepath
);
440 s
->log_file
= stderr
;
442 s
->deferred_options
.log_filepath
= NULL
;
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");
450 s
->deferred_options
.pid_filepath
= NULL
;
453 /* enable all disabled, non-blacklisted commands */
454 qmp_for_each_command(ga_enable_non_blacklisted
, s
->blacklist
);
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
);
462 #ifdef CONFIG_FSFREEZE
463 const char *ga_fsfreeze_hook(GAState
*s
)
465 return s
->fsfreeze_hook
;
469 static void become_daemon(const char *pidfile
)
483 if (!ga_open_pidfile(pidfile
)) {
484 g_critical("failed to create pidfile");
489 umask(S_IRWXG
| S_IRWXO
);
494 if ((chdir("/")) < 0) {
498 reopen_fd_to_null(STDIN_FILENO
);
499 reopen_fd_to_null(STDOUT_FILENO
);
500 reopen_fd_to_null(STDERR_FILENO
);
507 g_critical("failed to daemonize");
512 static int send_response(GAState
*s
, QObject
*payload
)
515 QString
*payload_qstr
, *response_qstr
;
518 g_assert(payload
&& s
->channel
);
520 payload_qstr
= qobject_to_json(payload
);
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
);
532 response_qstr
= payload_qstr
;
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
) {
546 static void process_command(GAState
*s
, QDict
*req
)
552 g_debug("processing command");
553 rsp
= qmp_dispatch(QOBJECT(req
));
555 ret
= send_response(s
, rsp
);
557 g_warning("error sending response: %s", strerror(ret
));
563 /* handle requests/control events coming in over the channel */
564 static void process_event(JSONMessageParser
*parser
, QList
*tokens
)
566 GAState
*s
= container_of(parser
, GAState
, parser
);
572 g_assert(s
&& parser
);
574 g_debug("process_event: called");
575 obj
= json_parser_parse_err(tokens
, NULL
, &err
);
576 if (err
|| !obj
|| qobject_type(obj
) != QTYPE_QDICT
) {
580 g_warning("failed to parse event: unknown error");
581 error_setg(&err
, QERR_JSON_PARSING
);
583 g_warning("failed to parse event: %s", error_get_pretty(err
));
585 qdict_put_obj(qdict
, "error", qmp_build_error_object(err
));
588 qdict
= qobject_to_qdict(obj
);
593 /* handle host->guest commands */
594 if (qdict_haskey(qdict
, "execute")) {
595 process_command(s
, qdict
);
597 if (!qdict_haskey(qdict
, "error")) {
600 g_warning("unrecognized payload format");
601 error_setg(&err
, QERR_UNSUPPORTED
);
602 qdict_put_obj(qdict
, "error", qmp_build_error_object(err
));
605 ret
= send_response(s
, QOBJECT(qdict
));
607 g_warning("error sending error response: %s", strerror(-ret
));
614 /* false return signals GAChannel to close the current client connection */
615 static gboolean
channel_event_cb(GIOCondition condition
, gpointer data
)
618 gchar buf
[QGA_READ_COUNT_DEFAULT
+1];
621 GIOStatus status
= ga_channel_read(s
->channel
, buf
, QGA_READ_COUNT_DEFAULT
, &count
);
623 g_warning("error reading channel: %s", err
->message
);
628 case G_IO_STATUS_ERROR
:
629 g_warning("error reading channel");
631 case G_IO_STATUS_NORMAL
:
633 g_debug("read data, count: %d, data: %s", (int)count
, buf
);
634 json_message_parser_feed(&s
->parser
, (char *)buf
, (int)count
);
636 case G_IO_STATUS_EOF
:
637 g_debug("received EOF");
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
651 g_warning("unknown channel read status, closing");
657 static gboolean
channel_init(GAState
*s
, const gchar
*method
, const gchar
*path
)
659 GAChannelMethod channel_method
;
661 if (strcmp(method
, "virtio-serial") == 0) {
662 s
->virtio
= true; /* virtio requires special handling in some cases */
663 channel_method
= GA_CHANNEL_VIRTIO_SERIAL
;
664 } else if (strcmp(method
, "isa-serial") == 0) {
665 channel_method
= GA_CHANNEL_ISA_SERIAL
;
666 } else if (strcmp(method
, "unix-listen") == 0) {
667 channel_method
= GA_CHANNEL_UNIX_LISTEN
;
669 g_critical("unsupported channel method/type: %s", method
);
673 s
->channel
= ga_channel_new(channel_method
, path
, channel_event_cb
, s
);
675 g_critical("failed to create guest agent channel");
683 DWORD WINAPI
service_ctrl_handler(DWORD ctrl
, DWORD type
, LPVOID data
,
686 DWORD ret
= NO_ERROR
;
687 GAService
*service
= &ga_state
->service
;
691 case SERVICE_CONTROL_STOP
:
692 case SERVICE_CONTROL_SHUTDOWN
:
693 quit_handler(SIGTERM
);
694 service
->status
.dwCurrentState
= SERVICE_STOP_PENDING
;
695 SetServiceStatus(service
->status_handle
, &service
->status
);
699 ret
= ERROR_CALL_NOT_IMPLEMENTED
;
704 VOID WINAPI
service_main(DWORD argc
, TCHAR
*argv
[])
706 GAService
*service
= &ga_state
->service
;
708 service
->status_handle
= RegisterServiceCtrlHandlerEx(QGA_SERVICE_NAME
,
709 service_ctrl_handler
, NULL
);
711 if (service
->status_handle
== 0) {
712 g_critical("Failed to register extended requests function!\n");
716 service
->status
.dwServiceType
= SERVICE_WIN32
;
717 service
->status
.dwCurrentState
= SERVICE_RUNNING
;
718 service
->status
.dwControlsAccepted
= SERVICE_ACCEPT_STOP
| SERVICE_ACCEPT_SHUTDOWN
;
719 service
->status
.dwWin32ExitCode
= NO_ERROR
;
720 service
->status
.dwServiceSpecificExitCode
= NO_ERROR
;
721 service
->status
.dwCheckPoint
= 0;
722 service
->status
.dwWaitHint
= 0;
723 SetServiceStatus(service
->status_handle
, &service
->status
);
725 g_main_loop_run(ga_state
->main_loop
);
727 service
->status
.dwCurrentState
= SERVICE_STOPPED
;
728 SetServiceStatus(service
->status_handle
, &service
->status
);
732 static void set_persistent_state_defaults(GAPersistentState
*pstate
)
735 pstate
->fd_counter
= QGA_PSTATE_DEFAULT_FD_COUNTER
;
738 static void persistent_state_from_keyfile(GAPersistentState
*pstate
,
743 /* if any fields are missing, either because the file was tampered with
744 * by agents of chaos, or because the field wasn't present at the time the
745 * file was created, the best we can ever do is start over with the default
746 * values. so load them now, and ignore any errors in accessing key-value
749 set_persistent_state_defaults(pstate
);
751 if (g_key_file_has_key(keyfile
, "global", "fd_counter", NULL
)) {
753 g_key_file_get_integer(keyfile
, "global", "fd_counter", NULL
);
757 static void persistent_state_to_keyfile(const GAPersistentState
*pstate
,
763 g_key_file_set_integer(keyfile
, "global", "fd_counter", pstate
->fd_counter
);
766 static gboolean
write_persistent_state(const GAPersistentState
*pstate
,
769 GKeyFile
*keyfile
= g_key_file_new();
777 persistent_state_to_keyfile(pstate
, keyfile
);
778 data
= g_key_file_to_data(keyfile
, &data_len
, &gerr
);
780 g_critical("failed to convert persistent state to string: %s",
786 g_file_set_contents(path
, data
, data_len
, &gerr
);
788 g_critical("failed to write persistent state to %s: %s",
789 path
, gerr
->message
);
799 g_key_file_free(keyfile
);
805 static gboolean
read_persistent_state(GAPersistentState
*pstate
,
806 const gchar
*path
, gboolean frozen
)
808 GKeyFile
*keyfile
= NULL
;
815 if (stat(path
, &st
) == -1) {
816 /* it's okay if state file doesn't exist, but any other error
817 * indicates a permissions issue or some other misconfiguration
818 * that we likely won't be able to recover from.
820 if (errno
!= ENOENT
) {
821 g_critical("unable to access state file at path %s: %s",
822 path
, strerror(errno
));
827 /* file doesn't exist. initialize state to default values and
828 * attempt to save now. (we could wait till later when we have
829 * modified state we need to commit, but if there's a problem,
830 * such as a missing parent directory, we want to catch it now)
832 * there is a potential scenario where someone either managed to
833 * update the agent from a version that didn't use a key store
834 * while qemu-ga thought the filesystem was frozen, or
835 * deleted the key store prior to issuing a fsfreeze, prior
836 * to restarting the agent. in this case we go ahead and defer
837 * initial creation till we actually have modified state to
838 * write, otherwise fail to recover from freeze.
840 set_persistent_state_defaults(pstate
);
842 ret
= write_persistent_state(pstate
, path
);
844 g_critical("unable to create state file at path %s", path
);
853 keyfile
= g_key_file_new();
854 g_key_file_load_from_file(keyfile
, path
, 0, &gerr
);
856 g_critical("error loading persistent state from path: %s, %s",
857 path
, gerr
->message
);
862 persistent_state_from_keyfile(pstate
, keyfile
);
866 g_key_file_free(keyfile
);
875 int64_t ga_get_fd_handle(GAState
*s
, Error
**errp
)
879 g_assert(s
->pstate_filepath
);
880 /* we blacklist commands and avoid operations that potentially require
881 * writing to disk when we're in a frozen state. this includes opening
882 * new files, so we should never get here in that situation
884 g_assert(!ga_is_frozen(s
));
886 handle
= s
->pstate
.fd_counter
++;
888 /* This should never happen on a reasonable timeframe, as guest-file-open
889 * would have to be issued 2^63 times */
890 if (s
->pstate
.fd_counter
== INT64_MAX
) {
894 if (!write_persistent_state(&s
->pstate
, s
->pstate_filepath
)) {
895 error_setg(errp
, "failed to commit persistent state to disk");
902 static void ga_print_cmd(QmpCommand
*cmd
, void *opaque
)
904 printf("%s\n", qmp_command_name(cmd
));
907 static GList
*split_list(const gchar
*str
, const gchar
*delim
)
913 strv
= g_strsplit(str
, delim
, -1);
914 for (i
= 0; strv
[i
]; i
++) {
915 list
= g_list_prepend(list
, strv
[i
]);
922 typedef struct GAConfig
{
927 #ifdef CONFIG_FSFREEZE
936 GLogLevelFlags log_level
;
939 static GAConfig
*config_parse(int argc
, char **argv
)
941 GAConfig
*config
= g_new0(GAConfig
, 1);
942 const char *sopt
= "hVvdm:p:l:f:F::b:s:t:D";
944 const struct option lopt
[] = {
945 { "help", 0, NULL
, 'h' },
946 { "version", 0, NULL
, 'V' },
947 { "logfile", 1, NULL
, 'l' },
948 { "pidfile", 1, NULL
, 'f' },
949 #ifdef CONFIG_FSFREEZE
950 { "fsfreeze-hook", 2, NULL
, 'F' },
952 { "verbose", 0, NULL
, 'v' },
953 { "method", 1, NULL
, 'm' },
954 { "path", 1, NULL
, 'p' },
955 { "daemonize", 0, NULL
, 'd' },
956 { "blacklist", 1, NULL
, 'b' },
958 { "service", 1, NULL
, 's' },
960 { "statedir", 1, NULL
, 't' },
964 config
->log_level
= G_LOG_LEVEL_ERROR
| G_LOG_LEVEL_CRITICAL
;
966 while ((ch
= getopt_long(argc
, argv
, sopt
, lopt
, &opt_ind
)) != -1) {
969 config
->method
= g_strdup(optarg
);
972 config
->channel_path
= g_strdup(optarg
);
975 config
->log_filepath
= g_strdup(optarg
);
978 config
->pid_filepath
= g_strdup(optarg
);
980 #ifdef CONFIG_FSFREEZE
982 config
->fsfreeze_hook
= g_strdup(optarg
?: QGA_FSFREEZE_HOOK_DEFAULT
);
986 config
->state_dir
= g_strdup(optarg
);
989 /* enable all log levels */
990 config
->log_level
= G_LOG_LEVEL_MASK
;
993 printf("QEMU Guest Agent %s\n", QEMU_VERSION
);
996 config
->daemonize
= 1;
999 if (is_help_option(optarg
)) {
1000 qmp_for_each_command(ga_print_cmd
, NULL
);
1003 config
->blacklist
= g_list_concat(config
->blacklist
,
1004 split_list(optarg
, ","));
1009 config
->service
= optarg
;
1010 if (strcmp(config
->service
, "install") == 0) {
1011 if (ga_install_vss_provider()) {
1014 if (ga_install_service(config
->channel_path
,
1015 config
->log_filepath
, config
->state_dir
)) {
1019 } else if (strcmp(config
->service
, "uninstall") == 0) {
1020 ga_uninstall_vss_provider();
1021 exit(ga_uninstall_service());
1022 } else if (strcmp(config
->service
, "vss-install") == 0) {
1023 if (ga_install_vss_provider()) {
1027 } else if (strcmp(config
->service
, "vss-uninstall") == 0) {
1028 ga_uninstall_vss_provider();
1031 printf("Unknown service command.\n");
1040 g_print("Unknown option, try '%s --help' for more information.\n",
1049 static void config_free(GAConfig
*config
)
1051 g_free(config
->method
);
1052 g_free(config
->log_filepath
);
1053 g_free(config
->pid_filepath
);
1054 g_free(config
->state_dir
);
1055 g_free(config
->channel_path
);
1056 #ifdef CONFIG_FSFREEZE
1057 g_free(config
->fsfreeze_hook
);
1062 static bool check_is_frozen(GAState
*s
)
1065 /* check if a previous instance of qemu-ga exited with filesystems' state
1066 * marked as frozen. this could be a stale value (a non-qemu-ga process
1067 * or reboot may have since unfrozen them), but better to require an
1068 * uneeded unfreeze than to risk hanging on start-up
1071 if (stat(s
->state_filepath_isfrozen
, &st
) == -1) {
1072 /* it's okay if the file doesn't exist, but if we can't access for
1073 * some other reason, such as permissions, there's a configuration
1074 * that needs to be addressed. so just bail now before we get into
1075 * more trouble later
1077 if (errno
!= ENOENT
) {
1078 g_critical("unable to access state file at path %s: %s",
1079 s
->state_filepath_isfrozen
, strerror(errno
));
1080 return EXIT_FAILURE
;
1083 g_warning("previous instance appears to have exited with frozen"
1084 " filesystems. deferring logging/pidfile creation and"
1085 " disabling non-fsfreeze-safe commands until"
1086 " guest-fsfreeze-thaw is issued, or filesystems are"
1087 " manually unfrozen and the file %s is removed",
1088 s
->state_filepath_isfrozen
);
1095 static int run_agent(GAState
*s
, GAConfig
*config
)
1099 g_log_set_default_handler(ga_log
, s
);
1100 g_log_set_fatal_mask(NULL
, G_LOG_LEVEL_ERROR
);
1101 ga_enable_logging(s
);
1104 /* On win32 the state directory is application specific (be it the default
1105 * or a user override). We got past the command line parsing; let's create
1106 * the directory (with any intermediate directories). If we run into an
1107 * error later on, we won't try to clean up the directory, it is considered
1110 if (g_mkdir_with_parents(config
->state_dir
, S_IRWXU
) == -1) {
1111 g_critical("unable to create (an ancestor of) the state directory"
1112 " '%s': %s", config
->state_dir
, strerror(errno
));
1113 return EXIT_FAILURE
;
1117 if (ga_is_frozen(s
)) {
1118 if (config
->daemonize
) {
1119 /* delay opening/locking of pidfile till filesystems are unfrozen */
1120 s
->deferred_options
.pid_filepath
= config
->pid_filepath
;
1121 become_daemon(NULL
);
1123 if (config
->log_filepath
) {
1124 /* delay opening the log file till filesystems are unfrozen */
1125 s
->deferred_options
.log_filepath
= config
->log_filepath
;
1127 ga_disable_logging(s
);
1128 qmp_for_each_command(ga_disable_non_whitelisted
, NULL
);
1130 if (config
->daemonize
) {
1131 become_daemon(config
->pid_filepath
);
1133 if (config
->log_filepath
) {
1134 FILE *log_file
= ga_open_logfile(config
->log_filepath
);
1136 g_critical("unable to open specified log file: %s",
1138 return EXIT_FAILURE
;
1140 s
->log_file
= log_file
;
1144 /* load persistent state from disk */
1145 if (!read_persistent_state(&s
->pstate
,
1148 g_critical("failed to load persistent state");
1149 return EXIT_FAILURE
;
1152 config
->blacklist
= ga_command_blacklist_init(config
->blacklist
);
1153 if (config
->blacklist
) {
1154 GList
*l
= config
->blacklist
;
1155 s
->blacklist
= config
->blacklist
;
1157 g_debug("disabling command: %s", (char *)l
->data
);
1158 qmp_disable_command(l
->data
);
1162 s
->command_state
= ga_command_state_new();
1163 ga_command_state_init(s
, s
->command_state
);
1164 ga_command_state_init_all(s
->command_state
);
1165 json_message_parser_init(&s
->parser
, process_event
);
1168 if (!register_signal_handlers()) {
1169 g_critical("failed to register signal handlers");
1170 return EXIT_FAILURE
;
1174 s
->main_loop
= g_main_loop_new(NULL
, false);
1175 if (!channel_init(ga_state
, config
->method
, config
->channel_path
)) {
1176 g_critical("failed to initialize guest agent channel");
1177 return EXIT_FAILURE
;
1180 g_main_loop_run(ga_state
->main_loop
);
1182 if (config
->daemonize
) {
1183 SERVICE_TABLE_ENTRY service_table
[] = {
1184 { (char *)QGA_SERVICE_NAME
, service_main
}, { NULL
, NULL
} };
1185 StartServiceCtrlDispatcher(service_table
);
1187 g_main_loop_run(ga_state
->main_loop
);
1191 return EXIT_SUCCESS
;
1194 static void free_blacklist_entry(gpointer entry
, gpointer unused
)
1199 int main(int argc
, char **argv
)
1201 int ret
= EXIT_SUCCESS
;
1202 GAState
*s
= g_new0(GAState
, 1);
1205 module_call_init(MODULE_INIT_QAPI
);
1207 init_dfl_pathnames();
1209 config
= config_parse(argc
, argv
);
1211 if (config
->pid_filepath
== NULL
) {
1212 config
->pid_filepath
= g_strdup(dfl_pathnames
.pidfile
);
1215 if (config
->state_dir
== NULL
) {
1216 config
->state_dir
= g_strdup(dfl_pathnames
.state_dir
);
1219 if (config
->method
== NULL
) {
1220 config
->method
= g_strdup("virtio-serial");
1223 if (config
->channel_path
== NULL
) {
1224 if (strcmp(config
->method
, "virtio-serial") == 0) {
1225 /* try the default path for the virtio-serial port */
1226 config
->channel_path
= g_strdup(QGA_VIRTIO_PATH_DEFAULT
);
1227 } else if (strcmp(config
->method
, "isa-serial") == 0) {
1228 /* try the default path for the serial port - COM1 */
1229 config
->channel_path
= g_strdup(QGA_SERIAL_PATH_DEFAULT
);
1231 g_critical("must specify a path for this channel");
1237 s
->log_level
= config
->log_level
;
1238 s
->log_file
= stderr
;
1239 #ifdef CONFIG_FSFREEZE
1240 s
->fsfreeze_hook
= config
->fsfreeze_hook
;
1242 s
->pstate_filepath
= g_strdup_printf("%s/qga.state", config
->state_dir
);
1243 s
->state_filepath_isfrozen
= g_strdup_printf("%s/qga.state.isfrozen",
1245 s
->frozen
= check_is_frozen(s
);
1247 ret
= run_agent(s
, config
);
1250 if (s
->command_state
) {
1251 ga_command_state_cleanup_all(s
->command_state
);
1254 ga_channel_free(s
->channel
);
1256 g_list_foreach(config
->blacklist
, free_blacklist_entry
, NULL
);
1257 g_free(s
->pstate_filepath
);
1258 g_free(s
->state_filepath_isfrozen
);
1260 if (config
->daemonize
) {
1261 unlink(config
->pid_filepath
);
1264 config_free(config
);