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"
43 #define CONFIG_FSFREEZE
49 #define QGA_VIRTIO_PATH_DEFAULT "/dev/vtcon/org.qemu.guest_agent.0"
50 #else /* __FreeBSD__ */
51 #define QGA_VIRTIO_PATH_DEFAULT "/dev/virtio-ports/org.qemu.guest_agent.0"
52 #endif /* __FreeBSD__ */
53 #define QGA_SERIAL_PATH_DEFAULT "/dev/ttyS0"
54 #define QGA_STATE_RELATIVE_DIR "run"
56 #define QGA_VIRTIO_PATH_DEFAULT "\\\\.\\Global\\org.qemu.guest_agent.0"
57 #define QGA_STATE_RELATIVE_DIR "qemu-ga"
58 #define QGA_SERIAL_PATH_DEFAULT "COM1"
60 #ifdef CONFIG_FSFREEZE
61 #define QGA_FSFREEZE_HOOK_DEFAULT CONFIG_QEMU_CONFDIR "/fsfreeze-hook"
63 #define QGA_SENTINEL_BYTE 0xFF
64 #define QGA_CONF_DEFAULT CONFIG_QEMU_CONFDIR G_DIR_SEPARATOR_S "qemu-ga.conf"
65 #define QGA_RETRY_INTERVAL 5
68 const char *state_dir
;
72 typedef struct GAPersistentState
{
73 #define QGA_PSTATE_DEFAULT_FD_COUNTER 1000
77 typedef struct GAConfig GAConfig
;
80 JSONMessageParser parser
;
83 bool virtio
; /* fastpath to check for virtio to deal with poll() quirks */
84 GACommandState
*command_state
;
85 GLogLevelFlags log_level
;
92 bool delimit_response
;
95 char *state_filepath_isfrozen
;
97 const char *log_filepath
;
98 const char *pid_filepath
;
100 #ifdef CONFIG_FSFREEZE
101 const char *fsfreeze_hook
;
103 gchar
*pstate_filepath
;
104 GAPersistentState pstate
;
106 int socket_activation
;
110 struct GAState
*ga_state
;
111 QmpCommandList ga_commands
;
113 /* commands that are safe to issue while filesystems are frozen */
114 static const char *ga_freeze_allowlist
[] = {
118 "guest-sync-delimited",
119 "guest-fsfreeze-status",
120 "guest-fsfreeze-thaw",
125 DWORD WINAPI
service_ctrl_handler(DWORD ctrl
, DWORD type
, LPVOID data
,
127 DWORD WINAPI
handle_serial_device_events(DWORD type
, LPVOID data
);
128 VOID WINAPI
service_main(DWORD argc
, TCHAR
*argv
[]);
130 static int run_agent(GAState
*s
);
131 static void stop_agent(GAState
*s
, bool requested
);
134 init_dfl_pathnames(void)
136 g_autofree
char *state
= qemu_get_local_state_dir();
138 g_assert(dfl_pathnames
.state_dir
== NULL
);
139 g_assert(dfl_pathnames
.pidfile
== NULL
);
140 dfl_pathnames
.state_dir
= g_build_filename(state
, QGA_STATE_RELATIVE_DIR
, NULL
);
141 dfl_pathnames
.pidfile
= g_build_filename(state
, QGA_STATE_RELATIVE_DIR
, "qemu-ga.pid", NULL
);
144 static void quit_handler(int sig
)
146 /* if we're frozen, don't exit unless we're absolutely forced to,
147 * because it's basically impossible for graceful exit to complete
148 * unless all log/pid files are on unfreezable filesystems. there's
149 * also a very likely chance killing the agent before unfreezing
150 * the filesystems is a mistake (or will be viewed as one later).
151 * On Windows the freeze interval is limited to 10 seconds, so
152 * we should quit, but first we should wait for the timeout, thaw
153 * the filesystem and quit.
155 if (ga_is_frozen(ga_state
)) {
159 HANDLE hEventTimeout
;
161 g_debug("Thawing filesystems before exiting");
163 hEventTimeout
= OpenEvent(EVENT_ALL_ACCESS
, FALSE
, EVENT_NAME_TIMEOUT
);
165 WaitForSingleObject(hEventTimeout
, 0);
166 CloseHandle(hEventTimeout
);
168 qga_vss_fsfreeze(&i
, false, NULL
, &err
);
170 g_debug("Error unfreezing filesystems prior to exiting: %s",
171 error_get_pretty(err
));
178 g_debug("received signal num %d, quitting", sig
);
180 stop_agent(ga_state
, true);
184 static gboolean
register_signal_handlers(void)
186 struct sigaction sigact
;
189 memset(&sigact
, 0, sizeof(struct sigaction
));
190 sigact
.sa_handler
= quit_handler
;
192 ret
= sigaction(SIGINT
, &sigact
, NULL
);
194 g_error("error configuring signal handler: %s", strerror(errno
));
196 ret
= sigaction(SIGTERM
, &sigact
, NULL
);
198 g_error("error configuring signal handler: %s", strerror(errno
));
201 sigact
.sa_handler
= SIG_IGN
;
202 if (sigaction(SIGPIPE
, &sigact
, NULL
) != 0) {
203 g_error("error configuring SIGPIPE signal handler: %s",
210 /* TODO: use this in place of all post-fork() fclose(std*) callers */
211 void reopen_fd_to_null(int fd
)
215 nullfd
= open("/dev/null", O_RDWR
);
228 static void usage(const char *cmd
)
230 #ifdef CONFIG_FSFREEZE
231 g_autofree
char *fsfreeze_hook
= get_relocated_path(QGA_FSFREEZE_HOOK_DEFAULT
);
235 "Usage: %s [-m <method> -p <path>] [<options>]\n"
236 "QEMU Guest Agent " QEMU_FULL_VERSION
"\n"
239 " -m, --method transport method: one of unix-listen, virtio-serial,\n"
240 " isa-serial, or vsock-listen (virtio-serial is the default)\n"
241 " -p, --path device/socket path (the default for virtio-serial is:\n"
243 " the default for isa-serial is:\n"
245 " Socket addresses for vsock-listen are written as\n"
247 " -l, --logfile set logfile path, logs to stderr by default\n"
248 " -f, --pidfile specify pidfile (default is %s)\n"
249 #ifdef CONFIG_FSFREEZE
250 " -F, --fsfreeze-hook\n"
251 " enable fsfreeze hook. Accepts an optional argument that\n"
252 " specifies script to run on freeze/thaw. Script will be\n"
253 " called with 'freeze'/'thaw' arguments accordingly.\n"
255 " If using -F with an argument, do not follow -F with a\n"
257 " (for example: -F/var/run/fsfreezehook.sh)\n"
259 " -t, --statedir specify dir to store state information (absolute paths\n"
260 " only, default is %s)\n"
261 " -v, --verbose log extra debugging information\n"
262 " -V, --version print version information and exit\n"
263 " -d, --daemonize become a daemon\n"
265 " -s, --service service commands: install, uninstall, vss-install, vss-uninstall\n"
267 " -b, --block-rpcs comma-separated list of RPCs to disable (no spaces,\n"
268 " use \"help\" to list available RPCs)\n"
269 " -D, --dump-conf dump a qemu-ga config file based on current config\n"
270 " options / command-line parameters to stdout\n"
271 " -r, --retry-path attempt re-opening path if it's unavailable or closed\n"
272 " due to an error which may be recoverable in the future\n"
273 " (virtio-serial driver re-install, serial device hot\n"
274 " plug/unplug, etc.)\n"
275 " -h, --help display this help and exit\n"
277 QEMU_HELP_BOTTOM
"\n"
278 , cmd
, QGA_VIRTIO_PATH_DEFAULT
, QGA_SERIAL_PATH_DEFAULT
,
279 dfl_pathnames
.pidfile
,
280 #ifdef CONFIG_FSFREEZE
283 dfl_pathnames
.state_dir
);
286 static const char *ga_log_level_str(GLogLevelFlags level
)
288 switch (level
& G_LOG_LEVEL_MASK
) {
289 case G_LOG_LEVEL_ERROR
:
291 case G_LOG_LEVEL_CRITICAL
:
293 case G_LOG_LEVEL_WARNING
:
295 case G_LOG_LEVEL_MESSAGE
:
297 case G_LOG_LEVEL_INFO
:
299 case G_LOG_LEVEL_DEBUG
:
306 bool ga_logging_enabled(GAState
*s
)
308 return s
->logging_enabled
;
311 void ga_disable_logging(GAState
*s
)
313 s
->logging_enabled
= false;
316 void ga_enable_logging(GAState
*s
)
318 s
->logging_enabled
= true;
321 static void ga_log(const gchar
*domain
, GLogLevelFlags level
,
322 const gchar
*msg
, gpointer opaque
)
325 const char *level_str
= ga_log_level_str(level
);
327 if (!ga_logging_enabled(s
)) {
331 level
&= G_LOG_LEVEL_MASK
;
333 if (g_strcmp0(domain
, "syslog") == 0) {
334 syslog(LOG_INFO
, "%s: %s", level_str
, msg
);
335 } else if (level
& s
->log_level
) {
337 if (level
& s
->log_level
) {
339 g_autoptr(GDateTime
) now
= g_date_time_new_now_utc();
340 g_autofree
char *nowstr
= g_date_time_format(now
, "%s.%f");
341 fprintf(s
->log_file
, "%s: %s: %s\n", nowstr
, level_str
, msg
);
346 void ga_set_response_delimited(GAState
*s
)
348 s
->delimit_response
= true;
351 static FILE *ga_open_logfile(const char *logfile
)
355 f
= fopen(logfile
, "a");
360 qemu_set_cloexec(fileno(f
));
364 static gint
ga_strcmp(gconstpointer str1
, gconstpointer str2
)
366 return strcmp(str1
, str2
);
369 /* disable commands that aren't safe for fsfreeze */
370 static void ga_disable_not_allowed(const QmpCommand
*cmd
, void *opaque
)
372 bool allowed
= false;
374 const char *name
= qmp_command_name(cmd
);
376 while (ga_freeze_allowlist
[i
] != NULL
) {
377 if (strcmp(name
, ga_freeze_allowlist
[i
]) == 0) {
383 g_debug("disabling command: %s", name
);
384 qmp_disable_command(&ga_commands
, name
, "the agent is in frozen state");
388 /* [re-]enable all commands, except those explicitly blocked by user */
389 static void ga_enable_non_blocked(const QmpCommand
*cmd
, void *opaque
)
391 GList
*blockedrpcs
= opaque
;
392 const char *name
= qmp_command_name(cmd
);
394 if (g_list_find_custom(blockedrpcs
, name
, ga_strcmp
) == NULL
&&
395 !qmp_command_is_enabled(cmd
)) {
396 g_debug("enabling command: %s", name
);
397 qmp_enable_command(&ga_commands
, name
);
401 static bool ga_create_file(const char *path
)
403 int fd
= open(path
, O_CREAT
| O_WRONLY
, S_IWUSR
| S_IRUSR
);
405 g_warning("unable to open/create file %s: %s", path
, strerror(errno
));
412 static bool ga_delete_file(const char *path
)
414 int ret
= unlink(path
);
416 g_warning("unable to delete file: %s: %s", path
, strerror(errno
));
423 bool ga_is_frozen(GAState
*s
)
428 void ga_set_frozen(GAState
*s
)
430 if (ga_is_frozen(s
)) {
433 /* disable all forbidden (for frozen state) commands */
434 qmp_for_each_command(&ga_commands
, ga_disable_not_allowed
, NULL
);
435 g_warning("disabling logging due to filesystem freeze");
436 ga_disable_logging(s
);
438 if (!ga_create_file(s
->state_filepath_isfrozen
)) {
439 g_warning("unable to create %s, fsfreeze may not function properly",
440 s
->state_filepath_isfrozen
);
444 void ga_unset_frozen(GAState
*s
)
446 if (!ga_is_frozen(s
)) {
450 /* if we delayed creation/opening of pid/log files due to being
451 * in a frozen state at start up, do it now
453 if (s
->deferred_options
.log_filepath
) {
454 s
->log_file
= ga_open_logfile(s
->deferred_options
.log_filepath
);
456 s
->log_file
= stderr
;
458 s
->deferred_options
.log_filepath
= NULL
;
460 ga_enable_logging(s
);
461 g_warning("logging re-enabled due to filesystem unfreeze");
462 if (s
->deferred_options
.pid_filepath
) {
465 if (!qemu_write_pidfile(s
->deferred_options
.pid_filepath
, &err
)) {
466 g_warning("%s", error_get_pretty(err
));
469 s
->deferred_options
.pid_filepath
= NULL
;
472 /* enable all disabled, non-blocked commands */
473 qmp_for_each_command(&ga_commands
, ga_enable_non_blocked
, s
->blockedrpcs
);
475 if (!ga_delete_file(s
->state_filepath_isfrozen
)) {
476 g_warning("unable to delete %s, fsfreeze may not function properly",
477 s
->state_filepath_isfrozen
);
481 #ifdef CONFIG_FSFREEZE
482 const char *ga_fsfreeze_hook(GAState
*s
)
484 return s
->fsfreeze_hook
;
488 static void become_daemon(const char *pidfile
)
504 if (!qemu_write_pidfile(pidfile
, &err
)) {
505 g_critical("%s", error_get_pretty(err
));
511 umask(S_IRWXG
| S_IRWXO
);
516 if ((chdir("/")) < 0) {
520 reopen_fd_to_null(STDIN_FILENO
);
521 reopen_fd_to_null(STDOUT_FILENO
);
522 reopen_fd_to_null(STDERR_FILENO
);
529 g_critical("failed to daemonize");
534 static int send_response(GAState
*s
, const QDict
*rsp
)
539 g_assert(s
->channel
);
545 response
= qobject_to_json(QOBJECT(rsp
));
550 if (s
->delimit_response
) {
551 s
->delimit_response
= false;
552 g_string_prepend_c(response
, QGA_SENTINEL_BYTE
);
555 g_string_append_c(response
, '\n');
556 status
= ga_channel_write_all(s
->channel
, response
->str
, response
->len
);
557 g_string_free(response
, true);
558 if (status
!= G_IO_STATUS_NORMAL
) {
565 /* handle requests/control events coming in over the channel */
566 static void process_event(void *opaque
, QObject
*obj
, Error
*err
)
572 g_debug("process_event: called");
573 assert(!obj
!= !err
);
575 rsp
= qmp_error_response(err
);
579 g_debug("processing command");
580 rsp
= qmp_dispatch(&ga_commands
, obj
, false, NULL
);
583 ret
= send_response(s
, rsp
);
585 g_warning("error sending error response: %s", strerror(-ret
));
591 /* false return signals GAChannel to close the current client connection */
592 static gboolean
channel_event_cb(GIOCondition condition
, gpointer data
)
595 gchar buf
[QGA_READ_COUNT_DEFAULT
+ 1];
597 GIOStatus status
= ga_channel_read(s
->channel
, buf
, QGA_READ_COUNT_DEFAULT
, &count
);
599 case G_IO_STATUS_ERROR
:
600 g_warning("error reading channel");
601 stop_agent(s
, false);
603 case G_IO_STATUS_NORMAL
:
605 g_debug("read data, count: %d, data: %s", (int)count
, buf
);
606 json_message_parser_feed(&s
->parser
, (char *)buf
, (int)count
);
608 case G_IO_STATUS_EOF
:
609 g_debug("received EOF");
614 case G_IO_STATUS_AGAIN
:
615 /* virtio causes us to spin here when no process is attached to
616 * host-side chardev. sleep a bit to mitigate this
619 g_usleep(G_USEC_PER_SEC
/ 10);
623 g_warning("unknown channel read status, closing");
629 static gboolean
channel_init(GAState
*s
, const gchar
*method
, const gchar
*path
,
632 GAChannelMethod channel_method
;
634 if (strcmp(method
, "virtio-serial") == 0) {
635 s
->virtio
= true; /* virtio requires special handling in some cases */
636 channel_method
= GA_CHANNEL_VIRTIO_SERIAL
;
637 } else if (strcmp(method
, "isa-serial") == 0) {
638 channel_method
= GA_CHANNEL_ISA_SERIAL
;
639 } else if (strcmp(method
, "unix-listen") == 0) {
640 channel_method
= GA_CHANNEL_UNIX_LISTEN
;
641 } else if (strcmp(method
, "vsock-listen") == 0) {
642 channel_method
= GA_CHANNEL_VSOCK_LISTEN
;
644 g_critical("unsupported channel method/type: %s", method
);
648 s
->channel
= ga_channel_new(channel_method
, path
, listen_fd
,
649 channel_event_cb
, s
);
651 g_critical("failed to create guest agent channel");
659 DWORD WINAPI
handle_serial_device_events(DWORD type
, LPVOID data
)
661 DWORD ret
= NO_ERROR
;
662 PDEV_BROADCAST_HDR broadcast_header
= (PDEV_BROADCAST_HDR
)data
;
664 if (broadcast_header
->dbch_devicetype
== DBT_DEVTYP_DEVICEINTERFACE
) {
666 /* Device inserted */
667 case DBT_DEVICEARRIVAL
:
668 /* Start QEMU-ga's service */
669 if (!SetEvent(ga_state
->wakeup_event
)) {
670 ret
= GetLastError();
674 case DBT_DEVICEQUERYREMOVE
:
675 case DBT_DEVICEREMOVEPENDING
:
676 case DBT_DEVICEREMOVECOMPLETE
:
677 /* Stop QEMU-ga's service */
678 if (!ResetEvent(ga_state
->wakeup_event
)) {
679 ret
= GetLastError();
683 ret
= ERROR_CALL_NOT_IMPLEMENTED
;
689 DWORD WINAPI
service_ctrl_handler(DWORD ctrl
, DWORD type
, LPVOID data
,
692 DWORD ret
= NO_ERROR
;
693 GAService
*service
= &ga_state
->service
;
696 case SERVICE_CONTROL_STOP
:
697 case SERVICE_CONTROL_SHUTDOWN
:
698 quit_handler(SIGTERM
);
699 SetEvent(ga_state
->wakeup_event
);
700 service
->status
.dwCurrentState
= SERVICE_STOP_PENDING
;
701 SetServiceStatus(service
->status_handle
, &service
->status
);
703 case SERVICE_CONTROL_DEVICEEVENT
:
704 handle_serial_device_events(type
, data
);
708 ret
= ERROR_CALL_NOT_IMPLEMENTED
;
713 VOID WINAPI
service_main(DWORD argc
, TCHAR
*argv
[])
715 GAService
*service
= &ga_state
->service
;
717 service
->status_handle
= RegisterServiceCtrlHandlerEx(QGA_SERVICE_NAME
,
718 service_ctrl_handler
, NULL
);
720 if (service
->status_handle
== 0) {
721 g_critical("Failed to register extended requests function!\n");
725 service
->status
.dwServiceType
= SERVICE_WIN32
;
726 service
->status
.dwCurrentState
= SERVICE_RUNNING
;
727 service
->status
.dwControlsAccepted
= SERVICE_ACCEPT_STOP
| SERVICE_ACCEPT_SHUTDOWN
;
728 service
->status
.dwWin32ExitCode
= NO_ERROR
;
729 service
->status
.dwServiceSpecificExitCode
= NO_ERROR
;
730 service
->status
.dwCheckPoint
= 0;
731 service
->status
.dwWaitHint
= 0;
732 DEV_BROADCAST_DEVICEINTERFACE notification_filter
;
733 ZeroMemory(¬ification_filter
, sizeof(notification_filter
));
734 notification_filter
.dbcc_devicetype
= DBT_DEVTYP_DEVICEINTERFACE
;
735 notification_filter
.dbcc_size
= sizeof(DEV_BROADCAST_DEVICEINTERFACE
);
736 notification_filter
.dbcc_classguid
= GUID_VIOSERIAL_PORT
;
738 service
->device_notification_handle
=
739 RegisterDeviceNotification(service
->status_handle
,
740 ¬ification_filter
, DEVICE_NOTIFY_SERVICE_HANDLE
);
741 if (!service
->device_notification_handle
) {
742 g_critical("Failed to register device notification handle!\n");
745 SetServiceStatus(service
->status_handle
, &service
->status
);
749 UnregisterDeviceNotification(service
->device_notification_handle
);
750 service
->status
.dwCurrentState
= SERVICE_STOPPED
;
751 SetServiceStatus(service
->status_handle
, &service
->status
);
755 static void set_persistent_state_defaults(GAPersistentState
*pstate
)
758 pstate
->fd_counter
= QGA_PSTATE_DEFAULT_FD_COUNTER
;
761 static void persistent_state_from_keyfile(GAPersistentState
*pstate
,
766 /* if any fields are missing, either because the file was tampered with
767 * by agents of chaos, or because the field wasn't present at the time the
768 * file was created, the best we can ever do is start over with the default
769 * values. so load them now, and ignore any errors in accessing key-value
772 set_persistent_state_defaults(pstate
);
774 if (g_key_file_has_key(keyfile
, "global", "fd_counter", NULL
)) {
776 g_key_file_get_integer(keyfile
, "global", "fd_counter", NULL
);
780 static void persistent_state_to_keyfile(const GAPersistentState
*pstate
,
786 g_key_file_set_integer(keyfile
, "global", "fd_counter", pstate
->fd_counter
);
789 static gboolean
write_persistent_state(const GAPersistentState
*pstate
,
792 GKeyFile
*keyfile
= g_key_file_new();
800 persistent_state_to_keyfile(pstate
, keyfile
);
801 data
= g_key_file_to_data(keyfile
, &data_len
, &gerr
);
803 g_critical("failed to convert persistent state to string: %s",
809 g_file_set_contents(path
, data
, data_len
, &gerr
);
811 g_critical("failed to write persistent state to %s: %s",
812 path
, gerr
->message
);
822 g_key_file_free(keyfile
);
828 static gboolean
read_persistent_state(GAPersistentState
*pstate
,
829 const gchar
*path
, gboolean frozen
)
831 GKeyFile
*keyfile
= NULL
;
838 if (stat(path
, &st
) == -1) {
839 /* it's okay if state file doesn't exist, but any other error
840 * indicates a permissions issue or some other misconfiguration
841 * that we likely won't be able to recover from.
843 if (errno
!= ENOENT
) {
844 g_critical("unable to access state file at path %s: %s",
845 path
, strerror(errno
));
850 /* file doesn't exist. initialize state to default values and
851 * attempt to save now. (we could wait till later when we have
852 * modified state we need to commit, but if there's a problem,
853 * such as a missing parent directory, we want to catch it now)
855 * there is a potential scenario where someone either managed to
856 * update the agent from a version that didn't use a key store
857 * while qemu-ga thought the filesystem was frozen, or
858 * deleted the key store prior to issuing a fsfreeze, prior
859 * to restarting the agent. in this case we go ahead and defer
860 * initial creation till we actually have modified state to
861 * write, otherwise fail to recover from freeze.
863 set_persistent_state_defaults(pstate
);
865 ret
= write_persistent_state(pstate
, path
);
867 g_critical("unable to create state file at path %s", path
);
876 keyfile
= g_key_file_new();
877 g_key_file_load_from_file(keyfile
, path
, 0, &gerr
);
879 g_critical("error loading persistent state from path: %s, %s",
880 path
, gerr
->message
);
885 persistent_state_from_keyfile(pstate
, keyfile
);
889 g_key_file_free(keyfile
);
898 int64_t ga_get_fd_handle(GAState
*s
, Error
**errp
)
902 g_assert(s
->pstate_filepath
);
904 * We block commands and avoid operations that potentially require
905 * writing to disk when we're in a frozen state. this includes opening
906 * new files, so we should never get here in that situation
908 g_assert(!ga_is_frozen(s
));
910 handle
= s
->pstate
.fd_counter
++;
912 /* This should never happen on a reasonable timeframe, as guest-file-open
913 * would have to be issued 2^63 times */
914 if (s
->pstate
.fd_counter
== INT64_MAX
) {
918 if (!write_persistent_state(&s
->pstate
, s
->pstate_filepath
)) {
919 error_setg(errp
, "failed to commit persistent state to disk");
926 static void ga_print_cmd(const QmpCommand
*cmd
, void *opaque
)
928 printf("%s\n", qmp_command_name(cmd
));
931 static GList
*split_list(const gchar
*str
, const gchar
*delim
)
937 strv
= g_strsplit(str
, delim
, -1);
938 for (i
= 0; strv
[i
]; i
++) {
939 list
= g_list_prepend(list
, strv
[i
]);
951 #ifdef CONFIG_FSFREEZE
958 gchar
*bliststr
; /* blockedrpcs may point to this string */
961 GLogLevelFlags log_level
;
966 static void config_load(GAConfig
*config
)
970 g_autofree
char *conf
= g_strdup(g_getenv("QGA_CONF")) ?: get_relocated_path(QGA_CONF_DEFAULT
);
971 const gchar
*blockrpcs_key
= "block-rpcs";
973 /* read system config */
974 keyfile
= g_key_file_new();
975 if (!g_key_file_load_from_file(keyfile
, conf
, 0, &gerr
)) {
978 if (g_key_file_has_key(keyfile
, "general", "daemon", NULL
)) {
980 g_key_file_get_boolean(keyfile
, "general", "daemon", &gerr
);
982 if (g_key_file_has_key(keyfile
, "general", "method", NULL
)) {
984 g_key_file_get_string(keyfile
, "general", "method", &gerr
);
986 if (g_key_file_has_key(keyfile
, "general", "path", NULL
)) {
987 config
->channel_path
=
988 g_key_file_get_string(keyfile
, "general", "path", &gerr
);
990 if (g_key_file_has_key(keyfile
, "general", "logfile", NULL
)) {
991 config
->log_filepath
=
992 g_key_file_get_string(keyfile
, "general", "logfile", &gerr
);
994 if (g_key_file_has_key(keyfile
, "general", "pidfile", NULL
)) {
995 config
->pid_filepath
=
996 g_key_file_get_string(keyfile
, "general", "pidfile", &gerr
);
998 #ifdef CONFIG_FSFREEZE
999 if (g_key_file_has_key(keyfile
, "general", "fsfreeze-hook", NULL
)) {
1000 config
->fsfreeze_hook
=
1001 g_key_file_get_string(keyfile
,
1002 "general", "fsfreeze-hook", &gerr
);
1005 if (g_key_file_has_key(keyfile
, "general", "statedir", NULL
)) {
1007 g_key_file_get_string(keyfile
, "general", "statedir", &gerr
);
1009 if (g_key_file_has_key(keyfile
, "general", "verbose", NULL
) &&
1010 g_key_file_get_boolean(keyfile
, "general", "verbose", &gerr
)) {
1011 /* enable all log levels */
1012 config
->log_level
= G_LOG_LEVEL_MASK
;
1014 if (g_key_file_has_key(keyfile
, "general", "retry-path", NULL
)) {
1015 config
->retry_path
=
1016 g_key_file_get_boolean(keyfile
, "general", "retry-path", &gerr
);
1019 if (g_key_file_has_key(keyfile
, "general", "blacklist", NULL
)) {
1020 g_warning("config using deprecated 'blacklist' key, should be replaced"
1021 " with the 'block-rpcs' key.");
1022 blockrpcs_key
= "blacklist";
1024 if (g_key_file_has_key(keyfile
, "general", blockrpcs_key
, NULL
)) {
1026 g_key_file_get_string(keyfile
, "general", blockrpcs_key
, &gerr
);
1027 config
->blockedrpcs
= g_list_concat(config
->blockedrpcs
,
1028 split_list(config
->bliststr
, ","));
1032 g_key_file_free(keyfile
);
1034 !(gerr
->domain
== G_FILE_ERROR
&& gerr
->code
== G_FILE_ERROR_NOENT
)) {
1035 g_critical("error loading configuration from path: %s, %s",
1036 conf
, gerr
->message
);
1039 g_clear_error(&gerr
);
1042 static gchar
*list_join(GList
*list
, const gchar separator
)
1044 GString
*str
= g_string_new("");
1047 str
= g_string_append(str
, (gchar
*)list
->data
);
1048 list
= g_list_next(list
);
1050 str
= g_string_append_c(str
, separator
);
1054 return g_string_free(str
, FALSE
);
1057 static void config_dump(GAConfig
*config
)
1059 GError
*error
= NULL
;
1063 keyfile
= g_key_file_new();
1066 g_key_file_set_boolean(keyfile
, "general", "daemon", config
->daemonize
);
1067 g_key_file_set_string(keyfile
, "general", "method", config
->method
);
1068 if (config
->channel_path
) {
1069 g_key_file_set_string(keyfile
, "general", "path", config
->channel_path
);
1071 if (config
->log_filepath
) {
1072 g_key_file_set_string(keyfile
, "general", "logfile",
1073 config
->log_filepath
);
1075 g_key_file_set_string(keyfile
, "general", "pidfile", config
->pid_filepath
);
1076 #ifdef CONFIG_FSFREEZE
1077 if (config
->fsfreeze_hook
) {
1078 g_key_file_set_string(keyfile
, "general", "fsfreeze-hook",
1079 config
->fsfreeze_hook
);
1082 g_key_file_set_string(keyfile
, "general", "statedir", config
->state_dir
);
1083 g_key_file_set_boolean(keyfile
, "general", "verbose",
1084 config
->log_level
== G_LOG_LEVEL_MASK
);
1085 g_key_file_set_boolean(keyfile
, "general", "retry-path",
1086 config
->retry_path
);
1087 tmp
= list_join(config
->blockedrpcs
, ',');
1088 g_key_file_set_string(keyfile
, "general", "block-rpcs", tmp
);
1091 tmp
= g_key_file_to_data(keyfile
, NULL
, &error
);
1093 g_critical("Failed to dump keyfile: %s", error
->message
);
1094 g_clear_error(&error
);
1100 g_key_file_free(keyfile
);
1103 static void config_parse(GAConfig
*config
, int argc
, char **argv
)
1105 const char *sopt
= "hVvdm:p:l:f:F::b:s:t:Dr";
1106 int opt_ind
= 0, ch
;
1107 const struct option lopt
[] = {
1108 { "help", 0, NULL
, 'h' },
1109 { "version", 0, NULL
, 'V' },
1110 { "dump-conf", 0, NULL
, 'D' },
1111 { "logfile", 1, NULL
, 'l' },
1112 { "pidfile", 1, NULL
, 'f' },
1113 #ifdef CONFIG_FSFREEZE
1114 { "fsfreeze-hook", 2, NULL
, 'F' },
1116 { "verbose", 0, NULL
, 'v' },
1117 { "method", 1, NULL
, 'm' },
1118 { "path", 1, NULL
, 'p' },
1119 { "daemonize", 0, NULL
, 'd' },
1120 { "block-rpcs", 1, NULL
, 'b' },
1121 { "blacklist", 1, NULL
, 'b' }, /* deprecated alias for 'block-rpcs' */
1123 { "service", 1, NULL
, 's' },
1125 { "statedir", 1, NULL
, 't' },
1126 { "retry-path", 0, NULL
, 'r' },
1127 { NULL
, 0, NULL
, 0 }
1130 while ((ch
= getopt_long(argc
, argv
, sopt
, lopt
, &opt_ind
)) != -1) {
1133 g_free(config
->method
);
1134 config
->method
= g_strdup(optarg
);
1137 g_free(config
->channel_path
);
1138 config
->channel_path
= g_strdup(optarg
);
1141 g_free(config
->log_filepath
);
1142 config
->log_filepath
= g_strdup(optarg
);
1145 g_free(config
->pid_filepath
);
1146 config
->pid_filepath
= g_strdup(optarg
);
1148 #ifdef CONFIG_FSFREEZE
1150 g_free(config
->fsfreeze_hook
);
1151 config
->fsfreeze_hook
= optarg
? g_strdup(optarg
) : get_relocated_path(QGA_FSFREEZE_HOOK_DEFAULT
);
1155 g_free(config
->state_dir
);
1156 config
->state_dir
= g_strdup(optarg
);
1159 /* enable all log levels */
1160 config
->log_level
= G_LOG_LEVEL_MASK
;
1163 printf("QEMU Guest Agent %s\n", QEMU_VERSION
);
1166 config
->daemonize
= 1;
1169 config
->dumpconf
= 1;
1172 config
->retry_path
= true;
1175 if (is_help_option(optarg
)) {
1176 qmp_for_each_command(&ga_commands
, ga_print_cmd
, NULL
);
1179 config
->blockedrpcs
= g_list_concat(config
->blockedrpcs
,
1180 split_list(optarg
, ","));
1185 config
->service
= optarg
;
1186 if (strcmp(config
->service
, "install") == 0) {
1187 if (ga_install_vss_provider()) {
1190 if (ga_install_service(config
->channel_path
,
1191 config
->log_filepath
, config
->state_dir
)) {
1195 } else if (strcmp(config
->service
, "uninstall") == 0) {
1196 ga_uninstall_vss_provider();
1197 exit(ga_uninstall_service());
1198 } else if (strcmp(config
->service
, "vss-install") == 0) {
1199 if (ga_install_vss_provider()) {
1203 } else if (strcmp(config
->service
, "vss-uninstall") == 0) {
1204 ga_uninstall_vss_provider();
1207 printf("Unknown service command.\n");
1216 g_print("Unknown option, try '%s --help' for more information.\n",
1223 static void config_free(GAConfig
*config
)
1225 g_free(config
->method
);
1226 g_free(config
->log_filepath
);
1227 g_free(config
->pid_filepath
);
1228 g_free(config
->state_dir
);
1229 g_free(config
->channel_path
);
1230 g_free(config
->bliststr
);
1231 #ifdef CONFIG_FSFREEZE
1232 g_free(config
->fsfreeze_hook
);
1234 g_list_free_full(config
->blockedrpcs
, g_free
);
1238 static bool check_is_frozen(GAState
*s
)
1241 /* check if a previous instance of qemu-ga exited with filesystems' state
1242 * marked as frozen. this could be a stale value (a non-qemu-ga process
1243 * or reboot may have since unfrozen them), but better to require an
1244 * uneeded unfreeze than to risk hanging on start-up
1247 if (stat(s
->state_filepath_isfrozen
, &st
) == -1) {
1248 /* it's okay if the file doesn't exist, but if we can't access for
1249 * some other reason, such as permissions, there's a configuration
1250 * that needs to be addressed. so just bail now before we get into
1251 * more trouble later
1253 if (errno
!= ENOENT
) {
1254 g_critical("unable to access state file at path %s: %s",
1255 s
->state_filepath_isfrozen
, strerror(errno
));
1256 return EXIT_FAILURE
;
1259 g_warning("previous instance appears to have exited with frozen"
1260 " filesystems. deferring logging/pidfile creation and"
1261 " disabling non-fsfreeze-safe commands until"
1262 " guest-fsfreeze-thaw is issued, or filesystems are"
1263 " manually unfrozen and the file %s is removed",
1264 s
->state_filepath_isfrozen
);
1271 static GAState
*initialize_agent(GAConfig
*config
, int socket_activation
)
1273 GAState
*s
= g_new0(GAState
, 1);
1275 g_assert(ga_state
== NULL
);
1277 s
->log_level
= config
->log_level
;
1278 s
->log_file
= stderr
;
1279 #ifdef CONFIG_FSFREEZE
1280 s
->fsfreeze_hook
= config
->fsfreeze_hook
;
1282 s
->pstate_filepath
= g_strdup_printf("%s/qga.state", config
->state_dir
);
1283 s
->state_filepath_isfrozen
= g_strdup_printf("%s/qga.state.isfrozen",
1285 s
->frozen
= check_is_frozen(s
);
1287 g_log_set_default_handler(ga_log
, s
);
1288 g_log_set_fatal_mask(NULL
, G_LOG_LEVEL_ERROR
);
1289 ga_enable_logging(s
);
1291 g_debug("Guest agent version %s started", QEMU_FULL_VERSION
);
1294 /* On win32 the state directory is application specific (be it the default
1295 * or a user override). We got past the command line parsing; let's create
1296 * the directory (with any intermediate directories). If we run into an
1297 * error later on, we won't try to clean up the directory, it is considered
1300 if (g_mkdir_with_parents(config
->state_dir
, S_IRWXU
) == -1) {
1301 g_critical("unable to create (an ancestor of) the state directory"
1302 " '%s': %s", config
->state_dir
, strerror(errno
));
1307 if (ga_is_frozen(s
)) {
1308 if (config
->daemonize
) {
1309 /* delay opening/locking of pidfile till filesystems are unfrozen */
1310 s
->deferred_options
.pid_filepath
= config
->pid_filepath
;
1311 become_daemon(NULL
);
1313 if (config
->log_filepath
) {
1314 /* delay opening the log file till filesystems are unfrozen */
1315 s
->deferred_options
.log_filepath
= config
->log_filepath
;
1317 ga_disable_logging(s
);
1318 qmp_for_each_command(&ga_commands
, ga_disable_not_allowed
, NULL
);
1320 if (config
->daemonize
) {
1321 become_daemon(config
->pid_filepath
);
1323 if (config
->log_filepath
) {
1324 FILE *log_file
= ga_open_logfile(config
->log_filepath
);
1326 g_critical("unable to open specified log file: %s",
1330 s
->log_file
= log_file
;
1334 /* load persistent state from disk */
1335 if (!read_persistent_state(&s
->pstate
,
1338 g_critical("failed to load persistent state");
1342 config
->blockedrpcs
= ga_command_init_blockedrpcs(config
->blockedrpcs
);
1343 if (config
->blockedrpcs
) {
1344 GList
*l
= config
->blockedrpcs
;
1345 s
->blockedrpcs
= config
->blockedrpcs
;
1347 g_debug("disabling command: %s", (char *)l
->data
);
1348 qmp_disable_command(&ga_commands
, l
->data
, NULL
);
1352 s
->command_state
= ga_command_state_new();
1353 ga_command_state_init(s
, s
->command_state
);
1354 ga_command_state_init_all(s
->command_state
);
1355 json_message_parser_init(&s
->parser
, process_event
, s
, NULL
);
1358 if (!register_signal_handlers()) {
1359 g_critical("failed to register signal handlers");
1364 s
->main_loop
= g_main_loop_new(NULL
, false);
1367 s
->socket_activation
= socket_activation
;
1370 s
->wakeup_event
= CreateEvent(NULL
, TRUE
, FALSE
, TEXT("WakeUp"));
1371 if (s
->wakeup_event
== NULL
) {
1372 g_critical("CreateEvent failed");
1381 static void cleanup_agent(GAState
*s
)
1384 CloseHandle(s
->wakeup_event
);
1386 if (s
->command_state
) {
1387 ga_command_state_cleanup_all(s
->command_state
);
1388 ga_command_state_free(s
->command_state
);
1389 json_message_parser_destroy(&s
->parser
);
1391 g_free(s
->pstate_filepath
);
1392 g_free(s
->state_filepath_isfrozen
);
1394 g_main_loop_unref(s
->main_loop
);
1400 static int run_agent_once(GAState
*s
)
1402 if (!channel_init(s
, s
->config
->method
, s
->config
->channel_path
,
1403 s
->socket_activation
? FIRST_SOCKET_ACTIVATION_FD
: -1)) {
1404 g_critical("failed to initialize guest agent channel");
1405 return EXIT_FAILURE
;
1408 g_main_loop_run(ga_state
->main_loop
);
1411 ga_channel_free(s
->channel
);
1414 return EXIT_SUCCESS
;
1417 static void wait_for_channel_availability(GAState
*s
)
1419 g_warning("waiting for channel path...");
1421 sleep(QGA_RETRY_INTERVAL
);
1425 dwWaitResult
= WaitForSingleObject(s
->wakeup_event
, INFINITE
);
1427 switch (dwWaitResult
) {
1433 g_critical("WaitForSingleObject failed");
1438 static int run_agent(GAState
*s
)
1440 int ret
= EXIT_SUCCESS
;
1442 s
->force_exit
= false;
1445 ret
= run_agent_once(s
);
1446 if (s
->config
->retry_path
&& !s
->force_exit
) {
1447 g_warning("agent stopped unexpectedly, restarting...");
1448 wait_for_channel_availability(s
);
1450 } while (s
->config
->retry_path
&& !s
->force_exit
);
1455 static void stop_agent(GAState
*s
, bool requested
)
1457 if (!s
->force_exit
) {
1458 s
->force_exit
= requested
;
1461 if (g_main_loop_is_running(s
->main_loop
)) {
1462 g_main_loop_quit(s
->main_loop
);
1466 int main(int argc
, char **argv
)
1468 int ret
= EXIT_SUCCESS
;
1470 GAConfig
*config
= g_new0(GAConfig
, 1);
1471 int socket_activation
;
1473 config
->log_level
= G_LOG_LEVEL_ERROR
| G_LOG_LEVEL_CRITICAL
;
1475 qemu_init_exec_dir(argv
[0]);
1476 qga_qmp_init_marshal(&ga_commands
);
1478 init_dfl_pathnames();
1479 config_load(config
);
1480 config_parse(config
, argc
, argv
);
1482 if (config
->pid_filepath
== NULL
) {
1483 config
->pid_filepath
= g_strdup(dfl_pathnames
.pidfile
);
1486 if (config
->state_dir
== NULL
) {
1487 config
->state_dir
= g_strdup(dfl_pathnames
.state_dir
);
1490 if (config
->method
== NULL
) {
1491 config
->method
= g_strdup("virtio-serial");
1494 socket_activation
= check_socket_activation();
1495 if (socket_activation
> 1) {
1496 g_critical("qemu-ga only supports listening on one socket");
1500 if (socket_activation
) {
1501 SocketAddress
*addr
;
1503 g_free(config
->method
);
1504 g_free(config
->channel_path
);
1505 config
->method
= NULL
;
1506 config
->channel_path
= NULL
;
1508 addr
= socket_local_address(FIRST_SOCKET_ACTIVATION_FD
, NULL
);
1510 if (addr
->type
== SOCKET_ADDRESS_TYPE_UNIX
) {
1511 config
->method
= g_strdup("unix-listen");
1512 } else if (addr
->type
== SOCKET_ADDRESS_TYPE_VSOCK
) {
1513 config
->method
= g_strdup("vsock-listen");
1516 qapi_free_SocketAddress(addr
);
1519 if (!config
->method
) {
1520 g_critical("unsupported listen fd type");
1524 } else if (config
->channel_path
== NULL
) {
1525 if (strcmp(config
->method
, "virtio-serial") == 0) {
1526 /* try the default path for the virtio-serial port */
1527 config
->channel_path
= g_strdup(QGA_VIRTIO_PATH_DEFAULT
);
1528 } else if (strcmp(config
->method
, "isa-serial") == 0) {
1529 /* try the default path for the serial port - COM1 */
1530 config
->channel_path
= g_strdup(QGA_SERIAL_PATH_DEFAULT
);
1532 g_critical("must specify a path for this channel");
1538 if (config
->dumpconf
) {
1539 config_dump(config
);
1543 s
= initialize_agent(config
, socket_activation
);
1545 g_critical("error initializing guest agent");
1550 if (config
->daemonize
) {
1551 SERVICE_TABLE_ENTRY service_table
[] = {
1552 { (char *)QGA_SERVICE_NAME
, service_main
}, { NULL
, NULL
} };
1553 StartServiceCtrlDispatcher(service_table
);
1564 if (config
->daemonize
) {
1565 unlink(config
->pid_filepath
);
1568 config_free(config
);