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.
13 #include "qemu/osdep.h"
16 #include <glib/gstdio.h>
21 #include "qapi/qmp/json-streamer.h"
22 #include "qapi/qmp/json-parser.h"
23 #include "qapi/qmp/qint.h"
24 #include "qapi/qmp/qjson.h"
25 #include "qga/guest-agent-core.h"
26 #include "qemu/module.h"
27 #include "qapi/qmp/qerror.h"
28 #include "qapi/qmp/dispatch.h"
29 #include "qga/channel.h"
30 #include "qemu/bswap.h"
32 #include "qga/service-win32.h"
33 #include "qga/vss-win32.h"
38 #define CONFIG_FSFREEZE
43 #define QGA_VIRTIO_PATH_DEFAULT "/dev/virtio-ports/org.qemu.guest_agent.0"
44 #define QGA_STATE_RELATIVE_DIR "run"
45 #define QGA_SERIAL_PATH_DEFAULT "/dev/ttyS0"
47 #define QGA_VIRTIO_PATH_DEFAULT "\\\\.\\Global\\org.qemu.guest_agent.0"
48 #define QGA_STATE_RELATIVE_DIR "qemu-ga"
49 #define QGA_SERIAL_PATH_DEFAULT "COM1"
51 #ifdef CONFIG_FSFREEZE
52 #define QGA_FSFREEZE_HOOK_DEFAULT CONFIG_QEMU_CONFDIR "/fsfreeze-hook"
54 #define QGA_SENTINEL_BYTE 0xFF
55 #define QGA_CONF_DEFAULT CONFIG_QEMU_CONFDIR G_DIR_SEPARATOR_S "qemu-ga.conf"
58 const char *state_dir
;
62 typedef struct GAPersistentState
{
63 #define QGA_PSTATE_DEFAULT_FD_COUNTER 1000
68 JSONMessageParser parser
;
71 bool virtio
; /* fastpath to check for virtio to deal with poll() quirks */
72 GACommandState
*command_state
;
73 GLogLevelFlags log_level
;
79 bool delimit_response
;
82 char *state_filepath_isfrozen
;
84 const char *log_filepath
;
85 const char *pid_filepath
;
87 #ifdef CONFIG_FSFREEZE
88 const char *fsfreeze_hook
;
90 gchar
*pstate_filepath
;
91 GAPersistentState pstate
;
94 struct GAState
*ga_state
;
96 /* commands that are safe to issue while filesystems are frozen */
97 static const char *ga_freeze_whitelist
[] = {
101 "guest-sync-delimited",
102 "guest-fsfreeze-status",
103 "guest-fsfreeze-thaw",
108 DWORD WINAPI
service_ctrl_handler(DWORD ctrl
, DWORD type
, LPVOID data
,
110 VOID WINAPI
service_main(DWORD argc
, TCHAR
*argv
[]);
114 init_dfl_pathnames(void)
116 g_assert(dfl_pathnames
.state_dir
== NULL
);
117 g_assert(dfl_pathnames
.pidfile
== NULL
);
118 dfl_pathnames
.state_dir
= qemu_get_local_state_pathname(
119 QGA_STATE_RELATIVE_DIR
);
120 dfl_pathnames
.pidfile
= qemu_get_local_state_pathname(
121 QGA_STATE_RELATIVE_DIR G_DIR_SEPARATOR_S
"qemu-ga.pid");
124 static void quit_handler(int sig
)
126 /* if we're frozen, don't exit unless we're absolutely forced to,
127 * because it's basically impossible for graceful exit to complete
128 * unless all log/pid files are on unfreezable filesystems. there's
129 * also a very likely chance killing the agent before unfreezing
130 * the filesystems is a mistake (or will be viewed as one later).
132 if (ga_is_frozen(ga_state
)) {
135 g_debug("received signal num %d, quitting", sig
);
137 if (g_main_loop_is_running(ga_state
->main_loop
)) {
138 g_main_loop_quit(ga_state
->main_loop
);
143 static gboolean
register_signal_handlers(void)
145 struct sigaction sigact
;
148 memset(&sigact
, 0, sizeof(struct sigaction
));
149 sigact
.sa_handler
= quit_handler
;
151 ret
= sigaction(SIGINT
, &sigact
, NULL
);
153 g_error("error configuring signal handler: %s", strerror(errno
));
155 ret
= sigaction(SIGTERM
, &sigact
, NULL
);
157 g_error("error configuring signal handler: %s", strerror(errno
));
160 sigact
.sa_handler
= SIG_IGN
;
161 if (sigaction(SIGPIPE
, &sigact
, NULL
) != 0) {
162 g_error("error configuring SIGPIPE signal handler: %s",
169 /* TODO: use this in place of all post-fork() fclose(std*) callers */
170 void reopen_fd_to_null(int fd
)
174 nullfd
= open("/dev/null", O_RDWR
);
187 static void usage(const char *cmd
)
190 "Usage: %s [-m <method> -p <path>] [<options>]\n"
191 "QEMU Guest Agent %s\n"
193 " -m, --method transport method: one of unix-listen, virtio-serial, or\n"
194 " isa-serial (virtio-serial is the default)\n"
195 " -p, --path device/socket path (the default for virtio-serial is:\n"
197 " the default for isa-serial is:\n"
199 " -l, --logfile set logfile path, logs to stderr by default\n"
200 " -f, --pidfile specify pidfile (default is %s)\n"
201 #ifdef CONFIG_FSFREEZE
202 " -F, --fsfreeze-hook\n"
203 " enable fsfreeze hook. Accepts an optional argument that\n"
204 " specifies script to run on freeze/thaw. Script will be\n"
205 " called with 'freeze'/'thaw' arguments accordingly.\n"
207 " If using -F with an argument, do not follow -F with a\n"
209 " (for example: -F/var/run/fsfreezehook.sh)\n"
211 " -t, --statedir specify dir to store state information (absolute paths\n"
212 " only, default is %s)\n"
213 " -v, --verbose log extra debugging information\n"
214 " -V, --version print version information and exit\n"
215 " -d, --daemonize become a daemon\n"
217 " -s, --service service commands: install, uninstall, vss-install, vss-uninstall\n"
219 " -b, --blacklist comma-separated list of RPCs to disable (no spaces, \"?\"\n"
220 " to list available RPCs)\n"
221 " -D, --dump-conf dump a qemu-ga config file based on current config\n"
222 " options / command-line parameters to stdout\n"
223 " -h, --help display this help and exit\n"
225 "Report bugs to <mdroth@linux.vnet.ibm.com>\n"
226 , cmd
, QEMU_VERSION
, QGA_VIRTIO_PATH_DEFAULT
, QGA_SERIAL_PATH_DEFAULT
,
227 dfl_pathnames
.pidfile
,
228 #ifdef CONFIG_FSFREEZE
229 QGA_FSFREEZE_HOOK_DEFAULT
,
231 dfl_pathnames
.state_dir
);
234 static const char *ga_log_level_str(GLogLevelFlags level
)
236 switch (level
& G_LOG_LEVEL_MASK
) {
237 case G_LOG_LEVEL_ERROR
:
239 case G_LOG_LEVEL_CRITICAL
:
241 case G_LOG_LEVEL_WARNING
:
243 case G_LOG_LEVEL_MESSAGE
:
245 case G_LOG_LEVEL_INFO
:
247 case G_LOG_LEVEL_DEBUG
:
254 bool ga_logging_enabled(GAState
*s
)
256 return s
->logging_enabled
;
259 void ga_disable_logging(GAState
*s
)
261 s
->logging_enabled
= false;
264 void ga_enable_logging(GAState
*s
)
266 s
->logging_enabled
= true;
269 static void ga_log(const gchar
*domain
, GLogLevelFlags level
,
270 const gchar
*msg
, gpointer opaque
)
274 const char *level_str
= ga_log_level_str(level
);
276 if (!ga_logging_enabled(s
)) {
280 level
&= G_LOG_LEVEL_MASK
;
282 if (g_strcmp0(domain
, "syslog") == 0) {
283 syslog(LOG_INFO
, "%s: %s", level_str
, msg
);
284 } else if (level
& s
->log_level
) {
286 if (level
& s
->log_level
) {
288 g_get_current_time(&time
);
290 "%lu.%lu: %s: %s\n", time
.tv_sec
, time
.tv_usec
, level_str
, msg
);
295 void ga_set_response_delimited(GAState
*s
)
297 s
->delimit_response
= true;
300 static FILE *ga_open_logfile(const char *logfile
)
304 f
= fopen(logfile
, "a");
309 qemu_set_cloexec(fileno(f
));
314 static bool ga_open_pidfile(const char *pidfile
)
319 pidfd
= qemu_open(pidfile
, O_CREAT
|O_WRONLY
, S_IRUSR
|S_IWUSR
);
320 if (pidfd
== -1 || lockf(pidfd
, F_TLOCK
, 0)) {
321 g_critical("Cannot lock pid file, %s", strerror(errno
));
328 if (ftruncate(pidfd
, 0)) {
329 g_critical("Failed to truncate pid file");
332 snprintf(pidstr
, sizeof(pidstr
), "%d\n", getpid());
333 if (write(pidfd
, pidstr
, strlen(pidstr
)) != strlen(pidstr
)) {
334 g_critical("Failed to write pid file");
338 /* keep pidfile open & locked forever */
347 static bool ga_open_pidfile(const char *pidfile
)
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(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(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_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
) {
452 if (!ga_open_pidfile(s
->deferred_options
.pid_filepath
)) {
453 g_warning("failed to create/open pid file");
455 s
->deferred_options
.pid_filepath
= NULL
;
458 /* enable all disabled, non-blacklisted commands */
459 qmp_for_each_command(ga_enable_non_blacklisted
, s
->blacklist
);
461 if (!ga_delete_file(s
->state_filepath_isfrozen
)) {
462 g_warning("unable to delete %s, fsfreeze may not function properly",
463 s
->state_filepath_isfrozen
);
467 #ifdef CONFIG_FSFREEZE
468 const char *ga_fsfreeze_hook(GAState
*s
)
470 return s
->fsfreeze_hook
;
474 static void become_daemon(const char *pidfile
)
488 if (!ga_open_pidfile(pidfile
)) {
489 g_critical("failed to create pidfile");
494 umask(S_IRWXG
| S_IRWXO
);
499 if ((chdir("/")) < 0) {
503 reopen_fd_to_null(STDIN_FILENO
);
504 reopen_fd_to_null(STDOUT_FILENO
);
505 reopen_fd_to_null(STDERR_FILENO
);
512 g_critical("failed to daemonize");
517 static int send_response(GAState
*s
, QObject
*payload
)
520 QString
*payload_qstr
, *response_qstr
;
523 g_assert(payload
&& s
->channel
);
525 payload_qstr
= qobject_to_json(payload
);
530 if (s
->delimit_response
) {
531 s
->delimit_response
= false;
532 response_qstr
= qstring_new();
533 qstring_append_chr(response_qstr
, QGA_SENTINEL_BYTE
);
534 qstring_append(response_qstr
, qstring_get_str(payload_qstr
));
535 QDECREF(payload_qstr
);
537 response_qstr
= payload_qstr
;
540 qstring_append_chr(response_qstr
, '\n');
541 buf
= qstring_get_str(response_qstr
);
542 status
= ga_channel_write_all(s
->channel
, buf
, strlen(buf
));
543 QDECREF(response_qstr
);
544 if (status
!= G_IO_STATUS_NORMAL
) {
551 static void process_command(GAState
*s
, QDict
*req
)
557 g_debug("processing command");
558 rsp
= qmp_dispatch(QOBJECT(req
));
560 ret
= send_response(s
, rsp
);
562 g_warning("error sending response: %s", strerror(ret
));
568 /* handle requests/control events coming in over the channel */
569 static void process_event(JSONMessageParser
*parser
, GQueue
*tokens
)
571 GAState
*s
= container_of(parser
, GAState
, parser
);
576 g_assert(s
&& parser
);
578 g_debug("process_event: called");
579 qdict
= qobject_to_qdict(json_parser_parse_err(tokens
, NULL
, &err
));
584 g_warning("failed to parse event: unknown error");
585 error_setg(&err
, QERR_JSON_PARSING
);
587 g_warning("failed to parse event: %s", error_get_pretty(err
));
589 qdict_put_obj(qdict
, "error", qmp_build_error_object(err
));
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
934 gchar
*bliststr
; /* blacklist may point to this string */
937 GLogLevelFlags log_level
;
941 static void config_load(GAConfig
*config
)
945 const char *conf
= g_getenv("QGA_CONF") ?: QGA_CONF_DEFAULT
;
947 /* read system config */
948 keyfile
= g_key_file_new();
949 if (!g_key_file_load_from_file(keyfile
, conf
, 0, &gerr
)) {
952 if (g_key_file_has_key(keyfile
, "general", "daemon", NULL
)) {
954 g_key_file_get_boolean(keyfile
, "general", "daemon", &gerr
);
956 if (g_key_file_has_key(keyfile
, "general", "method", NULL
)) {
958 g_key_file_get_string(keyfile
, "general", "method", &gerr
);
960 if (g_key_file_has_key(keyfile
, "general", "path", NULL
)) {
961 config
->channel_path
=
962 g_key_file_get_string(keyfile
, "general", "path", &gerr
);
964 if (g_key_file_has_key(keyfile
, "general", "logfile", NULL
)) {
965 config
->log_filepath
=
966 g_key_file_get_string(keyfile
, "general", "logfile", &gerr
);
968 if (g_key_file_has_key(keyfile
, "general", "pidfile", NULL
)) {
969 config
->pid_filepath
=
970 g_key_file_get_string(keyfile
, "general", "pidfile", &gerr
);
972 #ifdef CONFIG_FSFREEZE
973 if (g_key_file_has_key(keyfile
, "general", "fsfreeze-hook", NULL
)) {
974 config
->fsfreeze_hook
=
975 g_key_file_get_string(keyfile
,
976 "general", "fsfreeze-hook", &gerr
);
979 if (g_key_file_has_key(keyfile
, "general", "statedir", NULL
)) {
981 g_key_file_get_string(keyfile
, "general", "statedir", &gerr
);
983 if (g_key_file_has_key(keyfile
, "general", "verbose", NULL
) &&
984 g_key_file_get_boolean(keyfile
, "general", "verbose", &gerr
)) {
985 /* enable all log levels */
986 config
->log_level
= G_LOG_LEVEL_MASK
;
988 if (g_key_file_has_key(keyfile
, "general", "blacklist", NULL
)) {
990 g_key_file_get_string(keyfile
, "general", "blacklist", &gerr
);
991 config
->blacklist
= g_list_concat(config
->blacklist
,
992 split_list(config
->bliststr
, ","));
996 g_key_file_free(keyfile
);
998 !(gerr
->domain
== G_FILE_ERROR
&& gerr
->code
== G_FILE_ERROR_NOENT
)) {
999 g_critical("error loading configuration from path: %s, %s",
1000 QGA_CONF_DEFAULT
, gerr
->message
);
1003 g_clear_error(&gerr
);
1006 static gchar
*list_join(GList
*list
, const gchar separator
)
1008 GString
*str
= g_string_new("");
1011 str
= g_string_append(str
, (gchar
*)list
->data
);
1012 list
= g_list_next(list
);
1014 str
= g_string_append_c(str
, separator
);
1018 return g_string_free(str
, FALSE
);
1021 static void config_dump(GAConfig
*config
)
1023 GError
*error
= NULL
;
1027 keyfile
= g_key_file_new();
1030 g_key_file_set_boolean(keyfile
, "general", "daemon", config
->daemonize
);
1031 g_key_file_set_string(keyfile
, "general", "method", config
->method
);
1032 g_key_file_set_string(keyfile
, "general", "path", config
->channel_path
);
1033 if (config
->log_filepath
) {
1034 g_key_file_set_string(keyfile
, "general", "logfile",
1035 config
->log_filepath
);
1037 g_key_file_set_string(keyfile
, "general", "pidfile", config
->pid_filepath
);
1038 #ifdef CONFIG_FSFREEZE
1039 if (config
->fsfreeze_hook
) {
1040 g_key_file_set_string(keyfile
, "general", "fsfreeze-hook",
1041 config
->fsfreeze_hook
);
1044 g_key_file_set_string(keyfile
, "general", "statedir", config
->state_dir
);
1045 g_key_file_set_boolean(keyfile
, "general", "verbose",
1046 config
->log_level
== G_LOG_LEVEL_MASK
);
1047 tmp
= list_join(config
->blacklist
, ',');
1048 g_key_file_set_string(keyfile
, "general", "blacklist", tmp
);
1051 tmp
= g_key_file_to_data(keyfile
, NULL
, &error
);
1055 g_key_file_free(keyfile
);
1058 static void config_parse(GAConfig
*config
, int argc
, char **argv
)
1060 const char *sopt
= "hVvdm:p:l:f:F::b:s:t:D";
1061 int opt_ind
= 0, ch
;
1062 const struct option lopt
[] = {
1063 { "help", 0, NULL
, 'h' },
1064 { "version", 0, NULL
, 'V' },
1065 { "dump-conf", 0, NULL
, 'D' },
1066 { "logfile", 1, NULL
, 'l' },
1067 { "pidfile", 1, NULL
, 'f' },
1068 #ifdef CONFIG_FSFREEZE
1069 { "fsfreeze-hook", 2, NULL
, 'F' },
1071 { "verbose", 0, NULL
, 'v' },
1072 { "method", 1, NULL
, 'm' },
1073 { "path", 1, NULL
, 'p' },
1074 { "daemonize", 0, NULL
, 'd' },
1075 { "blacklist", 1, NULL
, 'b' },
1077 { "service", 1, NULL
, 's' },
1079 { "statedir", 1, NULL
, 't' },
1080 { NULL
, 0, NULL
, 0 }
1083 while ((ch
= getopt_long(argc
, argv
, sopt
, lopt
, &opt_ind
)) != -1) {
1086 g_free(config
->method
);
1087 config
->method
= g_strdup(optarg
);
1090 g_free(config
->channel_path
);
1091 config
->channel_path
= g_strdup(optarg
);
1094 g_free(config
->log_filepath
);
1095 config
->log_filepath
= g_strdup(optarg
);
1098 g_free(config
->pid_filepath
);
1099 config
->pid_filepath
= g_strdup(optarg
);
1101 #ifdef CONFIG_FSFREEZE
1103 g_free(config
->fsfreeze_hook
);
1104 config
->fsfreeze_hook
= g_strdup(optarg
?: QGA_FSFREEZE_HOOK_DEFAULT
);
1108 g_free(config
->state_dir
);
1109 config
->state_dir
= g_strdup(optarg
);
1112 /* enable all log levels */
1113 config
->log_level
= G_LOG_LEVEL_MASK
;
1116 printf("QEMU Guest Agent %s\n", QEMU_VERSION
);
1119 config
->daemonize
= 1;
1122 config
->dumpconf
= 1;
1125 if (is_help_option(optarg
)) {
1126 qmp_for_each_command(ga_print_cmd
, NULL
);
1129 config
->blacklist
= g_list_concat(config
->blacklist
,
1130 split_list(optarg
, ","));
1135 config
->service
= optarg
;
1136 if (strcmp(config
->service
, "install") == 0) {
1137 if (ga_install_vss_provider()) {
1140 if (ga_install_service(config
->channel_path
,
1141 config
->log_filepath
, config
->state_dir
)) {
1145 } else if (strcmp(config
->service
, "uninstall") == 0) {
1146 ga_uninstall_vss_provider();
1147 exit(ga_uninstall_service());
1148 } else if (strcmp(config
->service
, "vss-install") == 0) {
1149 if (ga_install_vss_provider()) {
1153 } else if (strcmp(config
->service
, "vss-uninstall") == 0) {
1154 ga_uninstall_vss_provider();
1157 printf("Unknown service command.\n");
1166 g_print("Unknown option, try '%s --help' for more information.\n",
1173 static void config_free(GAConfig
*config
)
1175 g_free(config
->method
);
1176 g_free(config
->log_filepath
);
1177 g_free(config
->pid_filepath
);
1178 g_free(config
->state_dir
);
1179 g_free(config
->channel_path
);
1180 g_free(config
->bliststr
);
1181 #ifdef CONFIG_FSFREEZE
1182 g_free(config
->fsfreeze_hook
);
1187 static bool check_is_frozen(GAState
*s
)
1190 /* check if a previous instance of qemu-ga exited with filesystems' state
1191 * marked as frozen. this could be a stale value (a non-qemu-ga process
1192 * or reboot may have since unfrozen them), but better to require an
1193 * uneeded unfreeze than to risk hanging on start-up
1196 if (stat(s
->state_filepath_isfrozen
, &st
) == -1) {
1197 /* it's okay if the file doesn't exist, but if we can't access for
1198 * some other reason, such as permissions, there's a configuration
1199 * that needs to be addressed. so just bail now before we get into
1200 * more trouble later
1202 if (errno
!= ENOENT
) {
1203 g_critical("unable to access state file at path %s: %s",
1204 s
->state_filepath_isfrozen
, strerror(errno
));
1205 return EXIT_FAILURE
;
1208 g_warning("previous instance appears to have exited with frozen"
1209 " filesystems. deferring logging/pidfile creation and"
1210 " disabling non-fsfreeze-safe commands until"
1211 " guest-fsfreeze-thaw is issued, or filesystems are"
1212 " manually unfrozen and the file %s is removed",
1213 s
->state_filepath_isfrozen
);
1220 static int run_agent(GAState
*s
, GAConfig
*config
)
1224 g_log_set_default_handler(ga_log
, s
);
1225 g_log_set_fatal_mask(NULL
, G_LOG_LEVEL_ERROR
);
1226 ga_enable_logging(s
);
1229 /* On win32 the state directory is application specific (be it the default
1230 * or a user override). We got past the command line parsing; let's create
1231 * the directory (with any intermediate directories). If we run into an
1232 * error later on, we won't try to clean up the directory, it is considered
1235 if (g_mkdir_with_parents(config
->state_dir
, S_IRWXU
) == -1) {
1236 g_critical("unable to create (an ancestor of) the state directory"
1237 " '%s': %s", config
->state_dir
, strerror(errno
));
1238 return EXIT_FAILURE
;
1242 if (ga_is_frozen(s
)) {
1243 if (config
->daemonize
) {
1244 /* delay opening/locking of pidfile till filesystems are unfrozen */
1245 s
->deferred_options
.pid_filepath
= config
->pid_filepath
;
1246 become_daemon(NULL
);
1248 if (config
->log_filepath
) {
1249 /* delay opening the log file till filesystems are unfrozen */
1250 s
->deferred_options
.log_filepath
= config
->log_filepath
;
1252 ga_disable_logging(s
);
1253 qmp_for_each_command(ga_disable_non_whitelisted
, NULL
);
1255 if (config
->daemonize
) {
1256 become_daemon(config
->pid_filepath
);
1258 if (config
->log_filepath
) {
1259 FILE *log_file
= ga_open_logfile(config
->log_filepath
);
1261 g_critical("unable to open specified log file: %s",
1263 return EXIT_FAILURE
;
1265 s
->log_file
= log_file
;
1269 /* load persistent state from disk */
1270 if (!read_persistent_state(&s
->pstate
,
1273 g_critical("failed to load persistent state");
1274 return EXIT_FAILURE
;
1277 config
->blacklist
= ga_command_blacklist_init(config
->blacklist
);
1278 if (config
->blacklist
) {
1279 GList
*l
= config
->blacklist
;
1280 s
->blacklist
= config
->blacklist
;
1282 g_debug("disabling command: %s", (char *)l
->data
);
1283 qmp_disable_command(l
->data
);
1287 s
->command_state
= ga_command_state_new();
1288 ga_command_state_init(s
, s
->command_state
);
1289 ga_command_state_init_all(s
->command_state
);
1290 json_message_parser_init(&s
->parser
, process_event
);
1293 if (!register_signal_handlers()) {
1294 g_critical("failed to register signal handlers");
1295 return EXIT_FAILURE
;
1299 s
->main_loop
= g_main_loop_new(NULL
, false);
1300 if (!channel_init(ga_state
, config
->method
, config
->channel_path
)) {
1301 g_critical("failed to initialize guest agent channel");
1302 return EXIT_FAILURE
;
1305 g_main_loop_run(ga_state
->main_loop
);
1307 if (config
->daemonize
) {
1308 SERVICE_TABLE_ENTRY service_table
[] = {
1309 { (char *)QGA_SERVICE_NAME
, service_main
}, { NULL
, NULL
} };
1310 StartServiceCtrlDispatcher(service_table
);
1312 g_main_loop_run(ga_state
->main_loop
);
1316 return EXIT_SUCCESS
;
1319 static void free_blacklist_entry(gpointer entry
, gpointer unused
)
1324 int main(int argc
, char **argv
)
1326 int ret
= EXIT_SUCCESS
;
1327 GAState
*s
= g_new0(GAState
, 1);
1328 GAConfig
*config
= g_new0(GAConfig
, 1);
1330 config
->log_level
= G_LOG_LEVEL_ERROR
| G_LOG_LEVEL_CRITICAL
;
1332 module_call_init(MODULE_INIT_QAPI
);
1334 init_dfl_pathnames();
1335 config_load(config
);
1336 config_parse(config
, argc
, argv
);
1338 if (config
->pid_filepath
== NULL
) {
1339 config
->pid_filepath
= g_strdup(dfl_pathnames
.pidfile
);
1342 if (config
->state_dir
== NULL
) {
1343 config
->state_dir
= g_strdup(dfl_pathnames
.state_dir
);
1346 if (config
->method
== NULL
) {
1347 config
->method
= g_strdup("virtio-serial");
1350 if (config
->channel_path
== NULL
) {
1351 if (strcmp(config
->method
, "virtio-serial") == 0) {
1352 /* try the default path for the virtio-serial port */
1353 config
->channel_path
= g_strdup(QGA_VIRTIO_PATH_DEFAULT
);
1354 } else if (strcmp(config
->method
, "isa-serial") == 0) {
1355 /* try the default path for the serial port - COM1 */
1356 config
->channel_path
= g_strdup(QGA_SERIAL_PATH_DEFAULT
);
1358 g_critical("must specify a path for this channel");
1364 s
->log_level
= config
->log_level
;
1365 s
->log_file
= stderr
;
1366 #ifdef CONFIG_FSFREEZE
1367 s
->fsfreeze_hook
= config
->fsfreeze_hook
;
1369 s
->pstate_filepath
= g_strdup_printf("%s/qga.state", config
->state_dir
);
1370 s
->state_filepath_isfrozen
= g_strdup_printf("%s/qga.state.isfrozen",
1372 s
->frozen
= check_is_frozen(s
);
1374 if (config
->dumpconf
) {
1375 config_dump(config
);
1379 ret
= run_agent(s
, config
);
1382 if (s
->command_state
) {
1383 ga_command_state_cleanup_all(s
->command_state
);
1386 ga_channel_free(s
->channel
);
1388 g_list_foreach(config
->blacklist
, free_blacklist_entry
, NULL
);
1389 g_free(s
->pstate_filepath
);
1390 g_free(s
->state_filepath_isfrozen
);
1392 if (config
->daemonize
) {
1393 unlink(config
->pid_filepath
);
1396 config_free(config
);