qemu-ga.c

   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 #include <stdlib.h>
  14 #include <stdio.h>
  15 #include <stdbool.h>
  16 #include <glib.h>
  17 #include <getopt.h>
  18 #include <termios.h>
  19 #include <syslog.h>
  20 #include "qemu_socket.h"
  21 #include "json-streamer.h"
  22 #include "json-parser.h"
  23 #include "qint.h"
  24 #include "qjson.h"
  25 #include "qga/guest-agent-core.h"
  26 #include "module.h"
  27 #include "signal.h"
  28 #include "qerror.h"
  29 #include "error_int.h"
  30 #include "qapi/qmp-core.h"
  31
  32 #define QGA_VIRTIO_PATH_DEFAULT "/dev/virtio-ports/org.qemu.guest_agent.0"
  33 #define QGA_PIDFILE_DEFAULT "/var/run/qemu-ga.pid"
  34 #define QGA_BAUDRATE_DEFAULT B38400 /* for isa-serial channels */
  35 #define QGA_TIMEOUT_DEFAULT 30*1000 /* ms */
  36
  37 struct GAState {
  38     JSONMessageParser parser;
  39     GMainLoop *main_loop;
  40     GIOChannel *conn_channel;
  41     GIOChannel *listen_channel;
  42     const char *path;
  43     const char *method;
  44     bool virtio; /* fastpath to check for virtio to deal with poll() quirks */
  45     GACommandState *command_state;
  46     GLogLevelFlags log_level;
  47     FILE *log_file;
  48     bool logging_enabled;
  49 };
  50
  51 static struct GAState *ga_state;
  52
  53 static void quit_handler(int sig)
  54 {
  55     g_debug("received signal num %d, quitting", sig);
  56
  57     if (g_main_loop_is_running(ga_state->main_loop)) {
  58         g_main_loop_quit(ga_state->main_loop);
  59     }
  60 }
  61
  62 static void register_signal_handlers(void)
  63 {
  64     struct sigaction sigact;
  65     int ret;
  66
  67     memset(&sigact, 0, sizeof(struct sigaction));
  68     sigact.sa_handler = quit_handler;
  69
  70     ret = sigaction(SIGINT, &sigact, NULL);
  71     if (ret == -1) {
  72         g_error("error configuring signal handler: %s", strerror(errno));
  73         exit(EXIT_FAILURE);
  74     }
  75     ret = sigaction(SIGTERM, &sigact, NULL);
  76     if (ret == -1) {
  77         g_error("error configuring signal handler: %s", strerror(errno));
  78     }
  79 }
  80
  81 static void usage(const char *cmd)
  82 {
  83     printf(
  84 "Usage: %s -c <channel_opts>\n"
  85 "QEMU Guest Agent %s\n"
  86 "\n"
  87 "  -m, --method      transport method: one of unix-listen, virtio-serial, or\n"
  88 "                    isa-serial (virtio-serial is the default)\n"
  89 "  -p, --path        device/socket path (%s is the default for virtio-serial)\n"
  90 "  -l, --logfile     set logfile path, logs to stderr by default\n"
  91 "  -f, --pidfile     specify pidfile (default is %s)\n"
  92 "  -v, --verbose     log extra debugging information\n"
  93 "  -V, --version     print version information and exit\n"
  94 "  -d, --daemonize   become a daemon\n"
  95 "  -b, --blacklist   comma-separated list of RPCs to disable (no spaces, \"?\""
  96 "                    to list available RPCs)\n"
  97 "  -h, --help        display this help and exit\n"
  98 "\n"
  99 "Report bugs to <mdroth@linux.vnet.ibm.com>\n"
 100     , cmd, QGA_VERSION, QGA_VIRTIO_PATH_DEFAULT, QGA_PIDFILE_DEFAULT);
 101 }
 102
 103 static void conn_channel_close(GAState *s);
 104
 105 static const char *ga_log_level_str(GLogLevelFlags level)
 106 {
 107     switch (level & G_LOG_LEVEL_MASK) {
 108         case G_LOG_LEVEL_ERROR:
 109             return "error";
 110         case G_LOG_LEVEL_CRITICAL:
 111             return "critical";
 112         case G_LOG_LEVEL_WARNING:
 113             return "warning";
 114         case G_LOG_LEVEL_MESSAGE:
 115             return "message";
 116         case G_LOG_LEVEL_INFO:
 117             return "info";
 118         case G_LOG_LEVEL_DEBUG:
 119             return "debug";
 120         default:
 121             return "user";
 122     }
 123 }
 124
 125 bool ga_logging_enabled(GAState *s)
 126 {
 127     return s->logging_enabled;
 128 }
 129
 130 void ga_disable_logging(GAState *s)
 131 {
 132     s->logging_enabled = false;
 133 }
 134
 135 void ga_enable_logging(GAState *s)
 136 {
 137     s->logging_enabled = true;
 138 }
 139
 140 static void ga_log(const gchar *domain, GLogLevelFlags level,
 141                    const gchar *msg, gpointer opaque)
 142 {
 143     GAState *s = opaque;
 144     GTimeVal time;
 145     const char *level_str = ga_log_level_str(level);
 146
 147     if (!ga_logging_enabled(s)) {
 148         return;
 149     }
 150
 151     level &= G_LOG_LEVEL_MASK;
 152     if (domain && strcmp(domain, "syslog") == 0) {
 153         syslog(LOG_INFO, "%s: %s", level_str, msg);
 154     } else if (level & s->log_level) {
 155         g_get_current_time(&time);
 156         fprintf(s->log_file,
 157                 "%lu.%lu: %s: %s\n", time.tv_sec, time.tv_usec, level_str, msg);
 158         fflush(s->log_file);
 159     }
 160 }
 161
 162 static void become_daemon(const char *pidfile)
 163 {
 164     pid_t pid, sid;
 165     int pidfd;
 166     char *pidstr = NULL;
 167
 168     pid = fork();
 169     if (pid < 0) {
 170         exit(EXIT_FAILURE);
 171     }
 172     if (pid > 0) {
 173         exit(EXIT_SUCCESS);
 174     }
 175
 176     pidfd = open(pidfile, O_CREAT|O_WRONLY|O_EXCL, S_IRUSR|S_IWUSR);
 177     if (pidfd == -1) {
 178         g_critical("Cannot create pid file, %s", strerror(errno));
 179         exit(EXIT_FAILURE);
 180     }
 181
 182     if (asprintf(&pidstr, "%d", getpid()) == -1) {
 183         g_critical("Cannot allocate memory");
 184         goto fail;
 185     }
 186     if (write(pidfd, pidstr, strlen(pidstr)) != strlen(pidstr)) {
 187         free(pidstr);
 188         g_critical("Failed to write pid file");
 189         goto fail;
 190     }
 191
 192     umask(0);
 193     sid = setsid();
 194     if (sid < 0) {
 195         goto fail;
 196     }
 197     if ((chdir("/")) < 0) {
 198         goto fail;
 199     }
 200
 201     close(STDIN_FILENO);
 202     close(STDOUT_FILENO);
 203     close(STDERR_FILENO);
 204     free(pidstr);
 205     return;
 206
 207 fail:
 208     unlink(pidfile);
 209     g_critical("failed to daemonize");
 210     exit(EXIT_FAILURE);
 211 }
 212
 213 static int conn_channel_send_buf(GIOChannel *channel, const char *buf,
 214                                  gsize count)
 215 {
 216     GError *err = NULL;
 217     gsize written = 0;
 218     GIOStatus status;
 219
 220     while (count) {
 221         status = g_io_channel_write_chars(channel, buf, count, &written, &err);
 222         g_debug("sending data, count: %d", (int)count);
 223         if (err != NULL) {
 224             g_warning("error sending newline: %s", err->message);
 225             return err->code;
 226         }
 227         if (status == G_IO_STATUS_ERROR || status == G_IO_STATUS_EOF) {
 228             return -EPIPE;
 229         }
 230
 231         if (status == G_IO_STATUS_NORMAL) {
 232             count -= written;
 233         }
 234     }
 235
 236     return 0;
 237 }
 238
 239 static int conn_channel_send_payload(GIOChannel *channel, QObject *payload)
 240 {
 241     int ret = 0;
 242     const char *buf;
 243     QString *payload_qstr;
 244     GError *err = NULL;
 245
 246     g_assert(payload && channel);
 247
 248     payload_qstr = qobject_to_json(payload);
 249     if (!payload_qstr) {
 250         return -EINVAL;
 251     }
 252
 253     qstring_append_chr(payload_qstr, '\n');
 254     buf = qstring_get_str(payload_qstr);
 255     ret = conn_channel_send_buf(channel, buf, strlen(buf));
 256     if (ret) {
 257         goto out_free;
 258     }
 259
 260     g_io_channel_flush(channel, &err);
 261     if (err != NULL) {
 262         g_warning("error flushing payload: %s", err->message);
 263         ret = err->code;
 264         goto out_free;
 265     }
 266
 267 out_free:
 268     QDECREF(payload_qstr);
 269     if (err) {
 270         g_error_free(err);
 271     }
 272     return ret;
 273 }
 274
 275 static void process_command(GAState *s, QDict *req)
 276 {
 277     QObject *rsp = NULL;
 278     int ret;
 279
 280     g_assert(req);
 281     g_debug("processing command");
 282     rsp = qmp_dispatch(QOBJECT(req));
 283     if (rsp) {
 284         ret = conn_channel_send_payload(s->conn_channel, rsp);
 285         if (ret) {
 286             g_warning("error sending payload: %s", strerror(ret));
 287         }
 288         qobject_decref(rsp);
 289     } else {
 290         g_warning("error getting response");
 291     }
 292 }
 293
 294 /* handle requests/control events coming in over the channel */
 295 static void process_event(JSONMessageParser *parser, QList *tokens)
 296 {
 297     GAState *s = container_of(parser, GAState, parser);
 298     QObject *obj;
 299     QDict *qdict;
 300     Error *err = NULL;
 301     int ret;
 302
 303     g_assert(s && parser);
 304
 305     g_debug("process_event: called");
 306     obj = json_parser_parse_err(tokens, NULL, &err);
 307     if (err || !obj || qobject_type(obj) != QTYPE_QDICT) {
 308         qobject_decref(obj);
 309         qdict = qdict_new();
 310         if (!err) {
 311             g_warning("failed to parse event: unknown error");
 312             error_set(&err, QERR_JSON_PARSING);
 313         } else {
 314             g_warning("failed to parse event: %s", error_get_pretty(err));
 315         }
 316         qdict_put_obj(qdict, "error", error_get_qobject(err));
 317         error_free(err);
 318     } else {
 319         qdict = qobject_to_qdict(obj);
 320     }
 321
 322     g_assert(qdict);
 323
 324     /* handle host->guest commands */
 325     if (qdict_haskey(qdict, "execute")) {
 326         process_command(s, qdict);
 327     } else {
 328         if (!qdict_haskey(qdict, "error")) {
 329             QDECREF(qdict);
 330             qdict = qdict_new();
 331             g_warning("unrecognized payload format");
 332             error_set(&err, QERR_UNSUPPORTED);
 333             qdict_put_obj(qdict, "error", error_get_qobject(err));
 334             error_free(err);
 335         }
 336         ret = conn_channel_send_payload(s->conn_channel, QOBJECT(qdict));
 337         if (ret) {
 338             g_warning("error sending payload: %s", strerror(ret));
 339         }
 340     }
 341
 342     QDECREF(qdict);
 343 }
 344
 345 static gboolean conn_channel_read(GIOChannel *channel, GIOCondition condition,
 346                                   gpointer data)
 347 {
 348     GAState *s = data;
 349     gchar buf[1024];
 350     gsize count;
 351     GError *err = NULL;
 352     memset(buf, 0, 1024);
 353     GIOStatus status = g_io_channel_read_chars(channel, buf, 1024,
 354                                                &count, &err);
 355     if (err != NULL) {
 356         g_warning("error reading channel: %s", err->message);
 357         conn_channel_close(s);
 358         g_error_free(err);
 359         return false;
 360     }
 361     switch (status) {
 362     case G_IO_STATUS_ERROR:
 363         g_warning("problem");
 364         return false;
 365     case G_IO_STATUS_NORMAL:
 366         g_debug("read data, count: %d, data: %s", (int)count, buf);
 367         json_message_parser_feed(&s->parser, (char *)buf, (int)count);
 368     case G_IO_STATUS_AGAIN:
 369         /* virtio causes us to spin here when no process is attached to
 370          * host-side chardev. sleep a bit to mitigate this
 371          */
 372         if (s->virtio) {
 373             usleep(100*1000);
 374         }
 375         return true;
 376     case G_IO_STATUS_EOF:
 377         g_debug("received EOF");
 378         conn_channel_close(s);
 379         if (s->virtio) {
 380             return true;
 381         }
 382         return false;
 383     default:
 384         g_warning("unknown channel read status, closing");
 385         conn_channel_close(s);
 386         return false;
 387     }
 388     return true;
 389 }
 390
 391 static int conn_channel_add(GAState *s, int fd)
 392 {
 393     GIOChannel *conn_channel;
 394     GError *err = NULL;
 395
 396     g_assert(s && !s->conn_channel);
 397     conn_channel = g_io_channel_unix_new(fd);
 398     g_assert(conn_channel);
 399     g_io_channel_set_encoding(conn_channel, NULL, &err);
 400     if (err != NULL) {
 401         g_warning("error setting channel encoding to binary");
 402         g_error_free(err);
 403         return -1;
 404     }
 405     g_io_add_watch(conn_channel, G_IO_IN | G_IO_HUP,
 406                    conn_channel_read, s);
 407     s->conn_channel = conn_channel;
 408     return 0;
 409 }
 410
 411 static gboolean listen_channel_accept(GIOChannel *channel,
 412                                       GIOCondition condition, gpointer data)
 413 {
 414     GAState *s = data;
 415     g_assert(channel != NULL);
 416     int ret, conn_fd;
 417     bool accepted = false;
 418     struct sockaddr_un addr;
 419     socklen_t addrlen = sizeof(addr);
 420
 421     conn_fd = qemu_accept(g_io_channel_unix_get_fd(s->listen_channel),
 422                              (struct sockaddr *)&addr, &addrlen);
 423     if (conn_fd == -1) {
 424         g_warning("error converting fd to gsocket: %s", strerror(errno));
 425         goto out;
 426     }
 427     fcntl(conn_fd, F_SETFL, O_NONBLOCK);
 428     ret = conn_channel_add(s, conn_fd);
 429     if (ret) {
 430         g_warning("error setting up connection");
 431         goto out;
 432     }
 433     accepted = true;
 434
 435 out:
 436     /* only accept 1 connection at a time */
 437     return !accepted;
 438 }
 439
 440 /* start polling for readable events on listen fd, new==true
 441  * indicates we should use the existing s->listen_channel
 442  */
 443 static int listen_channel_add(GAState *s, int listen_fd, bool new)
 444 {
 445     if (new) {
 446         s->listen_channel = g_io_channel_unix_new(listen_fd);
 447     }
 448     g_io_add_watch(s->listen_channel, G_IO_IN,
 449                    listen_channel_accept, s);
 450     return 0;
 451 }
 452
 453 /* cleanup state for closed connection/session, start accepting new
 454  * connections if we're in listening mode
 455  */
 456 static void conn_channel_close(GAState *s)
 457 {
 458     if (strcmp(s->method, "unix-listen") == 0) {
 459         g_io_channel_shutdown(s->conn_channel, true, NULL);
 460         listen_channel_add(s, 0, false);
 461     } else if (strcmp(s->method, "virtio-serial") == 0) {
 462         /* we spin on EOF for virtio-serial, so back off a bit. also,
 463          * dont close the connection in this case, it'll resume normal
 464          * operation when another process connects to host chardev
 465          */
 466         usleep(100*1000);
 467         goto out_noclose;
 468     }
 469     g_io_channel_unref(s->conn_channel);
 470     s->conn_channel = NULL;
 471 out_noclose:
 472     return;
 473 }
 474
 475 static void init_guest_agent(GAState *s)
 476 {
 477     struct termios tio;
 478     int ret, fd;
 479
 480     if (s->method == NULL) {
 481         /* try virtio-serial as our default */
 482         s->method = "virtio-serial";
 483     }
 484
 485     if (s->path == NULL) {
 486         if (strcmp(s->method, "virtio-serial") != 0) {
 487             g_critical("must specify a path for this channel");
 488             exit(EXIT_FAILURE);
 489         }
 490         /* try the default path for the virtio-serial port */
 491         s->path = QGA_VIRTIO_PATH_DEFAULT;
 492     }
 493
 494     if (strcmp(s->method, "virtio-serial") == 0) {
 495         s->virtio = true;
 496         fd = qemu_open(s->path, O_RDWR | O_NONBLOCK | O_ASYNC);
 497         if (fd == -1) {
 498             g_critical("error opening channel: %s", strerror(errno));
 499             exit(EXIT_FAILURE);
 500         }
 501         ret = conn_channel_add(s, fd);
 502         if (ret) {
 503             g_critical("error adding channel to main loop");
 504             exit(EXIT_FAILURE);
 505         }
 506     } else if (strcmp(s->method, "isa-serial") == 0) {
 507         fd = qemu_open(s->path, O_RDWR | O_NOCTTY);
 508         if (fd == -1) {
 509             g_critical("error opening channel: %s", strerror(errno));
 510             exit(EXIT_FAILURE);
 511         }
 512         tcgetattr(fd, &tio);
 513         /* set up serial port for non-canonical, dumb byte streaming */
 514         tio.c_iflag &= ~(IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP |
 515                          INLCR | IGNCR | ICRNL | IXON | IXOFF | IXANY |
 516                          IMAXBEL);
 517         tio.c_oflag = 0;
 518         tio.c_lflag = 0;
 519         tio.c_cflag |= QGA_BAUDRATE_DEFAULT;
 520         /* 1 available byte min or reads will block (we'll set non-blocking
 521          * elsewhere, else we have to deal with read()=0 instead)
 522          */
 523         tio.c_cc[VMIN] = 1;
 524         tio.c_cc[VTIME] = 0;
 525         /* flush everything waiting for read/xmit, it's garbage at this point */
 526         tcflush(fd, TCIFLUSH);
 527         tcsetattr(fd, TCSANOW, &tio);
 528         ret = conn_channel_add(s, fd);
 529         if (ret) {
 530             g_error("error adding channel to main loop");
 531         }
 532     } else if (strcmp(s->method, "unix-listen") == 0) {
 533         fd = unix_listen(s->path, NULL, strlen(s->path));
 534         if (fd == -1) {
 535             g_critical("error opening path: %s", strerror(errno));
 536             exit(EXIT_FAILURE);
 537         }
 538         ret = listen_channel_add(s, fd, true);
 539         if (ret) {
 540             g_critical("error binding/listening to specified socket");
 541             exit(EXIT_FAILURE);
 542         }
 543     } else {
 544         g_critical("unsupported channel method/type: %s", s->method);
 545         exit(EXIT_FAILURE);
 546     }
 547
 548     json_message_parser_init(&s->parser, process_event);
 549     s->main_loop = g_main_loop_new(NULL, false);
 550 }
 551
 552 int main(int argc, char **argv)
 553 {
 554     const char *sopt = "hVvdm:p:l:f:b:";
 555     const char *method = NULL, *path = NULL, *pidfile = QGA_PIDFILE_DEFAULT;
 556     const struct option lopt[] = {
 557         { "help", 0, NULL, 'h' },
 558         { "version", 0, NULL, 'V' },
 559         { "logfile", 0, NULL, 'l' },
 560         { "pidfile", 0, NULL, 'f' },
 561         { "verbose", 0, NULL, 'v' },
 562         { "method", 0, NULL, 'm' },
 563         { "path", 0, NULL, 'p' },
 564         { "daemonize", 0, NULL, 'd' },
 565         { "blacklist", 0, NULL, 'b' },
 566         { NULL, 0, NULL, 0 }
 567     };
 568     int opt_ind = 0, ch, daemonize = 0, i, j, len;
 569     GLogLevelFlags log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL;
 570     FILE *log_file = stderr;
 571     GAState *s;
 572
 573     module_call_init(MODULE_INIT_QAPI);
 574
 575     while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) {
 576         switch (ch) {
 577         case 'm':
 578             method = optarg;
 579             break;
 580         case 'p':
 581             path = optarg;
 582             break;
 583         case 'l':
 584             log_file = fopen(optarg, "a");
 585             if (!log_file) {
 586                 g_critical("unable to open specified log file: %s",
 587                            strerror(errno));
 588                 return EXIT_FAILURE;
 589             }
 590             break;
 591         case 'f':
 592             pidfile = optarg;
 593             break;
 594         case 'v':
 595             /* enable all log levels */
 596             log_level = G_LOG_LEVEL_MASK;
 597             break;
 598         case 'V':
 599             printf("QEMU Guest Agent %s\n", QGA_VERSION);
 600             return 0;
 601         case 'd':
 602             daemonize = 1;
 603             break;
 604         case 'b': {
 605             char **list_head, **list;
 606             if (*optarg == '?') {
 607                 list_head = list = qmp_get_command_list();
 608                 while (*list != NULL) {
 609                     printf("%s\n", *list);
 610                     g_free(*list);
 611                     list++;
 612                 }
 613                 g_free(list_head);
 614                 return 0;
 615             }
 616             for (j = 0, i = 0, len = strlen(optarg); i < len; i++) {
 617                 if (optarg[i] == ',') {
 618                     optarg[i] = 0;
 619                     qmp_disable_command(&optarg[j]);
 620                     g_debug("disabling command: %s", &optarg[j]);
 621                     j = i + 1;
 622                 }
 623             }
 624             if (j < i) {
 625                 qmp_disable_command(&optarg[j]);
 626                 g_debug("disabling command: %s", &optarg[j]);
 627             }
 628             break;
 629         }
 630         case 'h':
 631             usage(argv[0]);
 632             return 0;
 633         case '?':
 634             g_print("Unknown option, try '%s --help' for more information.\n",
 635                     argv[0]);
 636             return EXIT_FAILURE;
 637         }
 638     }
 639
 640     if (daemonize) {
 641         g_debug("starting daemon");
 642         become_daemon(pidfile);
 643     }
 644
 645     s = g_malloc0(sizeof(GAState));
 646     s->conn_channel = NULL;
 647     s->path = path;
 648     s->method = method;
 649     s->log_file = log_file;
 650     s->log_level = log_level;
 651     g_log_set_default_handler(ga_log, s);
 652     g_log_set_fatal_mask(NULL, G_LOG_LEVEL_ERROR);
 653     s->logging_enabled = true;
 654     s->command_state = ga_command_state_new();
 655     ga_command_state_init(s, s->command_state);
 656     ga_command_state_init_all(s->command_state);
 657     ga_state = s;
 658
 659     init_guest_agent(ga_state);
 660     register_signal_handlers();
 661
 662     g_main_loop_run(ga_state->main_loop);
 663
 664     ga_command_state_cleanup_all(ga_state->command_state);
 665     unlink(pidfile);
 666
 667     return 0;
 668 }