PPC: booke206: Check for min/max TLB entry size
[qemu.git] / 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 }