root / qemu-ga.c @ dabdf394
History | View | Annotate | Download (18.6 kB)
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 |
} |