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 "qemu/help-texts.h"
22 #include "qapi/qmp/json-parser.h"
23 #include "qapi/qmp/qdict.h"
24 #include "qapi/qmp/qjson.h"
25 #include "guest-agent-core.h"
26 #include "qga-qapi-init-commands.h"
27 #include "qapi/qmp/qerror.h"
28 #include "qapi/error.h"
30 #include "qemu/cutils.h"
31 #include "qemu/help_option.h"
32 #include "qemu/sockets.h"
33 #include "qemu/systemd.h"
34 #include "qemu-version.h"
37 #include "qga/service-win32.h"
38 #include "qga/vss-win32.h"
40 #include "commands-common.h"
44 #define QGA_VIRTIO_PATH_DEFAULT "/dev/vtcon/org.qemu.guest_agent.0"
45 #else /* __FreeBSD__ */
46 #define QGA_VIRTIO_PATH_DEFAULT "/dev/virtio-ports/org.qemu.guest_agent.0"
47 #endif /* __FreeBSD__ */
48 #define QGA_SERIAL_PATH_DEFAULT "/dev/ttyS0"
49 #define QGA_STATE_RELATIVE_DIR "run"
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
59 #define QGA_CONF_DEFAULT CONFIG_QEMU_CONFDIR G_DIR_SEPARATOR_S "qemu-ga.conf"
60 #define QGA_RETRY_INTERVAL 5
63 const char *state_dir
;
67 typedef struct GAPersistentState
{
68 #define QGA_PSTATE_DEFAULT_FD_COUNTER 1000
72 typedef struct GAConfig GAConfig
;
75 JSONMessageParser parser
;
78 bool virtio
; /* fastpath to check for virtio to deal with poll() quirks */
79 GACommandState
*command_state
;
80 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_allowlist
[] = {
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 DWORD WINAPI
handle_serial_device_events(DWORD type
, LPVOID data
);
123 VOID WINAPI
service_main(DWORD argc
, TCHAR
*argv
[]);
125 static int run_agent(GAState
*s
);
126 static void stop_agent(GAState
*s
, bool requested
);
129 init_dfl_pathnames(void)
131 g_autofree
char *state
= qemu_get_local_state_dir();
133 g_assert(dfl_pathnames
.state_dir
== NULL
);
134 g_assert(dfl_pathnames
.pidfile
== NULL
);
135 dfl_pathnames
.state_dir
= g_build_filename(state
, QGA_STATE_RELATIVE_DIR
, NULL
);
136 dfl_pathnames
.pidfile
= g_build_filename(state
, QGA_STATE_RELATIVE_DIR
, "qemu-ga.pid", NULL
);
139 static void quit_handler(int sig
)
141 /* if we're frozen, don't exit unless we're absolutely forced to,
142 * because it's basically impossible for graceful exit to complete
143 * unless all log/pid files are on unfreezable filesystems. there's
144 * also a very likely chance killing the agent before unfreezing
145 * the filesystems is a mistake (or will be viewed as one later).
146 * On Windows the freeze interval is limited to 10 seconds, so
147 * we should quit, but first we should wait for the timeout, thaw
148 * the filesystem and quit.
150 if (ga_is_frozen(ga_state
)) {
154 HANDLE hEventTimeout
;
156 g_debug("Thawing filesystems before exiting");
158 hEventTimeout
= OpenEvent(EVENT_ALL_ACCESS
, FALSE
, EVENT_NAME_TIMEOUT
);
160 WaitForSingleObject(hEventTimeout
, 0);
161 CloseHandle(hEventTimeout
);
163 qga_vss_fsfreeze(&i
, false, NULL
, &err
);
165 g_debug("Error unfreezing filesystems prior to exiting: %s",
166 error_get_pretty(err
));
173 g_debug("received signal num %d, quitting", sig
);
175 stop_agent(ga_state
, true);
179 static gboolean
register_signal_handlers(void)
181 struct sigaction sigact
;
184 memset(&sigact
, 0, sizeof(struct sigaction
));
185 sigact
.sa_handler
= quit_handler
;
187 ret
= sigaction(SIGINT
, &sigact
, NULL
);
189 g_error("error configuring signal handler: %s", strerror(errno
));
191 ret
= sigaction(SIGTERM
, &sigact
, NULL
);
193 g_error("error configuring signal handler: %s", strerror(errno
));
196 sigact
.sa_handler
= SIG_IGN
;
197 if (sigaction(SIGPIPE
, &sigact
, NULL
) != 0) {
198 g_error("error configuring SIGPIPE signal handler: %s",
205 /* TODO: use this in place of all post-fork() fclose(std*) callers */
206 void reopen_fd_to_null(int fd
)
210 nullfd
= open("/dev/null", O_RDWR
);
223 static void usage(const char *cmd
)
225 #ifdef CONFIG_FSFREEZE
226 g_autofree
char *fsfreeze_hook
= get_relocated_path(QGA_FSFREEZE_HOOK_DEFAULT
);
230 "Usage: %s [-m <method> -p <path>] [<options>]\n"
231 "QEMU Guest Agent " QEMU_FULL_VERSION
"\n"
234 " -m, --method transport method: one of unix-listen, virtio-serial,\n"
235 " isa-serial, or vsock-listen (virtio-serial is the default)\n"
236 " -p, --path device/socket path (the default for virtio-serial is:\n"
238 " the default for isa-serial is:\n"
240 " Socket addresses for vsock-listen are written as\n"
242 " -l, --logfile set logfile path, logs to stderr by default\n"
243 " -f, --pidfile specify pidfile (default is %s)\n"
244 #ifdef CONFIG_FSFREEZE
245 " -F, --fsfreeze-hook\n"
246 " enable fsfreeze hook. Accepts an optional argument that\n"
247 " specifies script to run on freeze/thaw. Script will be\n"
248 " called with 'freeze'/'thaw' arguments accordingly.\n"
250 " If using -F with an argument, do not follow -F with a\n"
252 " (for example: -F/var/run/fsfreezehook.sh)\n"
254 " -t, --statedir specify dir to store state information (absolute paths\n"
255 " only, default is %s)\n"
256 " -v, --verbose log extra debugging information\n"
257 " -V, --version print version information and exit\n"
258 " -d, --daemonize become a daemon\n"
260 " -s, --service service commands: install, uninstall, vss-install, vss-uninstall\n"
262 " -b, --block-rpcs comma-separated list of RPCs to disable (no spaces,\n"
263 " use \"help\" to list available RPCs)\n"
264 " -D, --dump-conf dump a qemu-ga config file based on current config\n"
265 " options / command-line parameters to stdout\n"
266 " -r, --retry-path attempt re-opening path if it's unavailable or closed\n"
267 " due to an error which may be recoverable in the future\n"
268 " (virtio-serial driver re-install, serial device hot\n"
269 " plug/unplug, etc.)\n"
270 " -h, --help display this help and exit\n"
272 QEMU_HELP_BOTTOM
"\n"
273 , cmd
, QGA_VIRTIO_PATH_DEFAULT
, QGA_SERIAL_PATH_DEFAULT
,
274 dfl_pathnames
.pidfile
,
275 #ifdef CONFIG_FSFREEZE
278 dfl_pathnames
.state_dir
);
281 static const char *ga_log_level_str(GLogLevelFlags level
)
283 switch (level
& G_LOG_LEVEL_MASK
) {
284 case G_LOG_LEVEL_ERROR
:
286 case G_LOG_LEVEL_CRITICAL
:
288 case G_LOG_LEVEL_WARNING
:
290 case G_LOG_LEVEL_MESSAGE
:
292 case G_LOG_LEVEL_INFO
:
294 case G_LOG_LEVEL_DEBUG
:
301 bool ga_logging_enabled(GAState
*s
)
303 return s
->logging_enabled
;
306 void ga_disable_logging(GAState
*s
)
308 s
->logging_enabled
= false;
311 void ga_enable_logging(GAState
*s
)
313 s
->logging_enabled
= true;
316 static void ga_log(const gchar
*domain
, GLogLevelFlags level
,
317 const gchar
*msg
, gpointer opaque
)
320 const char *level_str
= ga_log_level_str(level
);
322 if (!ga_logging_enabled(s
)) {
326 level
&= G_LOG_LEVEL_MASK
;
328 if (g_strcmp0(domain
, "syslog") == 0) {
329 syslog(LOG_INFO
, "%s: %s", level_str
, msg
);
330 } else if (level
& s
->log_level
) {
332 if (level
& s
->log_level
) {
334 g_autoptr(GDateTime
) now
= g_date_time_new_now_utc();
335 g_autofree
char *nowstr
= g_date_time_format(now
, "%s.%f");
336 fprintf(s
->log_file
, "%s: %s: %s\n", nowstr
, level_str
, msg
);
341 void ga_set_response_delimited(GAState
*s
)
343 s
->delimit_response
= true;
346 static FILE *ga_open_logfile(const char *logfile
)
350 f
= fopen(logfile
, "a");
355 qemu_set_cloexec(fileno(f
));
359 static gint
ga_strcmp(gconstpointer str1
, gconstpointer str2
)
361 return strcmp(str1
, str2
);
364 /* disable commands that aren't safe for fsfreeze */
365 static void ga_disable_not_allowed(const QmpCommand
*cmd
, void *opaque
)
367 bool allowed
= false;
369 const char *name
= qmp_command_name(cmd
);
371 while (ga_freeze_allowlist
[i
] != NULL
) {
372 if (strcmp(name
, ga_freeze_allowlist
[i
]) == 0) {
378 g_debug("disabling command: %s", name
);
379 qmp_disable_command(&ga_commands
, name
, "the agent is in frozen state");
383 /* [re-]enable all commands, except those explicitly blocked by user */
384 static void ga_enable_non_blocked(const QmpCommand
*cmd
, void *opaque
)
386 GList
*blockedrpcs
= opaque
;
387 const char *name
= qmp_command_name(cmd
);
389 if (g_list_find_custom(blockedrpcs
, name
, ga_strcmp
) == NULL
&&
390 !qmp_command_is_enabled(cmd
)) {
391 g_debug("enabling command: %s", name
);
392 qmp_enable_command(&ga_commands
, name
);
396 static bool ga_create_file(const char *path
)
398 int fd
= open(path
, O_CREAT
| O_WRONLY
, S_IWUSR
| S_IRUSR
);
400 g_warning("unable to open/create file %s: %s", path
, strerror(errno
));
407 static bool ga_delete_file(const char *path
)
409 int ret
= unlink(path
);
411 g_warning("unable to delete file: %s: %s", path
, strerror(errno
));
418 bool ga_is_frozen(GAState
*s
)
423 void ga_set_frozen(GAState
*s
)
425 if (ga_is_frozen(s
)) {
428 /* disable all forbidden (for frozen state) commands */
429 qmp_for_each_command(&ga_commands
, ga_disable_not_allowed
, NULL
);
430 g_warning("disabling logging due to filesystem freeze");
431 ga_disable_logging(s
);
433 if (!ga_create_file(s
->state_filepath_isfrozen
)) {
434 g_warning("unable to create %s, fsfreeze may not function properly",
435 s
->state_filepath_isfrozen
);
439 void ga_unset_frozen(GAState
*s
)
441 if (!ga_is_frozen(s
)) {
445 /* if we delayed creation/opening of pid/log files due to being
446 * in a frozen state at start up, do it now
448 if (s
->deferred_options
.log_filepath
) {
449 s
->log_file
= ga_open_logfile(s
->deferred_options
.log_filepath
);
451 s
->log_file
= stderr
;
453 s
->deferred_options
.log_filepath
= NULL
;
455 ga_enable_logging(s
);
456 g_warning("logging re-enabled due to filesystem unfreeze");
457 if (s
->deferred_options
.pid_filepath
) {
460 if (!qemu_write_pidfile(s
->deferred_options
.pid_filepath
, &err
)) {
461 g_warning("%s", error_get_pretty(err
));
464 s
->deferred_options
.pid_filepath
= NULL
;
467 /* enable all disabled, non-blocked commands */
468 qmp_for_each_command(&ga_commands
, ga_enable_non_blocked
, s
->blockedrpcs
);
470 if (!ga_delete_file(s
->state_filepath_isfrozen
)) {
471 g_warning("unable to delete %s, fsfreeze may not function properly",
472 s
->state_filepath_isfrozen
);
476 #ifdef CONFIG_FSFREEZE
477 const char *ga_fsfreeze_hook(GAState
*s
)
479 return s
->fsfreeze_hook
;
483 static void become_daemon(const char *pidfile
)
499 if (!qemu_write_pidfile(pidfile
, &err
)) {
500 g_critical("%s", error_get_pretty(err
));
506 umask(S_IRWXG
| S_IRWXO
);
511 if ((chdir("/")) < 0) {
515 reopen_fd_to_null(STDIN_FILENO
);
516 reopen_fd_to_null(STDOUT_FILENO
);
517 reopen_fd_to_null(STDERR_FILENO
);
524 g_critical("failed to daemonize");
529 static int send_response(GAState
*s
, const QDict
*rsp
)
534 g_assert(s
->channel
);
540 response
= qobject_to_json(QOBJECT(rsp
));
545 if (s
->delimit_response
) {
546 s
->delimit_response
= false;
547 g_string_prepend_c(response
, QGA_SENTINEL_BYTE
);
550 g_string_append_c(response
, '\n');
551 status
= ga_channel_write_all(s
->channel
, response
->str
, response
->len
);
552 g_string_free(response
, true);
553 if (status
!= G_IO_STATUS_NORMAL
) {
560 /* handle requests/control events coming in over the channel */
561 static void process_event(void *opaque
, QObject
*obj
, Error
*err
)
567 g_debug("process_event: called");
568 assert(!obj
!= !err
);
570 rsp
= qmp_error_response(err
);
574 g_debug("processing command");
575 rsp
= qmp_dispatch(&ga_commands
, obj
, false, NULL
);
578 ret
= send_response(s
, rsp
);
580 g_warning("error sending error response: %s", strerror(-ret
));
586 /* false return signals GAChannel to close the current client connection */
587 static gboolean
channel_event_cb(GIOCondition condition
, gpointer data
)
590 gchar buf
[QGA_READ_COUNT_DEFAULT
+ 1];
592 GIOStatus status
= ga_channel_read(s
->channel
, buf
, QGA_READ_COUNT_DEFAULT
, &count
);
594 case G_IO_STATUS_ERROR
:
595 g_warning("error reading channel");
596 stop_agent(s
, false);
598 case G_IO_STATUS_NORMAL
:
600 g_debug("read data, count: %d, data: %s", (int)count
, buf
);
601 json_message_parser_feed(&s
->parser
, (char *)buf
, (int)count
);
603 case G_IO_STATUS_EOF
:
604 g_debug("received EOF");
609 case G_IO_STATUS_AGAIN
:
610 /* virtio causes us to spin here when no process is attached to
611 * host-side chardev. sleep a bit to mitigate this
614 g_usleep(G_USEC_PER_SEC
/ 10);
618 g_warning("unknown channel read status, closing");
624 static gboolean
channel_init(GAState
*s
, const gchar
*method
, const gchar
*path
,
627 GAChannelMethod channel_method
;
629 if (strcmp(method
, "virtio-serial") == 0) {
630 s
->virtio
= true; /* virtio requires special handling in some cases */
631 channel_method
= GA_CHANNEL_VIRTIO_SERIAL
;
632 } else if (strcmp(method
, "isa-serial") == 0) {
633 channel_method
= GA_CHANNEL_ISA_SERIAL
;
634 } else if (strcmp(method
, "unix-listen") == 0) {
635 channel_method
= GA_CHANNEL_UNIX_LISTEN
;
636 } else if (strcmp(method
, "vsock-listen") == 0) {
637 channel_method
= GA_CHANNEL_VSOCK_LISTEN
;
639 g_critical("unsupported channel method/type: %s", method
);
643 s
->channel
= ga_channel_new(channel_method
, path
, listen_fd
,
644 channel_event_cb
, s
);
646 g_critical("failed to create guest agent channel");
654 DWORD WINAPI
handle_serial_device_events(DWORD type
, LPVOID data
)
656 DWORD ret
= NO_ERROR
;
657 PDEV_BROADCAST_HDR broadcast_header
= (PDEV_BROADCAST_HDR
)data
;
659 if (broadcast_header
->dbch_devicetype
== DBT_DEVTYP_DEVICEINTERFACE
) {
661 /* Device inserted */
662 case DBT_DEVICEARRIVAL
:
663 /* Start QEMU-ga's service */
664 if (!SetEvent(ga_state
->wakeup_event
)) {
665 ret
= GetLastError();
669 case DBT_DEVICEQUERYREMOVE
:
670 case DBT_DEVICEREMOVEPENDING
:
671 case DBT_DEVICEREMOVECOMPLETE
:
672 /* Stop QEMU-ga's service */
673 if (!ResetEvent(ga_state
->wakeup_event
)) {
674 ret
= GetLastError();
678 ret
= ERROR_CALL_NOT_IMPLEMENTED
;
684 DWORD WINAPI
service_ctrl_handler(DWORD ctrl
, DWORD type
, LPVOID data
,
687 DWORD ret
= NO_ERROR
;
688 GAService
*service
= &ga_state
->service
;
691 case SERVICE_CONTROL_STOP
:
692 case SERVICE_CONTROL_SHUTDOWN
:
693 quit_handler(SIGTERM
);
694 SetEvent(ga_state
->wakeup_event
);
695 service
->status
.dwCurrentState
= SERVICE_STOP_PENDING
;
696 SetServiceStatus(service
->status_handle
, &service
->status
);
698 case SERVICE_CONTROL_DEVICEEVENT
:
699 handle_serial_device_events(type
, data
);
703 ret
= ERROR_CALL_NOT_IMPLEMENTED
;
708 VOID WINAPI
service_main(DWORD argc
, TCHAR
*argv
[])
710 GAService
*service
= &ga_state
->service
;
712 service
->status_handle
= RegisterServiceCtrlHandlerEx(QGA_SERVICE_NAME
,
713 service_ctrl_handler
, NULL
);
715 if (service
->status_handle
== 0) {
716 g_critical("Failed to register extended requests function!\n");
720 service
->status
.dwServiceType
= SERVICE_WIN32
;
721 service
->status
.dwCurrentState
= SERVICE_RUNNING
;
722 service
->status
.dwControlsAccepted
= SERVICE_ACCEPT_STOP
| SERVICE_ACCEPT_SHUTDOWN
;
723 service
->status
.dwWin32ExitCode
= NO_ERROR
;
724 service
->status
.dwServiceSpecificExitCode
= NO_ERROR
;
725 service
->status
.dwCheckPoint
= 0;
726 service
->status
.dwWaitHint
= 0;
727 DEV_BROADCAST_DEVICEINTERFACE notification_filter
;
728 ZeroMemory(¬ification_filter
, sizeof(notification_filter
));
729 notification_filter
.dbcc_devicetype
= DBT_DEVTYP_DEVICEINTERFACE
;
730 notification_filter
.dbcc_size
= sizeof(DEV_BROADCAST_DEVICEINTERFACE
);
731 notification_filter
.dbcc_classguid
= GUID_VIOSERIAL_PORT
;
733 service
->device_notification_handle
=
734 RegisterDeviceNotification(service
->status_handle
,
735 ¬ification_filter
, DEVICE_NOTIFY_SERVICE_HANDLE
);
736 if (!service
->device_notification_handle
) {
737 g_critical("Failed to register device notification handle!\n");
740 SetServiceStatus(service
->status_handle
, &service
->status
);
744 UnregisterDeviceNotification(service
->device_notification_handle
);
745 service
->status
.dwCurrentState
= SERVICE_STOPPED
;
746 SetServiceStatus(service
->status_handle
, &service
->status
);
750 static void set_persistent_state_defaults(GAPersistentState
*pstate
)
753 pstate
->fd_counter
= QGA_PSTATE_DEFAULT_FD_COUNTER
;
756 static void persistent_state_from_keyfile(GAPersistentState
*pstate
,
761 /* if any fields are missing, either because the file was tampered with
762 * by agents of chaos, or because the field wasn't present at the time the
763 * file was created, the best we can ever do is start over with the default
764 * values. so load them now, and ignore any errors in accessing key-value
767 set_persistent_state_defaults(pstate
);
769 if (g_key_file_has_key(keyfile
, "global", "fd_counter", NULL
)) {
771 g_key_file_get_integer(keyfile
, "global", "fd_counter", NULL
);
775 static void persistent_state_to_keyfile(const GAPersistentState
*pstate
,
781 g_key_file_set_integer(keyfile
, "global", "fd_counter", pstate
->fd_counter
);
784 static gboolean
write_persistent_state(const GAPersistentState
*pstate
,
787 GKeyFile
*keyfile
= g_key_file_new();
795 persistent_state_to_keyfile(pstate
, keyfile
);
796 data
= g_key_file_to_data(keyfile
, &data_len
, &gerr
);
798 g_critical("failed to convert persistent state to string: %s",
804 g_file_set_contents(path
, data
, data_len
, &gerr
);
806 g_critical("failed to write persistent state to %s: %s",
807 path
, gerr
->message
);
817 g_key_file_free(keyfile
);
823 static gboolean
read_persistent_state(GAPersistentState
*pstate
,
824 const gchar
*path
, gboolean frozen
)
826 GKeyFile
*keyfile
= NULL
;
833 if (stat(path
, &st
) == -1) {
834 /* it's okay if state file doesn't exist, but any other error
835 * indicates a permissions issue or some other misconfiguration
836 * that we likely won't be able to recover from.
838 if (errno
!= ENOENT
) {
839 g_critical("unable to access state file at path %s: %s",
840 path
, strerror(errno
));
845 /* file doesn't exist. initialize state to default values and
846 * attempt to save now. (we could wait till later when we have
847 * modified state we need to commit, but if there's a problem,
848 * such as a missing parent directory, we want to catch it now)
850 * there is a potential scenario where someone either managed to
851 * update the agent from a version that didn't use a key store
852 * while qemu-ga thought the filesystem was frozen, or
853 * deleted the key store prior to issuing a fsfreeze, prior
854 * to restarting the agent. in this case we go ahead and defer
855 * initial creation till we actually have modified state to
856 * write, otherwise fail to recover from freeze.
858 set_persistent_state_defaults(pstate
);
860 ret
= write_persistent_state(pstate
, path
);
862 g_critical("unable to create state file at path %s", path
);
871 keyfile
= g_key_file_new();
872 g_key_file_load_from_file(keyfile
, path
, 0, &gerr
);
874 g_critical("error loading persistent state from path: %s, %s",
875 path
, gerr
->message
);
880 persistent_state_from_keyfile(pstate
, keyfile
);
884 g_key_file_free(keyfile
);
893 int64_t ga_get_fd_handle(GAState
*s
, Error
**errp
)
897 g_assert(s
->pstate_filepath
);
899 * We block commands and avoid operations that potentially require
900 * writing to disk when we're in a frozen state. this includes opening
901 * new files, so we should never get here in that situation
903 g_assert(!ga_is_frozen(s
));
905 handle
= s
->pstate
.fd_counter
++;
907 /* This should never happen on a reasonable timeframe, as guest-file-open
908 * would have to be issued 2^63 times */
909 if (s
->pstate
.fd_counter
== INT64_MAX
) {
913 if (!write_persistent_state(&s
->pstate
, s
->pstate_filepath
)) {
914 error_setg(errp
, "failed to commit persistent state to disk");
921 static void ga_print_cmd(const QmpCommand
*cmd
, void *opaque
)
923 printf("%s\n", qmp_command_name(cmd
));
926 static GList
*split_list(const gchar
*str
, const gchar
*delim
)
932 strv
= g_strsplit(str
, delim
, -1);
933 for (i
= 0; strv
[i
]; i
++) {
934 list
= g_list_prepend(list
, strv
[i
]);
946 #ifdef CONFIG_FSFREEZE
953 gchar
*bliststr
; /* blockedrpcs may point to this string */
956 GLogLevelFlags log_level
;
961 static void config_load(GAConfig
*config
)
965 g_autofree
char *conf
= g_strdup(g_getenv("QGA_CONF")) ?: get_relocated_path(QGA_CONF_DEFAULT
);
966 const gchar
*blockrpcs_key
= "block-rpcs";
968 /* read system config */
969 keyfile
= g_key_file_new();
970 if (!g_key_file_load_from_file(keyfile
, conf
, 0, &gerr
)) {
973 if (g_key_file_has_key(keyfile
, "general", "daemon", NULL
)) {
975 g_key_file_get_boolean(keyfile
, "general", "daemon", &gerr
);
977 if (g_key_file_has_key(keyfile
, "general", "method", NULL
)) {
979 g_key_file_get_string(keyfile
, "general", "method", &gerr
);
981 if (g_key_file_has_key(keyfile
, "general", "path", NULL
)) {
982 config
->channel_path
=
983 g_key_file_get_string(keyfile
, "general", "path", &gerr
);
985 if (g_key_file_has_key(keyfile
, "general", "logfile", NULL
)) {
986 config
->log_filepath
=
987 g_key_file_get_string(keyfile
, "general", "logfile", &gerr
);
989 if (g_key_file_has_key(keyfile
, "general", "pidfile", NULL
)) {
990 config
->pid_filepath
=
991 g_key_file_get_string(keyfile
, "general", "pidfile", &gerr
);
993 #ifdef CONFIG_FSFREEZE
994 if (g_key_file_has_key(keyfile
, "general", "fsfreeze-hook", NULL
)) {
995 config
->fsfreeze_hook
=
996 g_key_file_get_string(keyfile
,
997 "general", "fsfreeze-hook", &gerr
);
1000 if (g_key_file_has_key(keyfile
, "general", "statedir", NULL
)) {
1002 g_key_file_get_string(keyfile
, "general", "statedir", &gerr
);
1004 if (g_key_file_has_key(keyfile
, "general", "verbose", NULL
) &&
1005 g_key_file_get_boolean(keyfile
, "general", "verbose", &gerr
)) {
1006 /* enable all log levels */
1007 config
->log_level
= G_LOG_LEVEL_MASK
;
1009 if (g_key_file_has_key(keyfile
, "general", "retry-path", NULL
)) {
1010 config
->retry_path
=
1011 g_key_file_get_boolean(keyfile
, "general", "retry-path", &gerr
);
1014 if (g_key_file_has_key(keyfile
, "general", "blacklist", NULL
)) {
1015 g_warning("config using deprecated 'blacklist' key, should be replaced"
1016 " with the 'block-rpcs' key.");
1017 blockrpcs_key
= "blacklist";
1019 if (g_key_file_has_key(keyfile
, "general", blockrpcs_key
, NULL
)) {
1021 g_key_file_get_string(keyfile
, "general", blockrpcs_key
, &gerr
);
1022 config
->blockedrpcs
= g_list_concat(config
->blockedrpcs
,
1023 split_list(config
->bliststr
, ","));
1027 g_key_file_free(keyfile
);
1029 !(gerr
->domain
== G_FILE_ERROR
&& gerr
->code
== G_FILE_ERROR_NOENT
)) {
1030 g_critical("error loading configuration from path: %s, %s",
1031 conf
, gerr
->message
);
1034 g_clear_error(&gerr
);
1037 static gchar
*list_join(GList
*list
, const gchar separator
)
1039 GString
*str
= g_string_new("");
1042 str
= g_string_append(str
, (gchar
*)list
->data
);
1043 list
= g_list_next(list
);
1045 str
= g_string_append_c(str
, separator
);
1049 return g_string_free(str
, FALSE
);
1052 static void config_dump(GAConfig
*config
)
1054 GError
*error
= NULL
;
1058 keyfile
= g_key_file_new();
1061 g_key_file_set_boolean(keyfile
, "general", "daemon", config
->daemonize
);
1062 g_key_file_set_string(keyfile
, "general", "method", config
->method
);
1063 if (config
->channel_path
) {
1064 g_key_file_set_string(keyfile
, "general", "path", config
->channel_path
);
1066 if (config
->log_filepath
) {
1067 g_key_file_set_string(keyfile
, "general", "logfile",
1068 config
->log_filepath
);
1070 g_key_file_set_string(keyfile
, "general", "pidfile", config
->pid_filepath
);
1071 #ifdef CONFIG_FSFREEZE
1072 if (config
->fsfreeze_hook
) {
1073 g_key_file_set_string(keyfile
, "general", "fsfreeze-hook",
1074 config
->fsfreeze_hook
);
1077 g_key_file_set_string(keyfile
, "general", "statedir", config
->state_dir
);
1078 g_key_file_set_boolean(keyfile
, "general", "verbose",
1079 config
->log_level
== G_LOG_LEVEL_MASK
);
1080 g_key_file_set_boolean(keyfile
, "general", "retry-path",
1081 config
->retry_path
);
1082 tmp
= list_join(config
->blockedrpcs
, ',');
1083 g_key_file_set_string(keyfile
, "general", "block-rpcs", tmp
);
1086 tmp
= g_key_file_to_data(keyfile
, NULL
, &error
);
1088 g_critical("Failed to dump keyfile: %s", error
->message
);
1089 g_clear_error(&error
);
1095 g_key_file_free(keyfile
);
1098 static void config_parse(GAConfig
*config
, int argc
, char **argv
)
1100 const char *sopt
= "hVvdm:p:l:f:F::b:s:t:Dr";
1101 int opt_ind
= 0, ch
;
1102 const struct option lopt
[] = {
1103 { "help", 0, NULL
, 'h' },
1104 { "version", 0, NULL
, 'V' },
1105 { "dump-conf", 0, NULL
, 'D' },
1106 { "logfile", 1, NULL
, 'l' },
1107 { "pidfile", 1, NULL
, 'f' },
1108 #ifdef CONFIG_FSFREEZE
1109 { "fsfreeze-hook", 2, NULL
, 'F' },
1111 { "verbose", 0, NULL
, 'v' },
1112 { "method", 1, NULL
, 'm' },
1113 { "path", 1, NULL
, 'p' },
1114 { "daemonize", 0, NULL
, 'd' },
1115 { "block-rpcs", 1, NULL
, 'b' },
1116 { "blacklist", 1, NULL
, 'b' }, /* deprecated alias for 'block-rpcs' */
1118 { "service", 1, NULL
, 's' },
1120 { "statedir", 1, NULL
, 't' },
1121 { "retry-path", 0, NULL
, 'r' },
1122 { NULL
, 0, NULL
, 0 }
1125 while ((ch
= getopt_long(argc
, argv
, sopt
, lopt
, &opt_ind
)) != -1) {
1128 g_free(config
->method
);
1129 config
->method
= g_strdup(optarg
);
1132 g_free(config
->channel_path
);
1133 config
->channel_path
= g_strdup(optarg
);
1136 g_free(config
->log_filepath
);
1137 config
->log_filepath
= g_strdup(optarg
);
1140 g_free(config
->pid_filepath
);
1141 config
->pid_filepath
= g_strdup(optarg
);
1143 #ifdef CONFIG_FSFREEZE
1145 g_free(config
->fsfreeze_hook
);
1146 config
->fsfreeze_hook
= optarg
? g_strdup(optarg
) : get_relocated_path(QGA_FSFREEZE_HOOK_DEFAULT
);
1150 g_free(config
->state_dir
);
1151 config
->state_dir
= g_strdup(optarg
);
1154 /* enable all log levels */
1155 config
->log_level
= G_LOG_LEVEL_MASK
;
1158 printf("QEMU Guest Agent %s\n", QEMU_VERSION
);
1161 config
->daemonize
= 1;
1164 config
->dumpconf
= 1;
1167 config
->retry_path
= true;
1170 if (is_help_option(optarg
)) {
1171 qmp_for_each_command(&ga_commands
, ga_print_cmd
, NULL
);
1174 config
->blockedrpcs
= g_list_concat(config
->blockedrpcs
,
1175 split_list(optarg
, ","));
1180 config
->service
= optarg
;
1181 if (strcmp(config
->service
, "install") == 0) {
1182 if (ga_install_vss_provider()) {
1185 if (ga_install_service(config
->channel_path
,
1186 config
->log_filepath
, config
->state_dir
)) {
1190 } else if (strcmp(config
->service
, "uninstall") == 0) {
1191 ga_uninstall_vss_provider();
1192 exit(ga_uninstall_service());
1193 } else if (strcmp(config
->service
, "vss-install") == 0) {
1194 if (ga_install_vss_provider()) {
1198 } else if (strcmp(config
->service
, "vss-uninstall") == 0) {
1199 ga_uninstall_vss_provider();
1202 printf("Unknown service command.\n");
1211 g_print("Unknown option, try '%s --help' for more information.\n",
1218 static void config_free(GAConfig
*config
)
1220 g_free(config
->method
);
1221 g_free(config
->log_filepath
);
1222 g_free(config
->pid_filepath
);
1223 g_free(config
->state_dir
);
1224 g_free(config
->channel_path
);
1225 g_free(config
->bliststr
);
1226 #ifdef CONFIG_FSFREEZE
1227 g_free(config
->fsfreeze_hook
);
1229 g_list_free_full(config
->blockedrpcs
, g_free
);
1233 static bool check_is_frozen(GAState
*s
)
1236 /* check if a previous instance of qemu-ga exited with filesystems' state
1237 * marked as frozen. this could be a stale value (a non-qemu-ga process
1238 * or reboot may have since unfrozen them), but better to require an
1239 * uneeded unfreeze than to risk hanging on start-up
1242 if (stat(s
->state_filepath_isfrozen
, &st
) == -1) {
1243 /* it's okay if the file doesn't exist, but if we can't access for
1244 * some other reason, such as permissions, there's a configuration
1245 * that needs to be addressed. so just bail now before we get into
1246 * more trouble later
1248 if (errno
!= ENOENT
) {
1249 g_critical("unable to access state file at path %s: %s",
1250 s
->state_filepath_isfrozen
, strerror(errno
));
1251 return EXIT_FAILURE
;
1254 g_warning("previous instance appears to have exited with frozen"
1255 " filesystems. deferring logging/pidfile creation and"
1256 " disabling non-fsfreeze-safe commands until"
1257 " guest-fsfreeze-thaw is issued, or filesystems are"
1258 " manually unfrozen and the file %s is removed",
1259 s
->state_filepath_isfrozen
);
1266 static GAState
*initialize_agent(GAConfig
*config
, int socket_activation
)
1268 GAState
*s
= g_new0(GAState
, 1);
1270 g_assert(ga_state
== NULL
);
1272 s
->log_level
= config
->log_level
;
1273 s
->log_file
= stderr
;
1274 #ifdef CONFIG_FSFREEZE
1275 s
->fsfreeze_hook
= config
->fsfreeze_hook
;
1277 s
->pstate_filepath
= g_strdup_printf("%s/qga.state", config
->state_dir
);
1278 s
->state_filepath_isfrozen
= g_strdup_printf("%s/qga.state.isfrozen",
1280 s
->frozen
= check_is_frozen(s
);
1282 g_log_set_default_handler(ga_log
, s
);
1283 g_log_set_fatal_mask(NULL
, G_LOG_LEVEL_ERROR
);
1284 ga_enable_logging(s
);
1286 g_debug("Guest agent version %s started", QEMU_FULL_VERSION
);
1289 /* On win32 the state directory is application specific (be it the default
1290 * or a user override). We got past the command line parsing; let's create
1291 * the directory (with any intermediate directories). If we run into an
1292 * error later on, we won't try to clean up the directory, it is considered
1295 if (g_mkdir_with_parents(config
->state_dir
, S_IRWXU
) == -1) {
1296 g_critical("unable to create (an ancestor of) the state directory"
1297 " '%s': %s", config
->state_dir
, strerror(errno
));
1302 if (ga_is_frozen(s
)) {
1303 if (config
->daemonize
) {
1304 /* delay opening/locking of pidfile till filesystems are unfrozen */
1305 s
->deferred_options
.pid_filepath
= config
->pid_filepath
;
1306 become_daemon(NULL
);
1308 if (config
->log_filepath
) {
1309 /* delay opening the log file till filesystems are unfrozen */
1310 s
->deferred_options
.log_filepath
= config
->log_filepath
;
1312 ga_disable_logging(s
);
1313 qmp_for_each_command(&ga_commands
, ga_disable_not_allowed
, NULL
);
1315 if (config
->daemonize
) {
1316 become_daemon(config
->pid_filepath
);
1318 if (config
->log_filepath
) {
1319 FILE *log_file
= ga_open_logfile(config
->log_filepath
);
1321 g_critical("unable to open specified log file: %s",
1325 s
->log_file
= log_file
;
1329 /* load persistent state from disk */
1330 if (!read_persistent_state(&s
->pstate
,
1333 g_critical("failed to load persistent state");
1337 config
->blockedrpcs
= ga_command_init_blockedrpcs(config
->blockedrpcs
);
1338 if (config
->blockedrpcs
) {
1339 GList
*l
= config
->blockedrpcs
;
1340 s
->blockedrpcs
= config
->blockedrpcs
;
1342 g_debug("disabling command: %s", (char *)l
->data
);
1343 qmp_disable_command(&ga_commands
, l
->data
, NULL
);
1347 s
->command_state
= ga_command_state_new();
1348 ga_command_state_init(s
, s
->command_state
);
1349 ga_command_state_init_all(s
->command_state
);
1350 json_message_parser_init(&s
->parser
, process_event
, s
, NULL
);
1353 if (!register_signal_handlers()) {
1354 g_critical("failed to register signal handlers");
1359 s
->main_loop
= g_main_loop_new(NULL
, false);
1362 s
->socket_activation
= socket_activation
;
1365 s
->wakeup_event
= CreateEvent(NULL
, TRUE
, FALSE
, TEXT("WakeUp"));
1366 if (s
->wakeup_event
== NULL
) {
1367 g_critical("CreateEvent failed");
1376 static void cleanup_agent(GAState
*s
)
1379 CloseHandle(s
->wakeup_event
);
1381 if (s
->command_state
) {
1382 ga_command_state_cleanup_all(s
->command_state
);
1383 ga_command_state_free(s
->command_state
);
1384 json_message_parser_destroy(&s
->parser
);
1386 g_free(s
->pstate_filepath
);
1387 g_free(s
->state_filepath_isfrozen
);
1389 g_main_loop_unref(s
->main_loop
);
1395 static int run_agent_once(GAState
*s
)
1397 if (!channel_init(s
, s
->config
->method
, s
->config
->channel_path
,
1398 s
->socket_activation
? FIRST_SOCKET_ACTIVATION_FD
: -1)) {
1399 g_critical("failed to initialize guest agent channel");
1400 return EXIT_FAILURE
;
1403 g_main_loop_run(ga_state
->main_loop
);
1406 ga_channel_free(s
->channel
);
1409 return EXIT_SUCCESS
;
1412 static void wait_for_channel_availability(GAState
*s
)
1414 g_warning("waiting for channel path...");
1416 sleep(QGA_RETRY_INTERVAL
);
1420 dwWaitResult
= WaitForSingleObject(s
->wakeup_event
, INFINITE
);
1422 switch (dwWaitResult
) {
1428 g_critical("WaitForSingleObject failed");
1433 static int run_agent(GAState
*s
)
1435 int ret
= EXIT_SUCCESS
;
1437 s
->force_exit
= false;
1440 ret
= run_agent_once(s
);
1441 if (s
->config
->retry_path
&& !s
->force_exit
) {
1442 g_warning("agent stopped unexpectedly, restarting...");
1443 wait_for_channel_availability(s
);
1445 } while (s
->config
->retry_path
&& !s
->force_exit
);
1450 static void stop_agent(GAState
*s
, bool requested
)
1452 if (!s
->force_exit
) {
1453 s
->force_exit
= requested
;
1456 if (g_main_loop_is_running(s
->main_loop
)) {
1457 g_main_loop_quit(s
->main_loop
);
1461 int main(int argc
, char **argv
)
1463 int ret
= EXIT_SUCCESS
;
1465 GAConfig
*config
= g_new0(GAConfig
, 1);
1466 int socket_activation
;
1468 config
->log_level
= G_LOG_LEVEL_ERROR
| G_LOG_LEVEL_CRITICAL
;
1470 qemu_init_exec_dir(argv
[0]);
1471 qga_qmp_init_marshal(&ga_commands
);
1473 init_dfl_pathnames();
1474 config_load(config
);
1475 config_parse(config
, argc
, argv
);
1477 if (config
->pid_filepath
== NULL
) {
1478 config
->pid_filepath
= g_strdup(dfl_pathnames
.pidfile
);
1481 if (config
->state_dir
== NULL
) {
1482 config
->state_dir
= g_strdup(dfl_pathnames
.state_dir
);
1485 if (config
->method
== NULL
) {
1486 config
->method
= g_strdup("virtio-serial");
1489 socket_activation
= check_socket_activation();
1490 if (socket_activation
> 1) {
1491 g_critical("qemu-ga only supports listening on one socket");
1495 if (socket_activation
) {
1496 SocketAddress
*addr
;
1498 g_free(config
->method
);
1499 g_free(config
->channel_path
);
1500 config
->method
= NULL
;
1501 config
->channel_path
= NULL
;
1503 addr
= socket_local_address(FIRST_SOCKET_ACTIVATION_FD
, NULL
);
1505 if (addr
->type
== SOCKET_ADDRESS_TYPE_UNIX
) {
1506 config
->method
= g_strdup("unix-listen");
1507 } else if (addr
->type
== SOCKET_ADDRESS_TYPE_VSOCK
) {
1508 config
->method
= g_strdup("vsock-listen");
1511 qapi_free_SocketAddress(addr
);
1514 if (!config
->method
) {
1515 g_critical("unsupported listen fd type");
1519 } else if (config
->channel_path
== NULL
) {
1520 if (strcmp(config
->method
, "virtio-serial") == 0) {
1521 /* try the default path for the virtio-serial port */
1522 config
->channel_path
= g_strdup(QGA_VIRTIO_PATH_DEFAULT
);
1523 } else if (strcmp(config
->method
, "isa-serial") == 0) {
1524 /* try the default path for the serial port - COM1 */
1525 config
->channel_path
= g_strdup(QGA_SERIAL_PATH_DEFAULT
);
1527 g_critical("must specify a path for this channel");
1533 if (config
->dumpconf
) {
1534 config_dump(config
);
1538 s
= initialize_agent(config
, socket_activation
);
1540 g_critical("error initializing guest agent");
1545 if (config
->daemonize
) {
1546 SERVICE_TABLE_ENTRY service_table
[] = {
1547 { (char *)QGA_SERVICE_NAME
, service_main
}, { NULL
, NULL
} };
1548 StartServiceCtrlDispatcher(service_table
);
1559 if (config
->daemonize
) {
1560 unlink(config
->pid_filepath
);
1563 config_free(config
);