File:  [Qemu by Fabrice Bellard] / qemu / qemu-ga.c
Revision 1.1.1.2 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 19:17:34 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu1001, HEAD
qemu 1.0.1

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

unix.superglobalmegacorp.com