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.
23 #include "qapi/qmp/json-streamer.h"
24 #include "qapi/qmp/json-parser.h"
25 #include "qapi/qmp/qint.h"
26 #include "qapi/qmp/qjson.h"
27 #include "qga/guest-agent-core.h"
28 #include "qemu/module.h"
30 #include "qapi/qmp/qerror.h"
31 #include "qapi/qmp/dispatch.h"
32 #include "qga/channel.h"
34 #include "qga/service-win32.h"
40 #define CONFIG_FSFREEZE
45 #define QGA_VIRTIO_PATH_DEFAULT "/dev/virtio-ports/org.qemu.guest_agent.0"
47 #define QGA_VIRTIO_PATH_DEFAULT "\\\\.\\Global\\org.qemu.guest_agent.0"
49 #define QGA_STATEDIR_DEFAULT CONFIG_QEMU_LOCALSTATEDIR "/run"
50 #define QGA_PIDFILE_DEFAULT QGA_STATEDIR_DEFAULT "/qemu-ga.pid"
51 #ifdef CONFIG_FSFREEZE
52 #define QGA_FSFREEZE_HOOK_DEFAULT CONFIG_QEMU_CONFDIR "/fsfreeze-hook"
54 #define QGA_SENTINEL_BYTE 0xFF
57 JSONMessageParser parser
;
60 bool virtio
; /* fastpath to check for virtio to deal with poll() quirks */
61 GACommandState
*command_state
;
62 GLogLevelFlags log_level
;
68 bool delimit_response
;
71 const char *state_filepath_isfrozen
;
73 const char *log_filepath
;
74 const char *pid_filepath
;
76 #ifdef CONFIG_FSFREEZE
77 const char *fsfreeze_hook
;
81 struct GAState
*ga_state
;
83 /* commands that are safe to issue while filesystems are frozen */
84 static const char *ga_freeze_whitelist
[] = {
88 "guest-sync-delimited",
89 "guest-fsfreeze-status",
90 "guest-fsfreeze-thaw",
95 DWORD WINAPI
service_ctrl_handler(DWORD ctrl
, DWORD type
, LPVOID data
,
97 VOID WINAPI
service_main(DWORD argc
, TCHAR
*argv
[]);
100 static void quit_handler(int sig
)
102 /* if we're frozen, don't exit unless we're absolutely forced to,
103 * because it's basically impossible for graceful exit to complete
104 * unless all log/pid files are on unfreezable filesystems. there's
105 * also a very likely chance killing the agent before unfreezing
106 * the filesystems is a mistake (or will be viewed as one later).
108 if (ga_is_frozen(ga_state
)) {
111 g_debug("received signal num %d, quitting", sig
);
113 if (g_main_loop_is_running(ga_state
->main_loop
)) {
114 g_main_loop_quit(ga_state
->main_loop
);
119 static gboolean
register_signal_handlers(void)
121 struct sigaction sigact
;
124 memset(&sigact
, 0, sizeof(struct sigaction
));
125 sigact
.sa_handler
= quit_handler
;
127 ret
= sigaction(SIGINT
, &sigact
, NULL
);
129 g_error("error configuring signal handler: %s", strerror(errno
));
131 ret
= sigaction(SIGTERM
, &sigact
, NULL
);
133 g_error("error configuring signal handler: %s", strerror(errno
));
139 /* TODO: use this in place of all post-fork() fclose(std*) callers */
140 void reopen_fd_to_null(int fd
)
144 nullfd
= open("/dev/null", O_RDWR
);
157 static void usage(const char *cmd
)
160 "Usage: %s [-m <method> -p <path>] [<options>]\n"
161 "QEMU Guest Agent %s\n"
163 " -m, --method transport method: one of unix-listen, virtio-serial, or\n"
164 " isa-serial (virtio-serial is the default)\n"
165 " -p, --path device/socket path (the default for virtio-serial is:\n"
167 " -l, --logfile set logfile path, logs to stderr by default\n"
168 " -f, --pidfile specify pidfile (default is %s)\n"
169 #ifdef CONFIG_FSFREEZE
170 " -F, --fsfreeze-hook\n"
171 " enable fsfreeze hook. Accepts an optional argument that\n"
172 " specifies script to run on freeze/thaw. Script will be\n"
173 " called with 'freeze'/'thaw' arguments accordingly.\n"
175 " If using -F with an argument, do not follow -F with a\n"
177 " (for example: -F/var/run/fsfreezehook.sh)\n"
179 " -t, --statedir specify dir to store state information (absolute paths\n"
180 " only, default is %s)\n"
181 " -v, --verbose log extra debugging information\n"
182 " -V, --version print version information and exit\n"
183 " -d, --daemonize become a daemon\n"
185 " -s, --service service commands: install, uninstall\n"
187 " -b, --blacklist comma-separated list of RPCs to disable (no spaces, \"?\"\n"
188 " to list available RPCs)\n"
189 " -h, --help display this help and exit\n"
191 "Report bugs to <mdroth@linux.vnet.ibm.com>\n"
192 , cmd
, QEMU_VERSION
, QGA_VIRTIO_PATH_DEFAULT
, QGA_PIDFILE_DEFAULT
,
193 #ifdef CONFIG_FSFREEZE
194 QGA_FSFREEZE_HOOK_DEFAULT
,
196 QGA_STATEDIR_DEFAULT
);
199 static const char *ga_log_level_str(GLogLevelFlags level
)
201 switch (level
& G_LOG_LEVEL_MASK
) {
202 case G_LOG_LEVEL_ERROR
:
204 case G_LOG_LEVEL_CRITICAL
:
206 case G_LOG_LEVEL_WARNING
:
208 case G_LOG_LEVEL_MESSAGE
:
210 case G_LOG_LEVEL_INFO
:
212 case G_LOG_LEVEL_DEBUG
:
219 bool ga_logging_enabled(GAState
*s
)
221 return s
->logging_enabled
;
224 void ga_disable_logging(GAState
*s
)
226 s
->logging_enabled
= false;
229 void ga_enable_logging(GAState
*s
)
231 s
->logging_enabled
= true;
234 static void ga_log(const gchar
*domain
, GLogLevelFlags level
,
235 const gchar
*msg
, gpointer opaque
)
239 const char *level_str
= ga_log_level_str(level
);
241 if (!ga_logging_enabled(s
)) {
245 level
&= G_LOG_LEVEL_MASK
;
247 if (domain
&& strcmp(domain
, "syslog") == 0) {
248 syslog(LOG_INFO
, "%s: %s", level_str
, msg
);
249 } else if (level
& s
->log_level
) {
251 if (level
& s
->log_level
) {
253 g_get_current_time(&time
);
255 "%lu.%lu: %s: %s\n", time
.tv_sec
, time
.tv_usec
, level_str
, msg
);
260 void ga_set_response_delimited(GAState
*s
)
262 s
->delimit_response
= true;
265 static FILE *ga_open_logfile(const char *logfile
)
269 f
= fopen(logfile
, "a");
274 qemu_set_cloexec(fileno(f
));
279 static bool ga_open_pidfile(const char *pidfile
)
284 pidfd
= qemu_open(pidfile
, O_CREAT
|O_WRONLY
, S_IRUSR
|S_IWUSR
);
285 if (pidfd
== -1 || lockf(pidfd
, F_TLOCK
, 0)) {
286 g_critical("Cannot lock pid file, %s", strerror(errno
));
293 if (ftruncate(pidfd
, 0)) {
294 g_critical("Failed to truncate pid file");
297 snprintf(pidstr
, sizeof(pidstr
), "%d\n", getpid());
298 if (write(pidfd
, pidstr
, strlen(pidstr
)) != strlen(pidstr
)) {
299 g_critical("Failed to write pid file");
303 /* keep pidfile open & locked forever */
312 static bool ga_open_pidfile(const char *pidfile
)
318 static gint
ga_strcmp(gconstpointer str1
, gconstpointer str2
)
320 return strcmp(str1
, str2
);
323 /* disable commands that aren't safe for fsfreeze */
324 static void ga_disable_non_whitelisted(void)
326 char **list_head
, **list
;
330 list_head
= list
= qmp_get_command_list();
331 while (*list
!= NULL
) {
334 while (ga_freeze_whitelist
[i
] != NULL
) {
335 if (strcmp(*list
, ga_freeze_whitelist
[i
]) == 0) {
341 g_debug("disabling command: %s", *list
);
342 qmp_disable_command(*list
);
350 /* [re-]enable all commands, except those explicitly blacklisted by user */
351 static void ga_enable_non_blacklisted(GList
*blacklist
)
353 char **list_head
, **list
;
355 list_head
= list
= qmp_get_command_list();
356 while (*list
!= NULL
) {
357 if (g_list_find_custom(blacklist
, *list
, ga_strcmp
) == NULL
&&
358 !qmp_command_is_enabled(*list
)) {
359 g_debug("enabling command: %s", *list
);
360 qmp_enable_command(*list
);
368 static bool ga_create_file(const char *path
)
370 int fd
= open(path
, O_CREAT
| O_WRONLY
, S_IWUSR
| S_IRUSR
);
372 g_warning("unable to open/create file %s: %s", path
, strerror(errno
));
379 static bool ga_delete_file(const char *path
)
381 int ret
= unlink(path
);
383 g_warning("unable to delete file: %s: %s", path
, strerror(errno
));
390 bool ga_is_frozen(GAState
*s
)
395 void ga_set_frozen(GAState
*s
)
397 if (ga_is_frozen(s
)) {
400 /* disable all non-whitelisted (for frozen state) commands */
401 ga_disable_non_whitelisted();
402 g_warning("disabling logging due to filesystem freeze");
403 ga_disable_logging(s
);
405 if (!ga_create_file(s
->state_filepath_isfrozen
)) {
406 g_warning("unable to create %s, fsfreeze may not function properly",
407 s
->state_filepath_isfrozen
);
411 void ga_unset_frozen(GAState
*s
)
413 if (!ga_is_frozen(s
)) {
417 /* if we delayed creation/opening of pid/log files due to being
418 * in a frozen state at start up, do it now
420 if (s
->deferred_options
.log_filepath
) {
421 s
->log_file
= ga_open_logfile(s
->deferred_options
.log_filepath
);
423 s
->log_file
= stderr
;
425 s
->deferred_options
.log_filepath
= NULL
;
427 ga_enable_logging(s
);
428 g_warning("logging re-enabled due to filesystem unfreeze");
429 if (s
->deferred_options
.pid_filepath
) {
430 if (!ga_open_pidfile(s
->deferred_options
.pid_filepath
)) {
431 g_warning("failed to create/open pid file");
433 s
->deferred_options
.pid_filepath
= NULL
;
436 /* enable all disabled, non-blacklisted commands */
437 ga_enable_non_blacklisted(s
->blacklist
);
439 if (!ga_delete_file(s
->state_filepath_isfrozen
)) {
440 g_warning("unable to delete %s, fsfreeze may not function properly",
441 s
->state_filepath_isfrozen
);
445 #ifdef CONFIG_FSFREEZE
446 const char *ga_fsfreeze_hook(GAState
*s
)
448 return s
->fsfreeze_hook
;
452 static void become_daemon(const char *pidfile
)
466 if (!ga_open_pidfile(pidfile
)) {
467 g_critical("failed to create pidfile");
477 if ((chdir("/")) < 0) {
481 reopen_fd_to_null(STDIN_FILENO
);
482 reopen_fd_to_null(STDOUT_FILENO
);
483 reopen_fd_to_null(STDERR_FILENO
);
490 g_critical("failed to daemonize");
495 static int send_response(GAState
*s
, QObject
*payload
)
498 QString
*payload_qstr
, *response_qstr
;
501 g_assert(payload
&& s
->channel
);
503 payload_qstr
= qobject_to_json(payload
);
508 if (s
->delimit_response
) {
509 s
->delimit_response
= false;
510 response_qstr
= qstring_new();
511 qstring_append_chr(response_qstr
, QGA_SENTINEL_BYTE
);
512 qstring_append(response_qstr
, qstring_get_str(payload_qstr
));
513 QDECREF(payload_qstr
);
515 response_qstr
= payload_qstr
;
518 qstring_append_chr(response_qstr
, '\n');
519 buf
= qstring_get_str(response_qstr
);
520 status
= ga_channel_write_all(s
->channel
, buf
, strlen(buf
));
521 QDECREF(response_qstr
);
522 if (status
!= G_IO_STATUS_NORMAL
) {
529 static void process_command(GAState
*s
, QDict
*req
)
535 g_debug("processing command");
536 rsp
= qmp_dispatch(QOBJECT(req
));
538 ret
= send_response(s
, rsp
);
540 g_warning("error sending response: %s", strerror(ret
));
546 /* handle requests/control events coming in over the channel */
547 static void process_event(JSONMessageParser
*parser
, QList
*tokens
)
549 GAState
*s
= container_of(parser
, GAState
, parser
);
555 g_assert(s
&& parser
);
557 g_debug("process_event: called");
558 obj
= json_parser_parse_err(tokens
, NULL
, &err
);
559 if (err
|| !obj
|| qobject_type(obj
) != QTYPE_QDICT
) {
563 g_warning("failed to parse event: unknown error");
564 error_set(&err
, QERR_JSON_PARSING
);
566 g_warning("failed to parse event: %s", error_get_pretty(err
));
568 qdict_put_obj(qdict
, "error", qmp_build_error_object(err
));
571 qdict
= qobject_to_qdict(obj
);
576 /* handle host->guest commands */
577 if (qdict_haskey(qdict
, "execute")) {
578 process_command(s
, qdict
);
580 if (!qdict_haskey(qdict
, "error")) {
583 g_warning("unrecognized payload format");
584 error_set(&err
, QERR_UNSUPPORTED
);
585 qdict_put_obj(qdict
, "error", qmp_build_error_object(err
));
588 ret
= send_response(s
, QOBJECT(qdict
));
590 g_warning("error sending error response: %s", strerror(ret
));
597 /* false return signals GAChannel to close the current client connection */
598 static gboolean
channel_event_cb(GIOCondition condition
, gpointer data
)
601 gchar buf
[QGA_READ_COUNT_DEFAULT
+1];
604 GIOStatus status
= ga_channel_read(s
->channel
, buf
, QGA_READ_COUNT_DEFAULT
, &count
);
606 g_warning("error reading channel: %s", err
->message
);
611 case G_IO_STATUS_ERROR
:
612 g_warning("error reading channel");
614 case G_IO_STATUS_NORMAL
:
616 g_debug("read data, count: %d, data: %s", (int)count
, buf
);
617 json_message_parser_feed(&s
->parser
, (char *)buf
, (int)count
);
619 case G_IO_STATUS_EOF
:
620 g_debug("received EOF");
625 case G_IO_STATUS_AGAIN
:
626 /* virtio causes us to spin here when no process is attached to
627 * host-side chardev. sleep a bit to mitigate this
634 g_warning("unknown channel read status, closing");
640 static gboolean
channel_init(GAState
*s
, const gchar
*method
, const gchar
*path
)
642 GAChannelMethod channel_method
;
644 if (method
== NULL
) {
645 method
= "virtio-serial";
649 if (strcmp(method
, "virtio-serial") != 0) {
650 g_critical("must specify a path for this channel");
653 /* try the default path for the virtio-serial port */
654 path
= QGA_VIRTIO_PATH_DEFAULT
;
657 if (strcmp(method
, "virtio-serial") == 0) {
658 s
->virtio
= true; /* virtio requires special handling in some cases */
659 channel_method
= GA_CHANNEL_VIRTIO_SERIAL
;
660 } else if (strcmp(method
, "isa-serial") == 0) {
661 channel_method
= GA_CHANNEL_ISA_SERIAL
;
662 } else if (strcmp(method
, "unix-listen") == 0) {
663 channel_method
= GA_CHANNEL_UNIX_LISTEN
;
665 g_critical("unsupported channel method/type: %s", method
);
669 s
->channel
= ga_channel_new(channel_method
, path
, channel_event_cb
, s
);
671 g_critical("failed to create guest agent channel");
679 DWORD WINAPI
service_ctrl_handler(DWORD ctrl
, DWORD type
, LPVOID data
,
682 DWORD ret
= NO_ERROR
;
683 GAService
*service
= &ga_state
->service
;
687 case SERVICE_CONTROL_STOP
:
688 case SERVICE_CONTROL_SHUTDOWN
:
689 quit_handler(SIGTERM
);
690 service
->status
.dwCurrentState
= SERVICE_STOP_PENDING
;
691 SetServiceStatus(service
->status_handle
, &service
->status
);
695 ret
= ERROR_CALL_NOT_IMPLEMENTED
;
700 VOID WINAPI
service_main(DWORD argc
, TCHAR
*argv
[])
702 GAService
*service
= &ga_state
->service
;
704 service
->status_handle
= RegisterServiceCtrlHandlerEx(QGA_SERVICE_NAME
,
705 service_ctrl_handler
, NULL
);
707 if (service
->status_handle
== 0) {
708 g_critical("Failed to register extended requests function!\n");
712 service
->status
.dwServiceType
= SERVICE_WIN32
;
713 service
->status
.dwCurrentState
= SERVICE_RUNNING
;
714 service
->status
.dwControlsAccepted
= SERVICE_ACCEPT_STOP
| SERVICE_ACCEPT_SHUTDOWN
;
715 service
->status
.dwWin32ExitCode
= NO_ERROR
;
716 service
->status
.dwServiceSpecificExitCode
= NO_ERROR
;
717 service
->status
.dwCheckPoint
= 0;
718 service
->status
.dwWaitHint
= 0;
719 SetServiceStatus(service
->status_handle
, &service
->status
);
721 g_main_loop_run(ga_state
->main_loop
);
723 service
->status
.dwCurrentState
= SERVICE_STOPPED
;
724 SetServiceStatus(service
->status_handle
, &service
->status
);
728 int main(int argc
, char **argv
)
730 const char *sopt
= "hVvdm:p:l:f:F::b:s:t:";
731 const char *method
= NULL
, *path
= NULL
;
732 const char *log_filepath
= NULL
;
733 const char *pid_filepath
= QGA_PIDFILE_DEFAULT
;
734 #ifdef CONFIG_FSFREEZE
735 const char *fsfreeze_hook
= NULL
;
737 const char *state_dir
= QGA_STATEDIR_DEFAULT
;
739 const char *service
= NULL
;
741 const struct option lopt
[] = {
742 { "help", 0, NULL
, 'h' },
743 { "version", 0, NULL
, 'V' },
744 { "logfile", 1, NULL
, 'l' },
745 { "pidfile", 1, NULL
, 'f' },
746 #ifdef CONFIG_FSFREEZE
747 { "fsfreeze-hook", 2, NULL
, 'F' },
749 { "verbose", 0, NULL
, 'v' },
750 { "method", 1, NULL
, 'm' },
751 { "path", 1, NULL
, 'p' },
752 { "daemonize", 0, NULL
, 'd' },
753 { "blacklist", 1, NULL
, 'b' },
755 { "service", 1, NULL
, 's' },
757 { "statedir", 1, NULL
, 't' },
760 int opt_ind
= 0, ch
, daemonize
= 0, i
, j
, len
;
761 GLogLevelFlags log_level
= G_LOG_LEVEL_ERROR
| G_LOG_LEVEL_CRITICAL
;
762 GList
*blacklist
= NULL
;
765 module_call_init(MODULE_INIT_QAPI
);
767 while ((ch
= getopt_long(argc
, argv
, sopt
, lopt
, &opt_ind
)) != -1) {
776 log_filepath
= optarg
;
779 pid_filepath
= optarg
;
781 #ifdef CONFIG_FSFREEZE
783 fsfreeze_hook
= optarg
? optarg
: QGA_FSFREEZE_HOOK_DEFAULT
;
790 /* enable all log levels */
791 log_level
= G_LOG_LEVEL_MASK
;
794 printf("QEMU Guest Agent %s\n", QEMU_VERSION
);
800 char **list_head
, **list
;
801 if (is_help_option(optarg
)) {
802 list_head
= list
= qmp_get_command_list();
803 while (*list
!= NULL
) {
804 printf("%s\n", *list
);
811 for (j
= 0, i
= 0, len
= strlen(optarg
); i
< len
; i
++) {
812 if (optarg
[i
] == ',') {
814 blacklist
= g_list_append(blacklist
, &optarg
[j
]);
819 blacklist
= g_list_append(blacklist
, &optarg
[j
]);
826 if (strcmp(service
, "install") == 0) {
827 return ga_install_service(path
, log_filepath
);
828 } else if (strcmp(service
, "uninstall") == 0) {
829 return ga_uninstall_service();
831 printf("Unknown service command.\n");
840 g_print("Unknown option, try '%s --help' for more information.\n",
846 s
= g_malloc0(sizeof(GAState
));
847 s
->log_level
= log_level
;
848 s
->log_file
= stderr
;
849 #ifdef CONFIG_FSFREEZE
850 s
->fsfreeze_hook
= fsfreeze_hook
;
852 g_log_set_default_handler(ga_log
, s
);
853 g_log_set_fatal_mask(NULL
, G_LOG_LEVEL_ERROR
);
854 ga_enable_logging(s
);
855 s
->state_filepath_isfrozen
= g_strdup_printf("%s/qga.state.isfrozen",
859 /* check if a previous instance of qemu-ga exited with filesystems' state
860 * marked as frozen. this could be a stale value (a non-qemu-ga process
861 * or reboot may have since unfrozen them), but better to require an
862 * uneeded unfreeze than to risk hanging on start-up
865 if (stat(s
->state_filepath_isfrozen
, &st
) == -1) {
866 /* it's okay if the file doesn't exist, but if we can't access for
867 * some other reason, such as permissions, there's a configuration
868 * that needs to be addressed. so just bail now before we get into
871 if (errno
!= ENOENT
) {
872 g_critical("unable to access state file at path %s: %s",
873 s
->state_filepath_isfrozen
, strerror(errno
));
877 g_warning("previous instance appears to have exited with frozen"
878 " filesystems. deferring logging/pidfile creation and"
879 " disabling non-fsfreeze-safe commands until"
880 " guest-fsfreeze-thaw is issued, or filesystems are"
881 " manually unfrozen and the file %s is removed",
882 s
->state_filepath_isfrozen
);
887 if (ga_is_frozen(s
)) {
889 /* delay opening/locking of pidfile till filesystem are unfrozen */
890 s
->deferred_options
.pid_filepath
= pid_filepath
;
894 /* delay opening the log file till filesystems are unfrozen */
895 s
->deferred_options
.log_filepath
= log_filepath
;
897 ga_disable_logging(s
);
898 ga_disable_non_whitelisted();
901 become_daemon(pid_filepath
);
904 FILE *log_file
= ga_open_logfile(log_filepath
);
906 g_critical("unable to open specified log file: %s",
910 s
->log_file
= log_file
;
915 s
->blacklist
= blacklist
;
917 g_debug("disabling command: %s", (char *)blacklist
->data
);
918 qmp_disable_command(blacklist
->data
);
919 blacklist
= g_list_next(blacklist
);
922 s
->command_state
= ga_command_state_new();
923 ga_command_state_init(s
, s
->command_state
);
924 ga_command_state_init_all(s
->command_state
);
925 json_message_parser_init(&s
->parser
, process_event
);
928 if (!register_signal_handlers()) {
929 g_critical("failed to register signal handlers");
934 s
->main_loop
= g_main_loop_new(NULL
, false);
935 if (!channel_init(ga_state
, method
, path
)) {
936 g_critical("failed to initialize guest agent channel");
940 g_main_loop_run(ga_state
->main_loop
);
943 SERVICE_TABLE_ENTRY service_table
[] = {
944 { (char *)QGA_SERVICE_NAME
, service_main
}, { NULL
, NULL
} };
945 StartServiceCtrlDispatcher(service_table
);
947 g_main_loop_run(ga_state
->main_loop
);
951 ga_command_state_cleanup_all(ga_state
->command_state
);
952 ga_channel_free(ga_state
->channel
);
955 unlink(pid_filepath
);
961 unlink(pid_filepath
);