1 /* 2 * QEMU Guest Agent 3 * 4 * Copyright IBM Corp. 2011 5 * 6 * Authors: 7 * Adam Litke <aglitke@linux.vnet.ibm.com> 8 * Michael Roth <mdroth@linux.vnet.ibm.com> 9 * 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. 12 */ 13 14 #include "qemu/osdep.h" 15 #include <getopt.h> 16 #include <glib/gstdio.h> 17 #ifndef _WIN32 18 #include <syslog.h> 19 #include <sys/wait.h> 20 #endif 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" 29 #include "channel.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" 35 #ifdef _WIN32 36 #include <dbt.h> 37 #include "qga/service-win32.h" 38 #include "qga/vss-win32.h" 39 #endif 40 #ifdef __linux__ 41 #include <linux/fs.h> 42 #ifdef FIFREEZE 43 #define CONFIG_FSFREEZE 44 #endif 45 #endif 46 47 #ifndef _WIN32 48 #define QGA_VIRTIO_PATH_DEFAULT "/dev/virtio-ports/org.qemu.guest_agent.0" 49 #define QGA_STATE_RELATIVE_DIR "run" 50 #define QGA_SERIAL_PATH_DEFAULT "/dev/ttyS0" 51 #else 52 #define QGA_VIRTIO_PATH_DEFAULT "\\\\.\\Global\\org.qemu.guest_agent.0" 53 #define QGA_STATE_RELATIVE_DIR "qemu-ga" 54 #define QGA_SERIAL_PATH_DEFAULT "COM1" 55 #endif 56 #ifdef CONFIG_FSFREEZE 57 #define QGA_FSFREEZE_HOOK_DEFAULT CONFIG_QEMU_CONFDIR "/fsfreeze-hook" 58 #endif 59 #define QGA_SENTINEL_BYTE 0xFF 60 #define QGA_CONF_DEFAULT CONFIG_QEMU_CONFDIR G_DIR_SEPARATOR_S "qemu-ga.conf" 61 #define QGA_RETRY_INTERVAL 5 62 63 static struct { 64 const char *state_dir; 65 const char *pidfile; 66 } dfl_pathnames; 67 68 typedef struct GAPersistentState { 69 #define QGA_PSTATE_DEFAULT_FD_COUNTER 1000 70 int64_t fd_counter; 71 } GAPersistentState; 72 73 typedef struct GAConfig GAConfig; 74 75 struct GAState { 76 JSONMessageParser parser; 77 GMainLoop *main_loop; 78 GAChannel *channel; 79 bool virtio; /* fastpath to check for virtio to deal with poll() quirks */ 80 GACommandState *command_state; 81 GLogLevelFlags log_level; 82 FILE *log_file; 83 bool logging_enabled; 84 #ifdef _WIN32 85 GAService service; 86 HANDLE wakeup_event; 87 #endif 88 bool delimit_response; 89 bool frozen; 90 GList *blacklist; 91 char *state_filepath_isfrozen; 92 struct { 93 const char *log_filepath; 94 const char *pid_filepath; 95 } deferred_options; 96 #ifdef CONFIG_FSFREEZE 97 const char *fsfreeze_hook; 98 #endif 99 gchar *pstate_filepath; 100 GAPersistentState pstate; 101 GAConfig *config; 102 int socket_activation; 103 bool force_exit; 104 }; 105 106 struct GAState *ga_state; 107 QmpCommandList ga_commands; 108 109 /* commands that are safe to issue while filesystems are frozen */ 110 static const char *ga_freeze_whitelist[] = { 111 "guest-ping", 112 "guest-info", 113 "guest-sync", 114 "guest-sync-delimited", 115 "guest-fsfreeze-status", 116 "guest-fsfreeze-thaw", 117 NULL 118 }; 119 120 #ifdef _WIN32 121 DWORD WINAPI service_ctrl_handler(DWORD ctrl, DWORD type, LPVOID data, 122 LPVOID ctx); 123 DWORD WINAPI handle_serial_device_events(DWORD type, LPVOID data); 124 VOID WINAPI service_main(DWORD argc, TCHAR *argv[]); 125 #endif 126 static int run_agent(GAState *s); 127 static void stop_agent(GAState *s, bool requested); 128 129 static void 130 init_dfl_pathnames(void) 131 { 132 g_assert(dfl_pathnames.state_dir == NULL); 133 g_assert(dfl_pathnames.pidfile == NULL); 134 dfl_pathnames.state_dir = qemu_get_local_state_pathname( 135 QGA_STATE_RELATIVE_DIR); 136 dfl_pathnames.pidfile = qemu_get_local_state_pathname( 137 QGA_STATE_RELATIVE_DIR G_DIR_SEPARATOR_S "qemu-ga.pid"); 138 } 139 140 static void quit_handler(int sig) 141 { 142 /* if we're frozen, don't exit unless we're absolutely forced to, 143 * because it's basically impossible for graceful exit to complete 144 * unless all log/pid files are on unfreezable filesystems. there's 145 * also a very likely chance killing the agent before unfreezing 146 * the filesystems is a mistake (or will be viewed as one later). 147 * On Windows the freeze interval is limited to 10 seconds, so 148 * we should quit, but first we should wait for the timeout, thaw 149 * the filesystem and quit. 150 */ 151 if (ga_is_frozen(ga_state)) { 152 #ifdef _WIN32 153 int i = 0; 154 Error *err = NULL; 155 HANDLE hEventTimeout; 156 157 g_debug("Thawing filesystems before exiting"); 158 159 hEventTimeout = OpenEvent(EVENT_ALL_ACCESS, FALSE, EVENT_NAME_TIMEOUT); 160 if (hEventTimeout) { 161 WaitForSingleObject(hEventTimeout, 0); 162 CloseHandle(hEventTimeout); 163 } 164 qga_vss_fsfreeze(&i, false, NULL, &err); 165 if (err) { 166 g_debug("Error unfreezing filesystems prior to exiting: %s", 167 error_get_pretty(err)); 168 error_free(err); 169 } 170 #else 171 return; 172 #endif 173 } 174 g_debug("received signal num %d, quitting", sig); 175 176 stop_agent(ga_state, true); 177 } 178 179 #ifndef _WIN32 180 static gboolean register_signal_handlers(void) 181 { 182 struct sigaction sigact; 183 int ret; 184 185 memset(&sigact, 0, sizeof(struct sigaction)); 186 sigact.sa_handler = quit_handler; 187 188 ret = sigaction(SIGINT, &sigact, NULL); 189 if (ret == -1) { 190 g_error("error configuring signal handler: %s", strerror(errno)); 191 } 192 ret = sigaction(SIGTERM, &sigact, NULL); 193 if (ret == -1) { 194 g_error("error configuring signal handler: %s", strerror(errno)); 195 } 196 197 sigact.sa_handler = SIG_IGN; 198 if (sigaction(SIGPIPE, &sigact, NULL) != 0) { 199 g_error("error configuring SIGPIPE signal handler: %s", 200 strerror(errno)); 201 } 202 203 return true; 204 } 205 206 /* TODO: use this in place of all post-fork() fclose(std*) callers */ 207 void reopen_fd_to_null(int fd) 208 { 209 int nullfd; 210 211 nullfd = open("/dev/null", O_RDWR); 212 if (nullfd < 0) { 213 return; 214 } 215 216 dup2(nullfd, fd); 217 218 if (nullfd != fd) { 219 close(nullfd); 220 } 221 } 222 #endif 223 224 static void usage(const char *cmd) 225 { 226 printf( 227 "Usage: %s [-m <method> -p <path>] [<options>]\n" 228 "QEMU Guest Agent " QEMU_FULL_VERSION "\n" 229 QEMU_COPYRIGHT "\n" 230 "\n" 231 " -m, --method transport method: one of unix-listen, virtio-serial,\n" 232 " isa-serial, or vsock-listen (virtio-serial is the default)\n" 233 " -p, --path device/socket path (the default for virtio-serial is:\n" 234 " %s,\n" 235 " the default for isa-serial is:\n" 236 " %s).\n" 237 " Socket addresses for vsock-listen are written as\n" 238 " <cid>:<port>.\n" 239 " -l, --logfile set logfile path, logs to stderr by default\n" 240 " -f, --pidfile specify pidfile (default is %s)\n" 241 #ifdef CONFIG_FSFREEZE 242 " -F, --fsfreeze-hook\n" 243 " enable fsfreeze hook. Accepts an optional argument that\n" 244 " specifies script to run on freeze/thaw. Script will be\n" 245 " called with 'freeze'/'thaw' arguments accordingly.\n" 246 " (default is %s)\n" 247 " If using -F with an argument, do not follow -F with a\n" 248 " space.\n" 249 " (for example: -F/var/run/fsfreezehook.sh)\n" 250 #endif 251 " -t, --statedir specify dir to store state information (absolute paths\n" 252 " only, default is %s)\n" 253 " -v, --verbose log extra debugging information\n" 254 " -V, --version print version information and exit\n" 255 " -d, --daemonize become a daemon\n" 256 #ifdef _WIN32 257 " -s, --service service commands: install, uninstall, vss-install, vss-uninstall\n" 258 #endif 259 " -b, --blacklist comma-separated list of RPCs to disable (no spaces, \"?\"\n" 260 " to list available RPCs)\n" 261 " -D, --dump-conf dump a qemu-ga config file based on current config\n" 262 " options / command-line parameters to stdout\n" 263 " -r, --retry-path attempt re-opening path if it's unavailable or closed\n" 264 " due to an error which may be recoverable in the future\n" 265 " (virtio-serial driver re-install, serial device hot\n" 266 " plug/unplug, etc.)\n" 267 " -h, --help display this help and exit\n" 268 "\n" 269 QEMU_HELP_BOTTOM "\n" 270 , cmd, QGA_VIRTIO_PATH_DEFAULT, QGA_SERIAL_PATH_DEFAULT, 271 dfl_pathnames.pidfile, 272 #ifdef CONFIG_FSFREEZE 273 QGA_FSFREEZE_HOOK_DEFAULT, 274 #endif 275 dfl_pathnames.state_dir); 276 } 277 278 static const char *ga_log_level_str(GLogLevelFlags level) 279 { 280 switch (level & G_LOG_LEVEL_MASK) { 281 case G_LOG_LEVEL_ERROR: 282 return "error"; 283 case G_LOG_LEVEL_CRITICAL: 284 return "critical"; 285 case G_LOG_LEVEL_WARNING: 286 return "warning"; 287 case G_LOG_LEVEL_MESSAGE: 288 return "message"; 289 case G_LOG_LEVEL_INFO: 290 return "info"; 291 case G_LOG_LEVEL_DEBUG: 292 return "debug"; 293 default: 294 return "user"; 295 } 296 } 297 298 bool ga_logging_enabled(GAState *s) 299 { 300 return s->logging_enabled; 301 } 302 303 void ga_disable_logging(GAState *s) 304 { 305 s->logging_enabled = false; 306 } 307 308 void ga_enable_logging(GAState *s) 309 { 310 s->logging_enabled = true; 311 } 312 313 static void ga_log(const gchar *domain, GLogLevelFlags level, 314 const gchar *msg, gpointer opaque) 315 { 316 GAState *s = opaque; 317 const char *level_str = ga_log_level_str(level); 318 319 if (!ga_logging_enabled(s)) { 320 return; 321 } 322 323 level &= G_LOG_LEVEL_MASK; 324 #ifndef _WIN32 325 if (g_strcmp0(domain, "syslog") == 0) { 326 syslog(LOG_INFO, "%s: %s", level_str, msg); 327 } else if (level & s->log_level) { 328 #else 329 if (level & s->log_level) { 330 #endif 331 gint64 t = g_get_real_time(); 332 fprintf(s->log_file, 333 "%" G_GINT64_FORMAT ".%" G_GINT64_FORMAT 334 ": %s: %s\n", t / G_USEC_PER_SEC, t % G_USEC_PER_SEC, 335 level_str, msg); 336 fflush(s->log_file); 337 } 338 } 339 340 void ga_set_response_delimited(GAState *s) 341 { 342 s->delimit_response = true; 343 } 344 345 static FILE *ga_open_logfile(const char *logfile) 346 { 347 FILE *f; 348 349 f = fopen(logfile, "a"); 350 if (!f) { 351 return NULL; 352 } 353 354 qemu_set_cloexec(fileno(f)); 355 return f; 356 } 357 358 static gint ga_strcmp(gconstpointer str1, gconstpointer str2) 359 { 360 return strcmp(str1, str2); 361 } 362 363 /* disable commands that aren't safe for fsfreeze */ 364 static void ga_disable_non_whitelisted(const QmpCommand *cmd, void *opaque) 365 { 366 bool whitelisted = false; 367 int i = 0; 368 const char *name = qmp_command_name(cmd); 369 370 while (ga_freeze_whitelist[i] != NULL) { 371 if (strcmp(name, ga_freeze_whitelist[i]) == 0) { 372 whitelisted = true; 373 } 374 i++; 375 } 376 if (!whitelisted) { 377 g_debug("disabling command: %s", name); 378 qmp_disable_command(&ga_commands, name, "the agent is in frozen state"); 379 } 380 } 381 382 /* [re-]enable all commands, except those explicitly blacklisted by user */ 383 static void ga_enable_non_blacklisted(const QmpCommand *cmd, void *opaque) 384 { 385 GList *blacklist = opaque; 386 const char *name = qmp_command_name(cmd); 387 388 if (g_list_find_custom(blacklist, name, ga_strcmp) == NULL && 389 !qmp_command_is_enabled(cmd)) { 390 g_debug("enabling command: %s", name); 391 qmp_enable_command(&ga_commands, name); 392 } 393 } 394 395 static bool ga_create_file(const char *path) 396 { 397 int fd = open(path, O_CREAT | O_WRONLY, S_IWUSR | S_IRUSR); 398 if (fd == -1) { 399 g_warning("unable to open/create file %s: %s", path, strerror(errno)); 400 return false; 401 } 402 close(fd); 403 return true; 404 } 405 406 static bool ga_delete_file(const char *path) 407 { 408 int ret = unlink(path); 409 if (ret == -1) { 410 g_warning("unable to delete file: %s: %s", path, strerror(errno)); 411 return false; 412 } 413 414 return true; 415 } 416 417 bool ga_is_frozen(GAState *s) 418 { 419 return s->frozen; 420 } 421 422 void ga_set_frozen(GAState *s) 423 { 424 if (ga_is_frozen(s)) { 425 return; 426 } 427 /* disable all non-whitelisted (for frozen state) commands */ 428 qmp_for_each_command(&ga_commands, ga_disable_non_whitelisted, NULL); 429 g_warning("disabling logging due to filesystem freeze"); 430 ga_disable_logging(s); 431 s->frozen = true; 432 if (!ga_create_file(s->state_filepath_isfrozen)) { 433 g_warning("unable to create %s, fsfreeze may not function properly", 434 s->state_filepath_isfrozen); 435 } 436 } 437 438 void ga_unset_frozen(GAState *s) 439 { 440 if (!ga_is_frozen(s)) { 441 return; 442 } 443 444 /* if we delayed creation/opening of pid/log files due to being 445 * in a frozen state at start up, do it now 446 */ 447 if (s->deferred_options.log_filepath) { 448 s->log_file = ga_open_logfile(s->deferred_options.log_filepath); 449 if (!s->log_file) { 450 s->log_file = stderr; 451 } 452 s->deferred_options.log_filepath = NULL; 453 } 454 ga_enable_logging(s); 455 g_warning("logging re-enabled due to filesystem unfreeze"); 456 if (s->deferred_options.pid_filepath) { 457 Error *err = NULL; 458 459 if (!qemu_write_pidfile(s->deferred_options.pid_filepath, &err)) { 460 g_warning("%s", error_get_pretty(err)); 461 error_free(err); 462 } 463 s->deferred_options.pid_filepath = NULL; 464 } 465 466 /* enable all disabled, non-blacklisted commands */ 467 qmp_for_each_command(&ga_commands, ga_enable_non_blacklisted, s->blacklist); 468 s->frozen = false; 469 if (!ga_delete_file(s->state_filepath_isfrozen)) { 470 g_warning("unable to delete %s, fsfreeze may not function properly", 471 s->state_filepath_isfrozen); 472 } 473 } 474 475 #ifdef CONFIG_FSFREEZE 476 const char *ga_fsfreeze_hook(GAState *s) 477 { 478 return s->fsfreeze_hook; 479 } 480 #endif 481 482 static void become_daemon(const char *pidfile) 483 { 484 #ifndef _WIN32 485 pid_t pid, sid; 486 487 pid = fork(); 488 if (pid < 0) { 489 exit(EXIT_FAILURE); 490 } 491 if (pid > 0) { 492 exit(EXIT_SUCCESS); 493 } 494 495 if (pidfile) { 496 Error *err = NULL; 497 498 if (!qemu_write_pidfile(pidfile, &err)) { 499 g_critical("%s", error_get_pretty(err)); 500 error_free(err); 501 exit(EXIT_FAILURE); 502 } 503 } 504 505 umask(S_IRWXG | S_IRWXO); 506 sid = setsid(); 507 if (sid < 0) { 508 goto fail; 509 } 510 if ((chdir("/")) < 0) { 511 goto fail; 512 } 513 514 reopen_fd_to_null(STDIN_FILENO); 515 reopen_fd_to_null(STDOUT_FILENO); 516 reopen_fd_to_null(STDERR_FILENO); 517 return; 518 519 fail: 520 if (pidfile) { 521 unlink(pidfile); 522 } 523 g_critical("failed to daemonize"); 524 exit(EXIT_FAILURE); 525 #endif 526 } 527 528 static int send_response(GAState *s, const QDict *rsp) 529 { 530 GString *response; 531 GIOStatus status; 532 533 g_assert(s->channel); 534 535 if (!rsp) { 536 return 0; 537 } 538 539 response = qobject_to_json(QOBJECT(rsp)); 540 if (!response) { 541 return -EINVAL; 542 } 543 544 if (s->delimit_response) { 545 s->delimit_response = false; 546 g_string_prepend_c(response, QGA_SENTINEL_BYTE); 547 } 548 549 g_string_append_c(response, '\n'); 550 status = ga_channel_write_all(s->channel, response->str, response->len); 551 g_string_free(response, true); 552 if (status != G_IO_STATUS_NORMAL) { 553 return -EIO; 554 } 555 556 return 0; 557 } 558 559 /* handle requests/control events coming in over the channel */ 560 static void process_event(void *opaque, QObject *obj, Error *err) 561 { 562 GAState *s = opaque; 563 QDict *rsp; 564 int ret; 565 566 g_debug("process_event: called"); 567 assert(!obj != !err); 568 if (err) { 569 rsp = qmp_error_response(err); 570 goto end; 571 } 572 573 g_debug("processing command"); 574 rsp = qmp_dispatch(&ga_commands, obj, false, NULL); 575 576 end: 577 ret = send_response(s, rsp); 578 if (ret < 0) { 579 g_warning("error sending error response: %s", strerror(-ret)); 580 } 581 qobject_unref(rsp); 582 qobject_unref(obj); 583 } 584 585 /* false return signals GAChannel to close the current client connection */ 586 static gboolean channel_event_cb(GIOCondition condition, gpointer data) 587 { 588 GAState *s = data; 589 gchar buf[QGA_READ_COUNT_DEFAULT + 1]; 590 gsize count; 591 GIOStatus status = ga_channel_read(s->channel, buf, QGA_READ_COUNT_DEFAULT, &count); 592 switch (status) { 593 case G_IO_STATUS_ERROR: 594 g_warning("error reading channel"); 595 stop_agent(s, false); 596 return false; 597 case G_IO_STATUS_NORMAL: 598 buf[count] = 0; 599 g_debug("read data, count: %d, data: %s", (int)count, buf); 600 json_message_parser_feed(&s->parser, (char *)buf, (int)count); 601 break; 602 case G_IO_STATUS_EOF: 603 g_debug("received EOF"); 604 if (!s->virtio) { 605 return false; 606 } 607 /* fall through */ 608 case G_IO_STATUS_AGAIN: 609 /* virtio causes us to spin here when no process is attached to 610 * host-side chardev. sleep a bit to mitigate this 611 */ 612 if (s->virtio) { 613 g_usleep(G_USEC_PER_SEC / 10); 614 } 615 return true; 616 default: 617 g_warning("unknown channel read status, closing"); 618 return false; 619 } 620 return true; 621 } 622 623 static gboolean channel_init(GAState *s, const gchar *method, const gchar *path, 624 int listen_fd) 625 { 626 GAChannelMethod channel_method; 627 628 if (strcmp(method, "virtio-serial") == 0) { 629 s->virtio = true; /* virtio requires special handling in some cases */ 630 channel_method = GA_CHANNEL_VIRTIO_SERIAL; 631 } else if (strcmp(method, "isa-serial") == 0) { 632 channel_method = GA_CHANNEL_ISA_SERIAL; 633 } else if (strcmp(method, "unix-listen") == 0) { 634 channel_method = GA_CHANNEL_UNIX_LISTEN; 635 } else if (strcmp(method, "vsock-listen") == 0) { 636 channel_method = GA_CHANNEL_VSOCK_LISTEN; 637 } else { 638 g_critical("unsupported channel method/type: %s", method); 639 return false; 640 } 641 642 s->channel = ga_channel_new(channel_method, path, listen_fd, 643 channel_event_cb, s); 644 if (!s->channel) { 645 g_critical("failed to create guest agent channel"); 646 return false; 647 } 648 649 return true; 650 } 651 652 #ifdef _WIN32 653 DWORD WINAPI handle_serial_device_events(DWORD type, LPVOID data) 654 { 655 DWORD ret = NO_ERROR; 656 PDEV_BROADCAST_HDR broadcast_header = (PDEV_BROADCAST_HDR)data; 657 658 if (broadcast_header->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE) { 659 switch (type) { 660 /* Device inserted */ 661 case DBT_DEVICEARRIVAL: 662 /* Start QEMU-ga's service */ 663 if (!SetEvent(ga_state->wakeup_event)) { 664 ret = GetLastError(); 665 } 666 break; 667 /* Device removed */ 668 case DBT_DEVICEQUERYREMOVE: 669 case DBT_DEVICEREMOVEPENDING: 670 case DBT_DEVICEREMOVECOMPLETE: 671 /* Stop QEMU-ga's service */ 672 if (!ResetEvent(ga_state->wakeup_event)) { 673 ret = GetLastError(); 674 } 675 break; 676 default: 677 ret = ERROR_CALL_NOT_IMPLEMENTED; 678 } 679 } 680 return ret; 681 } 682 683 DWORD WINAPI service_ctrl_handler(DWORD ctrl, DWORD type, LPVOID data, 684 LPVOID ctx) 685 { 686 DWORD ret = NO_ERROR; 687 GAService *service = &ga_state->service; 688 689 switch (ctrl) { 690 case SERVICE_CONTROL_STOP: 691 case SERVICE_CONTROL_SHUTDOWN: 692 quit_handler(SIGTERM); 693 SetEvent(ga_state->wakeup_event); 694 service->status.dwCurrentState = SERVICE_STOP_PENDING; 695 SetServiceStatus(service->status_handle, &service->status); 696 break; 697 case SERVICE_CONTROL_DEVICEEVENT: 698 handle_serial_device_events(type, data); 699 break; 700 701 default: 702 ret = ERROR_CALL_NOT_IMPLEMENTED; 703 } 704 return ret; 705 } 706 707 VOID WINAPI service_main(DWORD argc, TCHAR *argv[]) 708 { 709 GAService *service = &ga_state->service; 710 711 service->status_handle = RegisterServiceCtrlHandlerEx(QGA_SERVICE_NAME, 712 service_ctrl_handler, NULL); 713 714 if (service->status_handle == 0) { 715 g_critical("Failed to register extended requests function!\n"); 716 return; 717 } 718 719 service->status.dwServiceType = SERVICE_WIN32; 720 service->status.dwCurrentState = SERVICE_RUNNING; 721 service->status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN; 722 service->status.dwWin32ExitCode = NO_ERROR; 723 service->status.dwServiceSpecificExitCode = NO_ERROR; 724 service->status.dwCheckPoint = 0; 725 service->status.dwWaitHint = 0; 726 DEV_BROADCAST_DEVICEINTERFACE notification_filter; 727 ZeroMemory(¬ification_filter, sizeof(notification_filter)); 728 notification_filter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE; 729 notification_filter.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE); 730 notification_filter.dbcc_classguid = GUID_VIOSERIAL_PORT; 731 732 service->device_notification_handle = 733 RegisterDeviceNotification(service->status_handle, 734 ¬ification_filter, DEVICE_NOTIFY_SERVICE_HANDLE); 735 if (!service->device_notification_handle) { 736 g_critical("Failed to register device notification handle!\n"); 737 return; 738 } 739 SetServiceStatus(service->status_handle, &service->status); 740 741 run_agent(ga_state); 742 743 UnregisterDeviceNotification(service->device_notification_handle); 744 service->status.dwCurrentState = SERVICE_STOPPED; 745 SetServiceStatus(service->status_handle, &service->status); 746 } 747 #endif 748 749 static void set_persistent_state_defaults(GAPersistentState *pstate) 750 { 751 g_assert(pstate); 752 pstate->fd_counter = QGA_PSTATE_DEFAULT_FD_COUNTER; 753 } 754 755 static void persistent_state_from_keyfile(GAPersistentState *pstate, 756 GKeyFile *keyfile) 757 { 758 g_assert(pstate); 759 g_assert(keyfile); 760 /* if any fields are missing, either because the file was tampered with 761 * by agents of chaos, or because the field wasn't present at the time the 762 * file was created, the best we can ever do is start over with the default 763 * values. so load them now, and ignore any errors in accessing key-value 764 * pairs 765 */ 766 set_persistent_state_defaults(pstate); 767 768 if (g_key_file_has_key(keyfile, "global", "fd_counter", NULL)) { 769 pstate->fd_counter = 770 g_key_file_get_integer(keyfile, "global", "fd_counter", NULL); 771 } 772 } 773 774 static void persistent_state_to_keyfile(const GAPersistentState *pstate, 775 GKeyFile *keyfile) 776 { 777 g_assert(pstate); 778 g_assert(keyfile); 779 780 g_key_file_set_integer(keyfile, "global", "fd_counter", pstate->fd_counter); 781 } 782 783 static gboolean write_persistent_state(const GAPersistentState *pstate, 784 const gchar *path) 785 { 786 GKeyFile *keyfile = g_key_file_new(); 787 GError *gerr = NULL; 788 gboolean ret = true; 789 gchar *data = NULL; 790 gsize data_len; 791 792 g_assert(pstate); 793 794 persistent_state_to_keyfile(pstate, keyfile); 795 data = g_key_file_to_data(keyfile, &data_len, &gerr); 796 if (gerr) { 797 g_critical("failed to convert persistent state to string: %s", 798 gerr->message); 799 ret = false; 800 goto out; 801 } 802 803 g_file_set_contents(path, data, data_len, &gerr); 804 if (gerr) { 805 g_critical("failed to write persistent state to %s: %s", 806 path, gerr->message); 807 ret = false; 808 goto out; 809 } 810 811 out: 812 if (gerr) { 813 g_error_free(gerr); 814 } 815 if (keyfile) { 816 g_key_file_free(keyfile); 817 } 818 g_free(data); 819 return ret; 820 } 821 822 static gboolean read_persistent_state(GAPersistentState *pstate, 823 const gchar *path, gboolean frozen) 824 { 825 GKeyFile *keyfile = NULL; 826 GError *gerr = NULL; 827 struct stat st; 828 gboolean ret = true; 829 830 g_assert(pstate); 831 832 if (stat(path, &st) == -1) { 833 /* it's okay if state file doesn't exist, but any other error 834 * indicates a permissions issue or some other misconfiguration 835 * that we likely won't be able to recover from. 836 */ 837 if (errno != ENOENT) { 838 g_critical("unable to access state file at path %s: %s", 839 path, strerror(errno)); 840 ret = false; 841 goto out; 842 } 843 844 /* file doesn't exist. initialize state to default values and 845 * attempt to save now. (we could wait till later when we have 846 * modified state we need to commit, but if there's a problem, 847 * such as a missing parent directory, we want to catch it now) 848 * 849 * there is a potential scenario where someone either managed to 850 * update the agent from a version that didn't use a key store 851 * while qemu-ga thought the filesystem was frozen, or 852 * deleted the key store prior to issuing a fsfreeze, prior 853 * to restarting the agent. in this case we go ahead and defer 854 * initial creation till we actually have modified state to 855 * write, otherwise fail to recover from freeze. 856 */ 857 set_persistent_state_defaults(pstate); 858 if (!frozen) { 859 ret = write_persistent_state(pstate, path); 860 if (!ret) { 861 g_critical("unable to create state file at path %s", path); 862 ret = false; 863 goto out; 864 } 865 } 866 ret = true; 867 goto out; 868 } 869 870 keyfile = g_key_file_new(); 871 g_key_file_load_from_file(keyfile, path, 0, &gerr); 872 if (gerr) { 873 g_critical("error loading persistent state from path: %s, %s", 874 path, gerr->message); 875 ret = false; 876 goto out; 877 } 878 879 persistent_state_from_keyfile(pstate, keyfile); 880 881 out: 882 if (keyfile) { 883 g_key_file_free(keyfile); 884 } 885 if (gerr) { 886 g_error_free(gerr); 887 } 888 889 return ret; 890 } 891 892 int64_t ga_get_fd_handle(GAState *s, Error **errp) 893 { 894 int64_t handle; 895 896 g_assert(s->pstate_filepath); 897 /* we blacklist commands and avoid operations that potentially require 898 * writing to disk when we're in a frozen state. this includes opening 899 * new files, so we should never get here in that situation 900 */ 901 g_assert(!ga_is_frozen(s)); 902 903 handle = s->pstate.fd_counter++; 904 905 /* This should never happen on a reasonable timeframe, as guest-file-open 906 * would have to be issued 2^63 times */ 907 if (s->pstate.fd_counter == INT64_MAX) { 908 abort(); 909 } 910 911 if (!write_persistent_state(&s->pstate, s->pstate_filepath)) { 912 error_setg(errp, "failed to commit persistent state to disk"); 913 return -1; 914 } 915 916 return handle; 917 } 918 919 static void ga_print_cmd(const QmpCommand *cmd, void *opaque) 920 { 921 printf("%s\n", qmp_command_name(cmd)); 922 } 923 924 static GList *split_list(const gchar *str, const gchar *delim) 925 { 926 GList *list = NULL; 927 int i; 928 gchar **strv; 929 930 strv = g_strsplit(str, delim, -1); 931 for (i = 0; strv[i]; i++) { 932 list = g_list_prepend(list, strv[i]); 933 } 934 g_free(strv); 935 936 return list; 937 } 938 939 struct GAConfig { 940 char *channel_path; 941 char *method; 942 char *log_filepath; 943 char *pid_filepath; 944 #ifdef CONFIG_FSFREEZE 945 char *fsfreeze_hook; 946 #endif 947 char *state_dir; 948 #ifdef _WIN32 949 const char *service; 950 #endif 951 gchar *bliststr; /* blacklist may point to this string */ 952 GList *blacklist; 953 int daemonize; 954 GLogLevelFlags log_level; 955 int dumpconf; 956 bool retry_path; 957 }; 958 959 static void config_load(GAConfig *config) 960 { 961 GError *gerr = NULL; 962 GKeyFile *keyfile; 963 g_autofree char *conf = g_strdup(g_getenv("QGA_CONF")) ?: get_relocated_path(QGA_CONF_DEFAULT); 964 965 /* read system config */ 966 keyfile = g_key_file_new(); 967 if (!g_key_file_load_from_file(keyfile, conf, 0, &gerr)) { 968 goto end; 969 } 970 if (g_key_file_has_key(keyfile, "general", "daemon", NULL)) { 971 config->daemonize = 972 g_key_file_get_boolean(keyfile, "general", "daemon", &gerr); 973 } 974 if (g_key_file_has_key(keyfile, "general", "method", NULL)) { 975 config->method = 976 g_key_file_get_string(keyfile, "general", "method", &gerr); 977 } 978 if (g_key_file_has_key(keyfile, "general", "path", NULL)) { 979 config->channel_path = 980 g_key_file_get_string(keyfile, "general", "path", &gerr); 981 } 982 if (g_key_file_has_key(keyfile, "general", "logfile", NULL)) { 983 config->log_filepath = 984 g_key_file_get_string(keyfile, "general", "logfile", &gerr); 985 } 986 if (g_key_file_has_key(keyfile, "general", "pidfile", NULL)) { 987 config->pid_filepath = 988 g_key_file_get_string(keyfile, "general", "pidfile", &gerr); 989 } 990 #ifdef CONFIG_FSFREEZE 991 if (g_key_file_has_key(keyfile, "general", "fsfreeze-hook", NULL)) { 992 config->fsfreeze_hook = 993 g_key_file_get_string(keyfile, 994 "general", "fsfreeze-hook", &gerr); 995 } 996 #endif 997 if (g_key_file_has_key(keyfile, "general", "statedir", NULL)) { 998 config->state_dir = 999 g_key_file_get_string(keyfile, "general", "statedir", &gerr); 1000 } 1001 if (g_key_file_has_key(keyfile, "general", "verbose", NULL) && 1002 g_key_file_get_boolean(keyfile, "general", "verbose", &gerr)) { 1003 /* enable all log levels */ 1004 config->log_level = G_LOG_LEVEL_MASK; 1005 } 1006 if (g_key_file_has_key(keyfile, "general", "retry-path", NULL)) { 1007 config->retry_path = 1008 g_key_file_get_boolean(keyfile, "general", "retry-path", &gerr); 1009 } 1010 if (g_key_file_has_key(keyfile, "general", "blacklist", NULL)) { 1011 config->bliststr = 1012 g_key_file_get_string(keyfile, "general", "blacklist", &gerr); 1013 config->blacklist = g_list_concat(config->blacklist, 1014 split_list(config->bliststr, ",")); 1015 } 1016 1017 end: 1018 g_key_file_free(keyfile); 1019 if (gerr && 1020 !(gerr->domain == G_FILE_ERROR && gerr->code == G_FILE_ERROR_NOENT)) { 1021 g_critical("error loading configuration from path: %s, %s", 1022 conf, gerr->message); 1023 exit(EXIT_FAILURE); 1024 } 1025 g_clear_error(&gerr); 1026 } 1027 1028 static gchar *list_join(GList *list, const gchar separator) 1029 { 1030 GString *str = g_string_new(""); 1031 1032 while (list) { 1033 str = g_string_append(str, (gchar *)list->data); 1034 list = g_list_next(list); 1035 if (list) { 1036 str = g_string_append_c(str, separator); 1037 } 1038 } 1039 1040 return g_string_free(str, FALSE); 1041 } 1042 1043 static void config_dump(GAConfig *config) 1044 { 1045 GError *error = NULL; 1046 GKeyFile *keyfile; 1047 gchar *tmp; 1048 1049 keyfile = g_key_file_new(); 1050 g_assert(keyfile); 1051 1052 g_key_file_set_boolean(keyfile, "general", "daemon", config->daemonize); 1053 g_key_file_set_string(keyfile, "general", "method", config->method); 1054 if (config->channel_path) { 1055 g_key_file_set_string(keyfile, "general", "path", config->channel_path); 1056 } 1057 if (config->log_filepath) { 1058 g_key_file_set_string(keyfile, "general", "logfile", 1059 config->log_filepath); 1060 } 1061 g_key_file_set_string(keyfile, "general", "pidfile", config->pid_filepath); 1062 #ifdef CONFIG_FSFREEZE 1063 if (config->fsfreeze_hook) { 1064 g_key_file_set_string(keyfile, "general", "fsfreeze-hook", 1065 config->fsfreeze_hook); 1066 } 1067 #endif 1068 g_key_file_set_string(keyfile, "general", "statedir", config->state_dir); 1069 g_key_file_set_boolean(keyfile, "general", "verbose", 1070 config->log_level == G_LOG_LEVEL_MASK); 1071 g_key_file_set_boolean(keyfile, "general", "retry-path", 1072 config->retry_path); 1073 tmp = list_join(config->blacklist, ','); 1074 g_key_file_set_string(keyfile, "general", "blacklist", tmp); 1075 g_free(tmp); 1076 1077 tmp = g_key_file_to_data(keyfile, NULL, &error); 1078 if (error) { 1079 g_critical("Failed to dump keyfile: %s", error->message); 1080 g_clear_error(&error); 1081 } else { 1082 printf("%s", tmp); 1083 } 1084 1085 g_free(tmp); 1086 g_key_file_free(keyfile); 1087 } 1088 1089 static void config_parse(GAConfig *config, int argc, char **argv) 1090 { 1091 const char *sopt = "hVvdm:p:l:f:F::b:s:t:Dr"; 1092 int opt_ind = 0, ch; 1093 const struct option lopt[] = { 1094 { "help", 0, NULL, 'h' }, 1095 { "version", 0, NULL, 'V' }, 1096 { "dump-conf", 0, NULL, 'D' }, 1097 { "logfile", 1, NULL, 'l' }, 1098 { "pidfile", 1, NULL, 'f' }, 1099 #ifdef CONFIG_FSFREEZE 1100 { "fsfreeze-hook", 2, NULL, 'F' }, 1101 #endif 1102 { "verbose", 0, NULL, 'v' }, 1103 { "method", 1, NULL, 'm' }, 1104 { "path", 1, NULL, 'p' }, 1105 { "daemonize", 0, NULL, 'd' }, 1106 { "blacklist", 1, NULL, 'b' }, 1107 #ifdef _WIN32 1108 { "service", 1, NULL, 's' }, 1109 #endif 1110 { "statedir", 1, NULL, 't' }, 1111 { "retry-path", 0, NULL, 'r' }, 1112 { NULL, 0, NULL, 0 } 1113 }; 1114 1115 while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) { 1116 switch (ch) { 1117 case 'm': 1118 g_free(config->method); 1119 config->method = g_strdup(optarg); 1120 break; 1121 case 'p': 1122 g_free(config->channel_path); 1123 config->channel_path = g_strdup(optarg); 1124 break; 1125 case 'l': 1126 g_free(config->log_filepath); 1127 config->log_filepath = g_strdup(optarg); 1128 break; 1129 case 'f': 1130 g_free(config->pid_filepath); 1131 config->pid_filepath = g_strdup(optarg); 1132 break; 1133 #ifdef CONFIG_FSFREEZE 1134 case 'F': 1135 g_free(config->fsfreeze_hook); 1136 config->fsfreeze_hook = optarg ? g_strdup(optarg) : get_relocated_path(QGA_FSFREEZE_HOOK_DEFAULT); 1137 break; 1138 #endif 1139 case 't': 1140 g_free(config->state_dir); 1141 config->state_dir = g_strdup(optarg); 1142 break; 1143 case 'v': 1144 /* enable all log levels */ 1145 config->log_level = G_LOG_LEVEL_MASK; 1146 break; 1147 case 'V': 1148 printf("QEMU Guest Agent %s\n", QEMU_VERSION); 1149 exit(EXIT_SUCCESS); 1150 case 'd': 1151 config->daemonize = 1; 1152 break; 1153 case 'D': 1154 config->dumpconf = 1; 1155 break; 1156 case 'r': 1157 config->retry_path = true; 1158 break; 1159 case 'b': { 1160 if (is_help_option(optarg)) { 1161 qmp_for_each_command(&ga_commands, ga_print_cmd, NULL); 1162 exit(EXIT_SUCCESS); 1163 } 1164 config->blacklist = g_list_concat(config->blacklist, 1165 split_list(optarg, ",")); 1166 break; 1167 } 1168 #ifdef _WIN32 1169 case 's': 1170 config->service = optarg; 1171 if (strcmp(config->service, "install") == 0) { 1172 if (ga_install_vss_provider()) { 1173 exit(EXIT_FAILURE); 1174 } 1175 if (ga_install_service(config->channel_path, 1176 config->log_filepath, config->state_dir)) { 1177 exit(EXIT_FAILURE); 1178 } 1179 exit(EXIT_SUCCESS); 1180 } else if (strcmp(config->service, "uninstall") == 0) { 1181 ga_uninstall_vss_provider(); 1182 exit(ga_uninstall_service()); 1183 } else if (strcmp(config->service, "vss-install") == 0) { 1184 if (ga_install_vss_provider()) { 1185 exit(EXIT_FAILURE); 1186 } 1187 exit(EXIT_SUCCESS); 1188 } else if (strcmp(config->service, "vss-uninstall") == 0) { 1189 ga_uninstall_vss_provider(); 1190 exit(EXIT_SUCCESS); 1191 } else { 1192 printf("Unknown service command.\n"); 1193 exit(EXIT_FAILURE); 1194 } 1195 break; 1196 #endif 1197 case 'h': 1198 usage(argv[0]); 1199 exit(EXIT_SUCCESS); 1200 case '?': 1201 g_print("Unknown option, try '%s --help' for more information.\n", 1202 argv[0]); 1203 exit(EXIT_FAILURE); 1204 } 1205 } 1206 } 1207 1208 static void config_free(GAConfig *config) 1209 { 1210 g_free(config->method); 1211 g_free(config->log_filepath); 1212 g_free(config->pid_filepath); 1213 g_free(config->state_dir); 1214 g_free(config->channel_path); 1215 g_free(config->bliststr); 1216 #ifdef CONFIG_FSFREEZE 1217 g_free(config->fsfreeze_hook); 1218 #endif 1219 g_list_free_full(config->blacklist, g_free); 1220 g_free(config); 1221 } 1222 1223 static bool check_is_frozen(GAState *s) 1224 { 1225 #ifndef _WIN32 1226 /* check if a previous instance of qemu-ga exited with filesystems' state 1227 * marked as frozen. this could be a stale value (a non-qemu-ga process 1228 * or reboot may have since unfrozen them), but better to require an 1229 * uneeded unfreeze than to risk hanging on start-up 1230 */ 1231 struct stat st; 1232 if (stat(s->state_filepath_isfrozen, &st) == -1) { 1233 /* it's okay if the file doesn't exist, but if we can't access for 1234 * some other reason, such as permissions, there's a configuration 1235 * that needs to be addressed. so just bail now before we get into 1236 * more trouble later 1237 */ 1238 if (errno != ENOENT) { 1239 g_critical("unable to access state file at path %s: %s", 1240 s->state_filepath_isfrozen, strerror(errno)); 1241 return EXIT_FAILURE; 1242 } 1243 } else { 1244 g_warning("previous instance appears to have exited with frozen" 1245 " filesystems. deferring logging/pidfile creation and" 1246 " disabling non-fsfreeze-safe commands until" 1247 " guest-fsfreeze-thaw is issued, or filesystems are" 1248 " manually unfrozen and the file %s is removed", 1249 s->state_filepath_isfrozen); 1250 return true; 1251 } 1252 #endif 1253 return false; 1254 } 1255 1256 static GAState *initialize_agent(GAConfig *config, int socket_activation) 1257 { 1258 GAState *s = g_new0(GAState, 1); 1259 1260 g_assert(ga_state == NULL); 1261 1262 s->log_level = config->log_level; 1263 s->log_file = stderr; 1264 #ifdef CONFIG_FSFREEZE 1265 s->fsfreeze_hook = config->fsfreeze_hook; 1266 #endif 1267 s->pstate_filepath = g_strdup_printf("%s/qga.state", config->state_dir); 1268 s->state_filepath_isfrozen = g_strdup_printf("%s/qga.state.isfrozen", 1269 config->state_dir); 1270 s->frozen = check_is_frozen(s); 1271 1272 g_log_set_default_handler(ga_log, s); 1273 g_log_set_fatal_mask(NULL, G_LOG_LEVEL_ERROR); 1274 ga_enable_logging(s); 1275 1276 #ifdef _WIN32 1277 /* On win32 the state directory is application specific (be it the default 1278 * or a user override). We got past the command line parsing; let's create 1279 * the directory (with any intermediate directories). If we run into an 1280 * error later on, we won't try to clean up the directory, it is considered 1281 * persistent. 1282 */ 1283 if (g_mkdir_with_parents(config->state_dir, S_IRWXU) == -1) { 1284 g_critical("unable to create (an ancestor of) the state directory" 1285 " '%s': %s", config->state_dir, strerror(errno)); 1286 return NULL; 1287 } 1288 #endif 1289 1290 if (ga_is_frozen(s)) { 1291 if (config->daemonize) { 1292 /* delay opening/locking of pidfile till filesystems are unfrozen */ 1293 s->deferred_options.pid_filepath = config->pid_filepath; 1294 become_daemon(NULL); 1295 } 1296 if (config->log_filepath) { 1297 /* delay opening the log file till filesystems are unfrozen */ 1298 s->deferred_options.log_filepath = config->log_filepath; 1299 } 1300 ga_disable_logging(s); 1301 qmp_for_each_command(&ga_commands, ga_disable_non_whitelisted, NULL); 1302 } else { 1303 if (config->daemonize) { 1304 become_daemon(config->pid_filepath); 1305 } 1306 if (config->log_filepath) { 1307 FILE *log_file = ga_open_logfile(config->log_filepath); 1308 if (!log_file) { 1309 g_critical("unable to open specified log file: %s", 1310 strerror(errno)); 1311 return NULL; 1312 } 1313 s->log_file = log_file; 1314 } 1315 } 1316 1317 /* load persistent state from disk */ 1318 if (!read_persistent_state(&s->pstate, 1319 s->pstate_filepath, 1320 ga_is_frozen(s))) { 1321 g_critical("failed to load persistent state"); 1322 return NULL; 1323 } 1324 1325 config->blacklist = ga_command_blacklist_init(config->blacklist); 1326 if (config->blacklist) { 1327 GList *l = config->blacklist; 1328 s->blacklist = config->blacklist; 1329 do { 1330 g_debug("disabling command: %s", (char *)l->data); 1331 qmp_disable_command(&ga_commands, l->data, NULL); 1332 l = g_list_next(l); 1333 } while (l); 1334 } 1335 s->command_state = ga_command_state_new(); 1336 ga_command_state_init(s, s->command_state); 1337 ga_command_state_init_all(s->command_state); 1338 json_message_parser_init(&s->parser, process_event, s, NULL); 1339 1340 #ifndef _WIN32 1341 if (!register_signal_handlers()) { 1342 g_critical("failed to register signal handlers"); 1343 return NULL; 1344 } 1345 #endif 1346 1347 s->main_loop = g_main_loop_new(NULL, false); 1348 1349 s->config = config; 1350 s->socket_activation = socket_activation; 1351 1352 #ifdef _WIN32 1353 s->wakeup_event = CreateEvent(NULL, TRUE, FALSE, TEXT("WakeUp")); 1354 if (s->wakeup_event == NULL) { 1355 g_critical("CreateEvent failed"); 1356 return NULL; 1357 } 1358 #endif 1359 1360 ga_state = s; 1361 return s; 1362 } 1363 1364 static void cleanup_agent(GAState *s) 1365 { 1366 #ifdef _WIN32 1367 CloseHandle(s->wakeup_event); 1368 #endif 1369 if (s->command_state) { 1370 ga_command_state_cleanup_all(s->command_state); 1371 ga_command_state_free(s->command_state); 1372 json_message_parser_destroy(&s->parser); 1373 } 1374 g_free(s->pstate_filepath); 1375 g_free(s->state_filepath_isfrozen); 1376 if (s->main_loop) { 1377 g_main_loop_unref(s->main_loop); 1378 } 1379 g_free(s); 1380 ga_state = NULL; 1381 } 1382 1383 static int run_agent_once(GAState *s) 1384 { 1385 if (!channel_init(s, s->config->method, s->config->channel_path, 1386 s->socket_activation ? FIRST_SOCKET_ACTIVATION_FD : -1)) { 1387 g_critical("failed to initialize guest agent channel"); 1388 return EXIT_FAILURE; 1389 } 1390 1391 g_main_loop_run(ga_state->main_loop); 1392 1393 if (s->channel) { 1394 ga_channel_free(s->channel); 1395 } 1396 1397 return EXIT_SUCCESS; 1398 } 1399 1400 static void wait_for_channel_availability(GAState *s) 1401 { 1402 g_warning("waiting for channel path..."); 1403 #ifndef _WIN32 1404 sleep(QGA_RETRY_INTERVAL); 1405 #else 1406 DWORD dwWaitResult; 1407 1408 dwWaitResult = WaitForSingleObject(s->wakeup_event, INFINITE); 1409 1410 switch (dwWaitResult) { 1411 case WAIT_OBJECT_0: 1412 break; 1413 case WAIT_TIMEOUT: 1414 break; 1415 default: 1416 g_critical("WaitForSingleObject failed"); 1417 } 1418 #endif 1419 } 1420 1421 static int run_agent(GAState *s) 1422 { 1423 int ret = EXIT_SUCCESS; 1424 1425 s->force_exit = false; 1426 1427 do { 1428 ret = run_agent_once(s); 1429 if (s->config->retry_path && !s->force_exit) { 1430 g_warning("agent stopped unexpectedly, restarting..."); 1431 wait_for_channel_availability(s); 1432 } 1433 } while (s->config->retry_path && !s->force_exit); 1434 1435 return ret; 1436 } 1437 1438 static void stop_agent(GAState *s, bool requested) 1439 { 1440 if (!s->force_exit) { 1441 s->force_exit = requested; 1442 } 1443 1444 if (g_main_loop_is_running(s->main_loop)) { 1445 g_main_loop_quit(s->main_loop); 1446 } 1447 } 1448 1449 int main(int argc, char **argv) 1450 { 1451 int ret = EXIT_SUCCESS; 1452 GAState *s; 1453 GAConfig *config = g_new0(GAConfig, 1); 1454 int socket_activation; 1455 1456 config->log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL; 1457 1458 qemu_init_exec_dir(argv[0]); 1459 qga_qmp_init_marshal(&ga_commands); 1460 1461 init_dfl_pathnames(); 1462 config_load(config); 1463 config_parse(config, argc, argv); 1464 1465 if (config->pid_filepath == NULL) { 1466 config->pid_filepath = g_strdup(dfl_pathnames.pidfile); 1467 } 1468 1469 if (config->state_dir == NULL) { 1470 config->state_dir = g_strdup(dfl_pathnames.state_dir); 1471 } 1472 1473 if (config->method == NULL) { 1474 config->method = g_strdup("virtio-serial"); 1475 } 1476 1477 socket_activation = check_socket_activation(); 1478 if (socket_activation > 1) { 1479 g_critical("qemu-ga only supports listening on one socket"); 1480 ret = EXIT_FAILURE; 1481 goto end; 1482 } 1483 if (socket_activation) { 1484 SocketAddress *addr; 1485 1486 g_free(config->method); 1487 g_free(config->channel_path); 1488 config->method = NULL; 1489 config->channel_path = NULL; 1490 1491 addr = socket_local_address(FIRST_SOCKET_ACTIVATION_FD, NULL); 1492 if (addr) { 1493 if (addr->type == SOCKET_ADDRESS_TYPE_UNIX) { 1494 config->method = g_strdup("unix-listen"); 1495 } else if (addr->type == SOCKET_ADDRESS_TYPE_VSOCK) { 1496 config->method = g_strdup("vsock-listen"); 1497 } 1498 1499 qapi_free_SocketAddress(addr); 1500 } 1501 1502 if (!config->method) { 1503 g_critical("unsupported listen fd type"); 1504 ret = EXIT_FAILURE; 1505 goto end; 1506 } 1507 } else if (config->channel_path == NULL) { 1508 if (strcmp(config->method, "virtio-serial") == 0) { 1509 /* try the default path for the virtio-serial port */ 1510 config->channel_path = g_strdup(QGA_VIRTIO_PATH_DEFAULT); 1511 } else if (strcmp(config->method, "isa-serial") == 0) { 1512 /* try the default path for the serial port - COM1 */ 1513 config->channel_path = g_strdup(QGA_SERIAL_PATH_DEFAULT); 1514 } else { 1515 g_critical("must specify a path for this channel"); 1516 ret = EXIT_FAILURE; 1517 goto end; 1518 } 1519 } 1520 1521 if (config->dumpconf) { 1522 config_dump(config); 1523 goto end; 1524 } 1525 1526 s = initialize_agent(config, socket_activation); 1527 if (!s) { 1528 g_critical("error initializing guest agent"); 1529 goto end; 1530 } 1531 1532 #ifdef _WIN32 1533 if (config->daemonize) { 1534 SERVICE_TABLE_ENTRY service_table[] = { 1535 { (char *)QGA_SERVICE_NAME, service_main }, { NULL, NULL } }; 1536 StartServiceCtrlDispatcher(service_table); 1537 } else { 1538 ret = run_agent(s); 1539 } 1540 #else 1541 ret = run_agent(s); 1542 #endif 1543 1544 cleanup_agent(s); 1545 1546 end: 1547 if (config->daemonize) { 1548 unlink(config->pid_filepath); 1549 } 1550 1551 config_free(config); 1552 1553 return ret; 1554 } 1555