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.
14 #include "qemu/osdep.h"
16 #include <glib/gstdio.h>
21 #include "qapi/qmp/json-parser.h"
22 #include "qapi/qmp/qdict.h"
23 #include "qapi/qmp/qjson.h"
24 #include "qapi/qmp/qstring.h"
25 #include "guest-agent-core.h"
26 #include "qemu/module.h"
27 #include "qga-qapi-commands.h"
28 #include "qapi/qmp/qerror.h"
29 #include "qapi/error.h"
31 #include "qemu/bswap.h"
32 #include "qemu/help_option.h"
33 #include "qemu/sockets.h"
34 #include "qemu/systemd.h"
35 #include "qemu-version.h"
37 #include "qga/service-win32.h"
38 #include "qga/vss-win32.h"
43 #define CONFIG_FSFREEZE
48 #define QGA_VIRTIO_PATH_DEFAULT "/dev/virtio-ports/org.qemu.guest_agent.0"
49 #define QGA_STATE_RELATIVE_DIR "run"
50 #define QGA_SERIAL_PATH_DEFAULT "/dev/ttyS0"
52 #define QGA_VIRTIO_PATH_DEFAULT "\\\\.\\Global\\org.qemu.guest_agent.0"
53 #define QGA_STATE_RELATIVE_DIR "qemu-ga"
54 #define QGA_SERIAL_PATH_DEFAULT "COM1"
56 #ifdef CONFIG_FSFREEZE
57 #define QGA_FSFREEZE_HOOK_DEFAULT CONFIG_QEMU_CONFDIR "/fsfreeze-hook"
59 #define QGA_SENTINEL_BYTE 0xFF
60 #define QGA_CONF_DEFAULT CONFIG_QEMU_CONFDIR G_DIR_SEPARATOR_S "qemu-ga.conf"
61 #define QGA_RETRY_INTERVAL 5
64 const char *state_dir
;
68 typedef struct GAPersistentState
{
69 #define QGA_PSTATE_DEFAULT_FD_COUNTER 1000
73 typedef struct GAConfig GAConfig
;
76 JSONMessageParser parser
;
79 bool virtio
; /* fastpath to check for virtio to deal with poll() quirks */
80 GACommandState
*command_state
;
81 GLogLevelFlags log_level
;
87 bool delimit_response
;
90 char *state_filepath_isfrozen
;
92 const char *log_filepath
;
93 const char *pid_filepath
;
95 #ifdef CONFIG_FSFREEZE
96 const char *fsfreeze_hook
;
98 gchar
*pstate_filepath
;
99 GAPersistentState pstate
;
101 int socket_activation
;
105 struct GAState
*ga_state
;
106 QmpCommandList ga_commands
;
108 /* commands that are safe to issue while filesystems are frozen */
109 static const char *ga_freeze_whitelist
[] = {
113 "guest-sync-delimited",
114 "guest-fsfreeze-status",
115 "guest-fsfreeze-thaw",
120 DWORD WINAPI
service_ctrl_handler(DWORD ctrl
, DWORD type
, LPVOID data
,
122 VOID WINAPI
service_main(DWORD argc
, TCHAR
*argv
[]);
124 static int run_agent(GAState
*s
);
125 static void stop_agent(GAState
*s
, bool requested
);
128 init_dfl_pathnames(void)
130 g_assert(dfl_pathnames
.state_dir
== NULL
);
131 g_assert(dfl_pathnames
.pidfile
== NULL
);
132 dfl_pathnames
.state_dir
= qemu_get_local_state_pathname(
133 QGA_STATE_RELATIVE_DIR
);
134 dfl_pathnames
.pidfile
= qemu_get_local_state_pathname(
135 QGA_STATE_RELATIVE_DIR G_DIR_SEPARATOR_S
"qemu-ga.pid");
138 static void quit_handler(int sig
)
140 /* if we're frozen, don't exit unless we're absolutely forced to,
141 * because it's basically impossible for graceful exit to complete
142 * unless all log/pid files are on unfreezable filesystems. there's
143 * also a very likely chance killing the agent before unfreezing
144 * the filesystems is a mistake (or will be viewed as one later).
145 * On Windows the freeze interval is limited to 10 seconds, so
146 * we should quit, but first we should wait for the timeout, thaw
147 * the filesystem and quit.
149 if (ga_is_frozen(ga_state
)) {
153 HANDLE hEventTimeout
;
155 g_debug("Thawing filesystems before exiting");
157 hEventTimeout
= OpenEvent(EVENT_ALL_ACCESS
, FALSE
, EVENT_NAME_TIMEOUT
);
159 WaitForSingleObject(hEventTimeout
, 0);
160 CloseHandle(hEventTimeout
);
162 qga_vss_fsfreeze(&i
, false, NULL
, &err
);
164 g_debug("Error unfreezing filesystems prior to exiting: %s",
165 error_get_pretty(err
));
172 g_debug("received signal num %d, quitting", sig
);
174 stop_agent(ga_state
, true);
178 static gboolean
register_signal_handlers(void)
180 struct sigaction sigact
;
183 memset(&sigact
, 0, sizeof(struct sigaction
));
184 sigact
.sa_handler
= quit_handler
;
186 ret
= sigaction(SIGINT
, &sigact
, NULL
);
188 g_error("error configuring signal handler: %s", strerror(errno
));
190 ret
= sigaction(SIGTERM
, &sigact
, NULL
);
192 g_error("error configuring signal handler: %s", strerror(errno
));
195 sigact
.sa_handler
= SIG_IGN
;
196 if (sigaction(SIGPIPE
, &sigact
, NULL
) != 0) {
197 g_error("error configuring SIGPIPE signal handler: %s",
204 /* TODO: use this in place of all post-fork() fclose(std*) callers */
205 void reopen_fd_to_null(int fd
)
209 nullfd
= open("/dev/null", O_RDWR
);
222 static void usage(const char *cmd
)
225 "Usage: %s [-m <method> -p <path>] [<options>]\n"
226 "QEMU Guest Agent " QEMU_FULL_VERSION
"\n"
229 " -m, --method transport method: one of unix-listen, virtio-serial,\n"
230 " isa-serial, or vsock-listen (virtio-serial is the default)\n"
231 " -p, --path device/socket path (the default for virtio-serial is:\n"
233 " the default for isa-serial is:\n"
235 " -l, --logfile set logfile path, logs to stderr by default\n"
236 " -f, --pidfile specify pidfile (default is %s)\n"
237 #ifdef CONFIG_FSFREEZE
238 " -F, --fsfreeze-hook\n"
239 " enable fsfreeze hook. Accepts an optional argument that\n"
240 " specifies script to run on freeze/thaw. Script will be\n"
241 " called with 'freeze'/'thaw' arguments accordingly.\n"
243 " If using -F with an argument, do not follow -F with a\n"
245 " (for example: -F/var/run/fsfreezehook.sh)\n"
247 " -t, --statedir specify dir to store state information (absolute paths\n"
248 " only, default is %s)\n"
249 " -v, --verbose log extra debugging information\n"
250 " -V, --version print version information and exit\n"
251 " -d, --daemonize become a daemon\n"
253 " -s, --service service commands: install, uninstall, vss-install, vss-uninstall\n"
255 " -b, --blacklist comma-separated list of RPCs to disable (no spaces, \"?\"\n"
256 " to list available RPCs)\n"
257 " -D, --dump-conf dump a qemu-ga config file based on current config\n"
258 " options / command-line parameters to stdout\n"
259 " -r, --retry-path attempt re-opening path if it's unavailable or closed\n"
260 " due to an error which may be recoverable in the future\n"
261 " (virtio-serial driver re-install, serial device hot\n"
262 " plug/unplug, etc.)\n"
263 " -h, --help display this help and exit\n"
265 QEMU_HELP_BOTTOM
"\n"
266 , cmd
, QGA_VIRTIO_PATH_DEFAULT
, QGA_SERIAL_PATH_DEFAULT
,
267 dfl_pathnames
.pidfile
,
268 #ifdef CONFIG_FSFREEZE
269 QGA_FSFREEZE_HOOK_DEFAULT
,
271 dfl_pathnames
.state_dir
);
274 static const char *ga_log_level_str(GLogLevelFlags level
)
276 switch (level
& G_LOG_LEVEL_MASK
) {
277 case G_LOG_LEVEL_ERROR
:
279 case G_LOG_LEVEL_CRITICAL
:
281 case G_LOG_LEVEL_WARNING
:
283 case G_LOG_LEVEL_MESSAGE
:
285 case G_LOG_LEVEL_INFO
:
287 case G_LOG_LEVEL_DEBUG
:
294 bool ga_logging_enabled(GAState
*s
)
296 return s
->logging_enabled
;
299 void ga_disable_logging(GAState
*s
)
301 s
->logging_enabled
= false;
304 void ga_enable_logging(GAState
*s
)
306 s
->logging_enabled
= true;
309 static void ga_log(const gchar
*domain
, GLogLevelFlags level
,
310 const gchar
*msg
, gpointer opaque
)
314 const char *level_str
= ga_log_level_str(level
);
316 if (!ga_logging_enabled(s
)) {
320 level
&= G_LOG_LEVEL_MASK
;
322 if (g_strcmp0(domain
, "syslog") == 0) {
323 syslog(LOG_INFO
, "%s: %s", level_str
, msg
);
324 } else if (level
& s
->log_level
) {
326 if (level
& s
->log_level
) {
328 g_get_current_time(&time
);
330 "%lu.%lu: %s: %s\n", time
.tv_sec
, time
.tv_usec
, level_str
, msg
);
335 void ga_set_response_delimited(GAState
*s
)
337 s
->delimit_response
= true;
340 static FILE *ga_open_logfile(const char *logfile
)
344 f
= fopen(logfile
, "a");
349 qemu_set_cloexec(fileno(f
));
353 static gint
ga_strcmp(gconstpointer str1
, gconstpointer str2
)
355 return strcmp(str1
, str2
);
358 /* disable commands that aren't safe for fsfreeze */
359 static void ga_disable_non_whitelisted(QmpCommand
*cmd
, void *opaque
)
361 bool whitelisted
= false;
363 const char *name
= qmp_command_name(cmd
);
365 while (ga_freeze_whitelist
[i
] != NULL
) {
366 if (strcmp(name
, ga_freeze_whitelist
[i
]) == 0) {
372 g_debug("disabling command: %s", name
);
373 qmp_disable_command(&ga_commands
, name
);
377 /* [re-]enable all commands, except those explicitly blacklisted by user */
378 static void ga_enable_non_blacklisted(QmpCommand
*cmd
, void *opaque
)
380 GList
*blacklist
= opaque
;
381 const char *name
= qmp_command_name(cmd
);
383 if (g_list_find_custom(blacklist
, name
, ga_strcmp
) == NULL
&&
384 !qmp_command_is_enabled(cmd
)) {
385 g_debug("enabling command: %s", name
);
386 qmp_enable_command(&ga_commands
, name
);
390 static bool ga_create_file(const char *path
)
392 int fd
= open(path
, O_CREAT
| O_WRONLY
, S_IWUSR
| S_IRUSR
);
394 g_warning("unable to open/create file %s: %s", path
, strerror(errno
));
401 static bool ga_delete_file(const char *path
)
403 int ret
= unlink(path
);
405 g_warning("unable to delete file: %s: %s", path
, strerror(errno
));
412 bool ga_is_frozen(GAState
*s
)
417 void ga_set_frozen(GAState
*s
)
419 if (ga_is_frozen(s
)) {
422 /* disable all non-whitelisted (for frozen state) commands */
423 qmp_for_each_command(&ga_commands
, ga_disable_non_whitelisted
, NULL
);
424 g_warning("disabling logging due to filesystem freeze");
425 ga_disable_logging(s
);
427 if (!ga_create_file(s
->state_filepath_isfrozen
)) {
428 g_warning("unable to create %s, fsfreeze may not function properly",
429 s
->state_filepath_isfrozen
);
433 void ga_unset_frozen(GAState
*s
)
435 if (!ga_is_frozen(s
)) {
439 /* if we delayed creation/opening of pid/log files due to being
440 * in a frozen state at start up, do it now
442 if (s
->deferred_options
.log_filepath
) {
443 s
->log_file
= ga_open_logfile(s
->deferred_options
.log_filepath
);
445 s
->log_file
= stderr
;
447 s
->deferred_options
.log_filepath
= NULL
;
449 ga_enable_logging(s
);
450 g_warning("logging re-enabled due to filesystem unfreeze");
451 if (s
->deferred_options
.pid_filepath
) {
454 if (!qemu_write_pidfile(s
->deferred_options
.pid_filepath
, &err
)) {
455 g_warning("%s", error_get_pretty(err
));
458 s
->deferred_options
.pid_filepath
= NULL
;
461 /* enable all disabled, non-blacklisted commands */
462 qmp_for_each_command(&ga_commands
, ga_enable_non_blacklisted
, s
->blacklist
);
464 if (!ga_delete_file(s
->state_filepath_isfrozen
)) {
465 g_warning("unable to delete %s, fsfreeze may not function properly",
466 s
->state_filepath_isfrozen
);
470 #ifdef CONFIG_FSFREEZE
471 const char *ga_fsfreeze_hook(GAState
*s
)
473 return s
->fsfreeze_hook
;
477 static void become_daemon(const char *pidfile
)
493 if (!qemu_write_pidfile(pidfile
, &err
)) {
494 g_critical("%s", error_get_pretty(err
));
500 umask(S_IRWXG
| S_IRWXO
);
505 if ((chdir("/")) < 0) {
509 reopen_fd_to_null(STDIN_FILENO
);
510 reopen_fd_to_null(STDOUT_FILENO
);
511 reopen_fd_to_null(STDERR_FILENO
);
518 g_critical("failed to daemonize");
523 static int send_response(GAState
*s
, QDict
*payload
)
526 QString
*payload_qstr
, *response_qstr
;
529 g_assert(payload
&& s
->channel
);
531 payload_qstr
= qobject_to_json(QOBJECT(payload
));
536 if (s
->delimit_response
) {
537 s
->delimit_response
= false;
538 response_qstr
= qstring_new();
539 qstring_append_chr(response_qstr
, QGA_SENTINEL_BYTE
);
540 qstring_append(response_qstr
, qstring_get_str(payload_qstr
));
541 qobject_unref(payload_qstr
);
543 response_qstr
= payload_qstr
;
546 qstring_append_chr(response_qstr
, '\n');
547 buf
= qstring_get_str(response_qstr
);
548 status
= ga_channel_write_all(s
->channel
, buf
, strlen(buf
));
549 qobject_unref(response_qstr
);
550 if (status
!= G_IO_STATUS_NORMAL
) {
557 static void process_command(GAState
*s
, QDict
*req
)
563 g_debug("processing command");
564 rsp
= qmp_dispatch(&ga_commands
, QOBJECT(req
), false);
566 ret
= send_response(s
, rsp
);
568 g_warning("error sending response: %s", strerror(-ret
));
574 /* handle requests/control events coming in over the channel */
575 static void process_event(void *opaque
, QObject
*obj
, Error
*err
)
581 g_debug("process_event: called");
582 assert(!obj
!= !err
);
586 req
= qobject_to(QDict
, obj
);
588 error_setg(&err
, "Input must be a JSON object");
591 if (!qdict_haskey(req
, "execute")) {
592 g_warning("unrecognized payload format");
593 error_setg(&err
, QERR_UNSUPPORTED
);
597 process_command(s
, req
);
602 g_warning("failed to parse event: %s", error_get_pretty(err
));
603 rsp
= qmp_error_response(err
);
604 ret
= send_response(s
, rsp
);
606 g_warning("error sending error response: %s", strerror(-ret
));
612 /* false return signals GAChannel to close the current client connection */
613 static gboolean
channel_event_cb(GIOCondition condition
, gpointer data
)
616 gchar buf
[QGA_READ_COUNT_DEFAULT
+1];
618 GIOStatus status
= ga_channel_read(s
->channel
, buf
, QGA_READ_COUNT_DEFAULT
, &count
);
620 case G_IO_STATUS_ERROR
:
621 g_warning("error reading channel");
622 stop_agent(s
, false);
624 case G_IO_STATUS_NORMAL
:
626 g_debug("read data, count: %d, data: %s", (int)count
, buf
);
627 json_message_parser_feed(&s
->parser
, (char *)buf
, (int)count
);
629 case G_IO_STATUS_EOF
:
630 g_debug("received EOF");
635 case G_IO_STATUS_AGAIN
:
636 /* virtio causes us to spin here when no process is attached to
637 * host-side chardev. sleep a bit to mitigate this
644 g_warning("unknown channel read status, closing");
650 static gboolean
channel_init(GAState
*s
, const gchar
*method
, const gchar
*path
,
653 GAChannelMethod channel_method
;
655 if (strcmp(method
, "virtio-serial") == 0) {
656 s
->virtio
= true; /* virtio requires special handling in some cases */
657 channel_method
= GA_CHANNEL_VIRTIO_SERIAL
;
658 } else if (strcmp(method
, "isa-serial") == 0) {
659 channel_method
= GA_CHANNEL_ISA_SERIAL
;
660 } else if (strcmp(method
, "unix-listen") == 0) {
661 channel_method
= GA_CHANNEL_UNIX_LISTEN
;
662 } else if (strcmp(method
, "vsock-listen") == 0) {
663 channel_method
= GA_CHANNEL_VSOCK_LISTEN
;
665 g_critical("unsupported channel method/type: %s", method
);
669 s
->channel
= ga_channel_new(channel_method
, path
, listen_fd
,
670 channel_event_cb
, s
);
672 g_critical("failed to create guest agent channel");
680 DWORD WINAPI
service_ctrl_handler(DWORD ctrl
, DWORD type
, LPVOID data
,
683 DWORD ret
= NO_ERROR
;
684 GAService
*service
= &ga_state
->service
;
688 case SERVICE_CONTROL_STOP
:
689 case SERVICE_CONTROL_SHUTDOWN
:
690 quit_handler(SIGTERM
);
691 service
->status
.dwCurrentState
= SERVICE_STOP_PENDING
;
692 SetServiceStatus(service
->status_handle
, &service
->status
);
696 ret
= ERROR_CALL_NOT_IMPLEMENTED
;
701 VOID WINAPI
service_main(DWORD argc
, TCHAR
*argv
[])
703 GAService
*service
= &ga_state
->service
;
705 service
->status_handle
= RegisterServiceCtrlHandlerEx(QGA_SERVICE_NAME
,
706 service_ctrl_handler
, NULL
);
708 if (service
->status_handle
== 0) {
709 g_critical("Failed to register extended requests function!\n");
713 service
->status
.dwServiceType
= SERVICE_WIN32
;
714 service
->status
.dwCurrentState
= SERVICE_RUNNING
;
715 service
->status
.dwControlsAccepted
= SERVICE_ACCEPT_STOP
| SERVICE_ACCEPT_SHUTDOWN
;
716 service
->status
.dwWin32ExitCode
= NO_ERROR
;
717 service
->status
.dwServiceSpecificExitCode
= NO_ERROR
;
718 service
->status
.dwCheckPoint
= 0;
719 service
->status
.dwWaitHint
= 0;
720 SetServiceStatus(service
->status_handle
, &service
->status
);
724 service
->status
.dwCurrentState
= SERVICE_STOPPED
;
725 SetServiceStatus(service
->status_handle
, &service
->status
);
729 static void set_persistent_state_defaults(GAPersistentState
*pstate
)
732 pstate
->fd_counter
= QGA_PSTATE_DEFAULT_FD_COUNTER
;
735 static void persistent_state_from_keyfile(GAPersistentState
*pstate
,
740 /* if any fields are missing, either because the file was tampered with
741 * by agents of chaos, or because the field wasn't present at the time the
742 * file was created, the best we can ever do is start over with the default
743 * values. so load them now, and ignore any errors in accessing key-value
746 set_persistent_state_defaults(pstate
);
748 if (g_key_file_has_key(keyfile
, "global", "fd_counter", NULL
)) {
750 g_key_file_get_integer(keyfile
, "global", "fd_counter", NULL
);
754 static void persistent_state_to_keyfile(const GAPersistentState
*pstate
,
760 g_key_file_set_integer(keyfile
, "global", "fd_counter", pstate
->fd_counter
);
763 static gboolean
write_persistent_state(const GAPersistentState
*pstate
,
766 GKeyFile
*keyfile
= g_key_file_new();
774 persistent_state_to_keyfile(pstate
, keyfile
);
775 data
= g_key_file_to_data(keyfile
, &data_len
, &gerr
);
777 g_critical("failed to convert persistent state to string: %s",
783 g_file_set_contents(path
, data
, data_len
, &gerr
);
785 g_critical("failed to write persistent state to %s: %s",
786 path
, gerr
->message
);
796 g_key_file_free(keyfile
);
802 static gboolean
read_persistent_state(GAPersistentState
*pstate
,
803 const gchar
*path
, gboolean frozen
)
805 GKeyFile
*keyfile
= NULL
;
812 if (stat(path
, &st
) == -1) {
813 /* it's okay if state file doesn't exist, but any other error
814 * indicates a permissions issue or some other misconfiguration
815 * that we likely won't be able to recover from.
817 if (errno
!= ENOENT
) {
818 g_critical("unable to access state file at path %s: %s",
819 path
, strerror(errno
));
824 /* file doesn't exist. initialize state to default values and
825 * attempt to save now. (we could wait till later when we have
826 * modified state we need to commit, but if there's a problem,
827 * such as a missing parent directory, we want to catch it now)
829 * there is a potential scenario where someone either managed to
830 * update the agent from a version that didn't use a key store
831 * while qemu-ga thought the filesystem was frozen, or
832 * deleted the key store prior to issuing a fsfreeze, prior
833 * to restarting the agent. in this case we go ahead and defer
834 * initial creation till we actually have modified state to
835 * write, otherwise fail to recover from freeze.
837 set_persistent_state_defaults(pstate
);
839 ret
= write_persistent_state(pstate
, path
);
841 g_critical("unable to create state file at path %s", path
);
850 keyfile
= g_key_file_new();
851 g_key_file_load_from_file(keyfile
, path
, 0, &gerr
);
853 g_critical("error loading persistent state from path: %s, %s",
854 path
, gerr
->message
);
859 persistent_state_from_keyfile(pstate
, keyfile
);
863 g_key_file_free(keyfile
);
872 int64_t ga_get_fd_handle(GAState
*s
, Error
**errp
)
876 g_assert(s
->pstate_filepath
);
877 /* we blacklist commands and avoid operations that potentially require
878 * writing to disk when we're in a frozen state. this includes opening
879 * new files, so we should never get here in that situation
881 g_assert(!ga_is_frozen(s
));
883 handle
= s
->pstate
.fd_counter
++;
885 /* This should never happen on a reasonable timeframe, as guest-file-open
886 * would have to be issued 2^63 times */
887 if (s
->pstate
.fd_counter
== INT64_MAX
) {
891 if (!write_persistent_state(&s
->pstate
, s
->pstate_filepath
)) {
892 error_setg(errp
, "failed to commit persistent state to disk");
899 static void ga_print_cmd(QmpCommand
*cmd
, void *opaque
)
901 printf("%s\n", qmp_command_name(cmd
));
904 static GList
*split_list(const gchar
*str
, const gchar
*delim
)
910 strv
= g_strsplit(str
, delim
, -1);
911 for (i
= 0; strv
[i
]; i
++) {
912 list
= g_list_prepend(list
, strv
[i
]);
924 #ifdef CONFIG_FSFREEZE
931 gchar
*bliststr
; /* blacklist may point to this string */
934 GLogLevelFlags log_level
;
939 static void config_load(GAConfig
*config
)
943 const char *conf
= g_getenv("QGA_CONF") ?: QGA_CONF_DEFAULT
;
945 /* read system config */
946 keyfile
= g_key_file_new();
947 if (!g_key_file_load_from_file(keyfile
, conf
, 0, &gerr
)) {
950 if (g_key_file_has_key(keyfile
, "general", "daemon", NULL
)) {
952 g_key_file_get_boolean(keyfile
, "general", "daemon", &gerr
);
954 if (g_key_file_has_key(keyfile
, "general", "method", NULL
)) {
956 g_key_file_get_string(keyfile
, "general", "method", &gerr
);
958 if (g_key_file_has_key(keyfile
, "general", "path", NULL
)) {
959 config
->channel_path
=
960 g_key_file_get_string(keyfile
, "general", "path", &gerr
);
962 if (g_key_file_has_key(keyfile
, "general", "logfile", NULL
)) {
963 config
->log_filepath
=
964 g_key_file_get_string(keyfile
, "general", "logfile", &gerr
);
966 if (g_key_file_has_key(keyfile
, "general", "pidfile", NULL
)) {
967 config
->pid_filepath
=
968 g_key_file_get_string(keyfile
, "general", "pidfile", &gerr
);
970 #ifdef CONFIG_FSFREEZE
971 if (g_key_file_has_key(keyfile
, "general", "fsfreeze-hook", NULL
)) {
972 config
->fsfreeze_hook
=
973 g_key_file_get_string(keyfile
,
974 "general", "fsfreeze-hook", &gerr
);
977 if (g_key_file_has_key(keyfile
, "general", "statedir", NULL
)) {
979 g_key_file_get_string(keyfile
, "general", "statedir", &gerr
);
981 if (g_key_file_has_key(keyfile
, "general", "verbose", NULL
) &&
982 g_key_file_get_boolean(keyfile
, "general", "verbose", &gerr
)) {
983 /* enable all log levels */
984 config
->log_level
= G_LOG_LEVEL_MASK
;
986 if (g_key_file_has_key(keyfile
, "general", "retry-path", NULL
)) {
988 g_key_file_get_boolean(keyfile
, "general", "retry-path", &gerr
);
990 if (g_key_file_has_key(keyfile
, "general", "blacklist", NULL
)) {
992 g_key_file_get_string(keyfile
, "general", "blacklist", &gerr
);
993 config
->blacklist
= g_list_concat(config
->blacklist
,
994 split_list(config
->bliststr
, ","));
998 g_key_file_free(keyfile
);
1000 !(gerr
->domain
== G_FILE_ERROR
&& gerr
->code
== G_FILE_ERROR_NOENT
)) {
1001 g_critical("error loading configuration from path: %s, %s",
1002 QGA_CONF_DEFAULT
, gerr
->message
);
1005 g_clear_error(&gerr
);
1008 static gchar
*list_join(GList
*list
, const gchar separator
)
1010 GString
*str
= g_string_new("");
1013 str
= g_string_append(str
, (gchar
*)list
->data
);
1014 list
= g_list_next(list
);
1016 str
= g_string_append_c(str
, separator
);
1020 return g_string_free(str
, FALSE
);
1023 static void config_dump(GAConfig
*config
)
1025 GError
*error
= NULL
;
1029 keyfile
= g_key_file_new();
1032 g_key_file_set_boolean(keyfile
, "general", "daemon", config
->daemonize
);
1033 g_key_file_set_string(keyfile
, "general", "method", config
->method
);
1034 if (config
->channel_path
) {
1035 g_key_file_set_string(keyfile
, "general", "path", config
->channel_path
);
1037 if (config
->log_filepath
) {
1038 g_key_file_set_string(keyfile
, "general", "logfile",
1039 config
->log_filepath
);
1041 g_key_file_set_string(keyfile
, "general", "pidfile", config
->pid_filepath
);
1042 #ifdef CONFIG_FSFREEZE
1043 if (config
->fsfreeze_hook
) {
1044 g_key_file_set_string(keyfile
, "general", "fsfreeze-hook",
1045 config
->fsfreeze_hook
);
1048 g_key_file_set_string(keyfile
, "general", "statedir", config
->state_dir
);
1049 g_key_file_set_boolean(keyfile
, "general", "verbose",
1050 config
->log_level
== G_LOG_LEVEL_MASK
);
1051 g_key_file_set_boolean(keyfile
, "general", "retry-path",
1052 config
->retry_path
);
1053 tmp
= list_join(config
->blacklist
, ',');
1054 g_key_file_set_string(keyfile
, "general", "blacklist", tmp
);
1057 tmp
= g_key_file_to_data(keyfile
, NULL
, &error
);
1059 g_critical("Failed to dump keyfile: %s", error
->message
);
1060 g_clear_error(&error
);
1066 g_key_file_free(keyfile
);
1069 static void config_parse(GAConfig
*config
, int argc
, char **argv
)
1071 const char *sopt
= "hVvdm:p:l:f:F::b:s:t:Dr";
1072 int opt_ind
= 0, ch
;
1073 const struct option lopt
[] = {
1074 { "help", 0, NULL
, 'h' },
1075 { "version", 0, NULL
, 'V' },
1076 { "dump-conf", 0, NULL
, 'D' },
1077 { "logfile", 1, NULL
, 'l' },
1078 { "pidfile", 1, NULL
, 'f' },
1079 #ifdef CONFIG_FSFREEZE
1080 { "fsfreeze-hook", 2, NULL
, 'F' },
1082 { "verbose", 0, NULL
, 'v' },
1083 { "method", 1, NULL
, 'm' },
1084 { "path", 1, NULL
, 'p' },
1085 { "daemonize", 0, NULL
, 'd' },
1086 { "blacklist", 1, NULL
, 'b' },
1088 { "service", 1, NULL
, 's' },
1090 { "statedir", 1, NULL
, 't' },
1091 { "retry-path", 0, NULL
, 'r' },
1092 { NULL
, 0, NULL
, 0 }
1095 while ((ch
= getopt_long(argc
, argv
, sopt
, lopt
, &opt_ind
)) != -1) {
1098 g_free(config
->method
);
1099 config
->method
= g_strdup(optarg
);
1102 g_free(config
->channel_path
);
1103 config
->channel_path
= g_strdup(optarg
);
1106 g_free(config
->log_filepath
);
1107 config
->log_filepath
= g_strdup(optarg
);
1110 g_free(config
->pid_filepath
);
1111 config
->pid_filepath
= g_strdup(optarg
);
1113 #ifdef CONFIG_FSFREEZE
1115 g_free(config
->fsfreeze_hook
);
1116 config
->fsfreeze_hook
= g_strdup(optarg
?: QGA_FSFREEZE_HOOK_DEFAULT
);
1120 g_free(config
->state_dir
);
1121 config
->state_dir
= g_strdup(optarg
);
1124 /* enable all log levels */
1125 config
->log_level
= G_LOG_LEVEL_MASK
;
1128 printf("QEMU Guest Agent %s\n", QEMU_VERSION
);
1131 config
->daemonize
= 1;
1134 config
->dumpconf
= 1;
1137 config
->retry_path
= true;
1140 if (is_help_option(optarg
)) {
1141 qmp_for_each_command(&ga_commands
, ga_print_cmd
, NULL
);
1144 config
->blacklist
= g_list_concat(config
->blacklist
,
1145 split_list(optarg
, ","));
1150 config
->service
= optarg
;
1151 if (strcmp(config
->service
, "install") == 0) {
1152 if (ga_install_vss_provider()) {
1155 if (ga_install_service(config
->channel_path
,
1156 config
->log_filepath
, config
->state_dir
)) {
1160 } else if (strcmp(config
->service
, "uninstall") == 0) {
1161 ga_uninstall_vss_provider();
1162 exit(ga_uninstall_service());
1163 } else if (strcmp(config
->service
, "vss-install") == 0) {
1164 if (ga_install_vss_provider()) {
1168 } else if (strcmp(config
->service
, "vss-uninstall") == 0) {
1169 ga_uninstall_vss_provider();
1172 printf("Unknown service command.\n");
1181 g_print("Unknown option, try '%s --help' for more information.\n",
1188 static void config_free(GAConfig
*config
)
1190 g_free(config
->method
);
1191 g_free(config
->log_filepath
);
1192 g_free(config
->pid_filepath
);
1193 g_free(config
->state_dir
);
1194 g_free(config
->channel_path
);
1195 g_free(config
->bliststr
);
1196 #ifdef CONFIG_FSFREEZE
1197 g_free(config
->fsfreeze_hook
);
1199 g_list_free_full(config
->blacklist
, g_free
);
1203 static bool check_is_frozen(GAState
*s
)
1206 /* check if a previous instance of qemu-ga exited with filesystems' state
1207 * marked as frozen. this could be a stale value (a non-qemu-ga process
1208 * or reboot may have since unfrozen them), but better to require an
1209 * uneeded unfreeze than to risk hanging on start-up
1212 if (stat(s
->state_filepath_isfrozen
, &st
) == -1) {
1213 /* it's okay if the file doesn't exist, but if we can't access for
1214 * some other reason, such as permissions, there's a configuration
1215 * that needs to be addressed. so just bail now before we get into
1216 * more trouble later
1218 if (errno
!= ENOENT
) {
1219 g_critical("unable to access state file at path %s: %s",
1220 s
->state_filepath_isfrozen
, strerror(errno
));
1221 return EXIT_FAILURE
;
1224 g_warning("previous instance appears to have exited with frozen"
1225 " filesystems. deferring logging/pidfile creation and"
1226 " disabling non-fsfreeze-safe commands until"
1227 " guest-fsfreeze-thaw is issued, or filesystems are"
1228 " manually unfrozen and the file %s is removed",
1229 s
->state_filepath_isfrozen
);
1236 static GAState
*initialize_agent(GAConfig
*config
, int socket_activation
)
1238 GAState
*s
= g_new0(GAState
, 1);
1240 g_assert(ga_state
== NULL
);
1242 s
->log_level
= config
->log_level
;
1243 s
->log_file
= stderr
;
1244 #ifdef CONFIG_FSFREEZE
1245 s
->fsfreeze_hook
= config
->fsfreeze_hook
;
1247 s
->pstate_filepath
= g_strdup_printf("%s/qga.state", config
->state_dir
);
1248 s
->state_filepath_isfrozen
= g_strdup_printf("%s/qga.state.isfrozen",
1250 s
->frozen
= check_is_frozen(s
);
1252 g_log_set_default_handler(ga_log
, s
);
1253 g_log_set_fatal_mask(NULL
, G_LOG_LEVEL_ERROR
);
1254 ga_enable_logging(s
);
1257 /* On win32 the state directory is application specific (be it the default
1258 * or a user override). We got past the command line parsing; let's create
1259 * the directory (with any intermediate directories). If we run into an
1260 * error later on, we won't try to clean up the directory, it is considered
1263 if (g_mkdir_with_parents(config
->state_dir
, S_IRWXU
) == -1) {
1264 g_critical("unable to create (an ancestor of) the state directory"
1265 " '%s': %s", config
->state_dir
, strerror(errno
));
1270 if (ga_is_frozen(s
)) {
1271 if (config
->daemonize
) {
1272 /* delay opening/locking of pidfile till filesystems are unfrozen */
1273 s
->deferred_options
.pid_filepath
= config
->pid_filepath
;
1274 become_daemon(NULL
);
1276 if (config
->log_filepath
) {
1277 /* delay opening the log file till filesystems are unfrozen */
1278 s
->deferred_options
.log_filepath
= config
->log_filepath
;
1280 ga_disable_logging(s
);
1281 qmp_for_each_command(&ga_commands
, ga_disable_non_whitelisted
, NULL
);
1283 if (config
->daemonize
) {
1284 become_daemon(config
->pid_filepath
);
1286 if (config
->log_filepath
) {
1287 FILE *log_file
= ga_open_logfile(config
->log_filepath
);
1289 g_critical("unable to open specified log file: %s",
1293 s
->log_file
= log_file
;
1297 /* load persistent state from disk */
1298 if (!read_persistent_state(&s
->pstate
,
1301 g_critical("failed to load persistent state");
1305 config
->blacklist
= ga_command_blacklist_init(config
->blacklist
);
1306 if (config
->blacklist
) {
1307 GList
*l
= config
->blacklist
;
1308 s
->blacklist
= config
->blacklist
;
1310 g_debug("disabling command: %s", (char *)l
->data
);
1311 qmp_disable_command(&ga_commands
, l
->data
);
1315 s
->command_state
= ga_command_state_new();
1316 ga_command_state_init(s
, s
->command_state
);
1317 ga_command_state_init_all(s
->command_state
);
1318 json_message_parser_init(&s
->parser
, process_event
, s
, NULL
);
1321 if (!register_signal_handlers()) {
1322 g_critical("failed to register signal handlers");
1327 s
->main_loop
= g_main_loop_new(NULL
, false);
1330 s
->socket_activation
= socket_activation
;
1335 static void cleanup_agent(GAState
*s
)
1337 if (s
->command_state
) {
1338 ga_command_state_cleanup_all(s
->command_state
);
1339 ga_command_state_free(s
->command_state
);
1340 json_message_parser_destroy(&s
->parser
);
1342 g_free(s
->pstate_filepath
);
1343 g_free(s
->state_filepath_isfrozen
);
1345 g_main_loop_unref(s
->main_loop
);
1351 static int run_agent_once(GAState
*s
)
1353 if (!channel_init(s
, s
->config
->method
, s
->config
->channel_path
,
1354 s
->socket_activation
? FIRST_SOCKET_ACTIVATION_FD
: -1)) {
1355 g_critical("failed to initialize guest agent channel");
1356 return EXIT_FAILURE
;
1359 g_main_loop_run(ga_state
->main_loop
);
1362 ga_channel_free(s
->channel
);
1365 return EXIT_SUCCESS
;
1368 static int run_agent(GAState
*s
)
1370 int ret
= EXIT_SUCCESS
;
1372 s
->force_exit
= false;
1375 ret
= run_agent_once(s
);
1376 if (s
->config
->retry_path
&& !s
->force_exit
) {
1377 g_warning("agent stopped unexpectedly, restarting...");
1378 sleep(QGA_RETRY_INTERVAL
);
1380 } while (s
->config
->retry_path
&& !s
->force_exit
);
1385 static void stop_agent(GAState
*s
, bool requested
)
1387 if (!s
->force_exit
) {
1388 s
->force_exit
= requested
;
1391 if (g_main_loop_is_running(s
->main_loop
)) {
1392 g_main_loop_quit(s
->main_loop
);
1396 int main(int argc
, char **argv
)
1398 int ret
= EXIT_SUCCESS
;
1400 GAConfig
*config
= g_new0(GAConfig
, 1);
1401 int socket_activation
;
1403 config
->log_level
= G_LOG_LEVEL_ERROR
| G_LOG_LEVEL_CRITICAL
;
1405 qga_qmp_init_marshal(&ga_commands
);
1407 init_dfl_pathnames();
1408 config_load(config
);
1409 config_parse(config
, argc
, argv
);
1411 if (config
->pid_filepath
== NULL
) {
1412 config
->pid_filepath
= g_strdup(dfl_pathnames
.pidfile
);
1415 if (config
->state_dir
== NULL
) {
1416 config
->state_dir
= g_strdup(dfl_pathnames
.state_dir
);
1419 if (config
->method
== NULL
) {
1420 config
->method
= g_strdup("virtio-serial");
1423 socket_activation
= check_socket_activation();
1424 if (socket_activation
> 1) {
1425 g_critical("qemu-ga only supports listening on one socket");
1429 if (socket_activation
) {
1430 SocketAddress
*addr
;
1432 g_free(config
->method
);
1433 g_free(config
->channel_path
);
1434 config
->method
= NULL
;
1435 config
->channel_path
= NULL
;
1437 addr
= socket_local_address(FIRST_SOCKET_ACTIVATION_FD
, NULL
);
1439 if (addr
->type
== SOCKET_ADDRESS_TYPE_UNIX
) {
1440 config
->method
= g_strdup("unix-listen");
1441 } else if (addr
->type
== SOCKET_ADDRESS_TYPE_VSOCK
) {
1442 config
->method
= g_strdup("vsock-listen");
1445 qapi_free_SocketAddress(addr
);
1448 if (!config
->method
) {
1449 g_critical("unsupported listen fd type");
1453 } else if (config
->channel_path
== NULL
) {
1454 if (strcmp(config
->method
, "virtio-serial") == 0) {
1455 /* try the default path for the virtio-serial port */
1456 config
->channel_path
= g_strdup(QGA_VIRTIO_PATH_DEFAULT
);
1457 } else if (strcmp(config
->method
, "isa-serial") == 0) {
1458 /* try the default path for the serial port - COM1 */
1459 config
->channel_path
= g_strdup(QGA_SERIAL_PATH_DEFAULT
);
1461 g_critical("must specify a path for this channel");
1467 if (config
->dumpconf
) {
1468 config_dump(config
);
1472 s
= initialize_agent(config
, socket_activation
);
1474 g_critical("error initializing guest agent");
1479 if (config
->daemonize
) {
1480 SERVICE_TABLE_ENTRY service_table
[] = {
1481 { (char *)QGA_SERVICE_NAME
, service_main
}, { NULL
, NULL
} };
1482 StartServiceCtrlDispatcher(service_table
);
1493 if (config
->daemonize
) {
1494 unlink(config
->pid_filepath
);
1497 config_free(config
);