Revision 48ff7a62

b/Makefile
140 140
######################################################################
141 141

  
142 142
qemu-img.o: qemu-img-cmds.h
143
qemu-img.o qemu-tool.o qemu-nbd.o qemu-io.o cmd.o: $(GENERATED_HEADERS)
143
qemu-img.o qemu-tool.o qemu-nbd.o qemu-io.o cmd.o qemu-ga.o: $(GENERATED_HEADERS)
144 144

  
145 145
qemu-img$(EXESUF): qemu-img.o qemu-tool.o qemu-error.o $(oslib-obj-y) $(trace-obj-y) $(block-obj-y) $(qobject-obj-y) $(version-obj-y) qemu-timer-common.o
146 146

  
......
184 184

  
185 185
QGALIB=qga/guest-agent-command-state.o
186 186

  
187
qemu-ga$(EXESUF): qemu-ga.o $(QGALIB) qemu-tool.o qemu-error.o error.o $(oslib-obj-y) $(trace-obj-y) $(block-obj-y) $(qobject-obj-y) $(version-obj-y) $(qapi-obj-y) qemu-timer-common.o qemu-sockets.o module.o qapi/qmp-dispatch.o qapi/qmp-registry.o
188

  
187 189
QEMULIBS=libhw32 libhw64 libuser libdis libdis-user
188 190

  
189 191
clean:
190 192
# avoid old build problems by removing potentially incorrect old files
191 193
	rm -f config.mak op-i386.h opc-i386.h gen-op-i386.h op-arm.h opc-arm.h gen-op-arm.h
192 194
	rm -f qemu-options.def
193
	rm -f *.o *.d *.a *.lo $(TOOLS) TAGS cscope.* *.pod *~ */*~
195
	rm -f *.o *.d *.a *.lo $(TOOLS) qemu-ga TAGS cscope.* *.pod *~ */*~
194 196
	rm -Rf .libs
195 197
	rm -f slirp/*.o slirp/*.d audio/*.o audio/*.d block/*.o block/*.d net/*.o net/*.d fsdev/*.o fsdev/*.d ui/*.o ui/*.d qapi/*.o qapi/*.d qga/*.o qga/*.d
196 198
	rm -f qemu-img-cmds.h
......
386 388
	$(mandir)/man8/qemu-nbd.8
387 389

  
388 390
# Include automatically generated dependency files
389
-include $(wildcard *.d audio/*.d slirp/*.d block/*.d net/*.d ui/*.d qapi/*.d)
391
-include $(wildcard *.d audio/*.d slirp/*.d block/*.d net/*.d ui/*.d qapi/*.d qga/*.d)
b/configure
2532 2532
  tools="qemu-img\$(EXESUF) qemu-io\$(EXESUF) $tools"
2533 2533
  if [ "$linux" = "yes" -o "$bsd" = "yes" -o "$solaris" = "yes" ] ; then
2534 2534
      tools="qemu-nbd\$(EXESUF) $tools"
2535
      tools="qemu-ga\$(EXESUF) $tools"
2535 2536
    if [ "$check_utests" = "yes" ]; then
2536 2537
      tools="check-qint check-qstring check-qdict check-qlist $tools"
2537 2538
      tools="check-qfloat check-qjson $tools"
b/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 <gio/gio.h>
18
#include <getopt.h>
19
#include <termios.h>
20
#include <syslog.h>
21
#include "qemu_socket.h"
22
#include "json-streamer.h"
23
#include "json-parser.h"
24
#include "qint.h"
25
#include "qjson.h"
26
#include "qga/guest-agent-core.h"
27
#include "module.h"
28
#include "signal.h"
29
#include "qerror.h"
30
#include "error_int.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
    GSocket *conn_sock;
41
    GIOChannel *conn_channel;
42
    GSocket *listen_sock;
43
    GIOChannel *listen_channel;
44
    const char *path;
45
    const char *method;
46
    bool virtio; /* fastpath to check for virtio to deal with poll() quirks */
47
    GACommandState *command_state;
48
    GLogLevelFlags log_level;
49
    FILE *log_file;
50
    bool logging_enabled;
51
};
52

  
53
static struct GAState *ga_state;
54

  
55
static void quit_handler(int sig)
56
{
57
    g_debug("recieved signal num %d, quitting", sig);
58

  
59
    if (g_main_loop_is_running(ga_state->main_loop)) {
60
        g_main_loop_quit(ga_state->main_loop);
61
    }
62
}
63

  
64
static void register_signal_handlers(void)
65
{
66
    struct sigaction sigact;
67
    int ret;
68

  
69
    memset(&sigact, 0, sizeof(struct sigaction));
70
    sigact.sa_handler = quit_handler;
71

  
72
    ret = sigaction(SIGINT, &sigact, NULL);
73
    if (ret == -1) {
74
        g_error("error configuring signal handler: %s", strerror(errno));
75
        exit(EXIT_FAILURE);
76
    }
77
    ret = sigaction(SIGTERM, &sigact, NULL);
78
    if (ret == -1) {
79
        g_error("error configuring signal handler: %s", strerror(errno));
80
    }
81
}
82

  
83
static void usage(const char *cmd)
84
{
85
    printf(
86
"Usage: %s -c <channel_opts>\n"
87
"QEMU Guest Agent %s\n"
88
"\n"
89
"  -m, --method      transport method: one of unix-listen, virtio-serial, or\n"
90
"                    isa-serial (virtio-serial is the default)\n"
91
"  -p, --path        device/socket path (%s is the default for virtio-serial)\n"
92
"  -l, --logfile     set logfile path, logs to stderr by default\n"
93
"  -f, --pidfile     specify pidfile (default is %s)\n"
94
"  -v, --verbose     log extra debugging information\n"
95
"  -V, --version     print version information and exit\n"
96
"  -d, --daemonize   become a daemon\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 (g_strcmp0(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
    GError *err = NULL;
416
    g_assert(channel != NULL);
417
    int ret;
418
    bool accepted = false;
419

  
420
    s->conn_sock = g_socket_accept(s->listen_sock, NULL, &err);
421
    if (err != NULL) {
422
        g_warning("error converting fd to gsocket: %s", err->message);
423
        g_error_free(err);
424
        goto out;
425
    }
426
    ret = conn_channel_add(s, g_socket_get_fd(s->conn_sock));
427
    if (ret) {
428
        g_warning("error setting up connection");
429
        goto out;
430
    }
431
    accepted = true;
432

  
433
out:
434
    /* only accept 1 connection at a time */
435
    return !accepted;
436
}
437

  
438
/* start polling for readable events on listen fd, new==true
439
 * indicates we should use the existing s->listen_channel
440
 */
441
static int listen_channel_add(GAState *s, int listen_fd, bool new)
442
{
443
    GError *err = NULL;
444

  
445
    if (new) {
446
        s->listen_channel = g_io_channel_unix_new(listen_fd);
447
        if (s->listen_sock) {
448
            g_object_unref(s->listen_sock);
449
        }
450
        s->listen_sock = g_socket_new_from_fd(listen_fd, &err);
451
        if (err != NULL) {
452
            g_warning("error converting fd to gsocket: %s", err->message);
453
            g_error_free(err);
454
            return -1;
455
        }
456
    }
457
    g_io_add_watch(s->listen_channel, G_IO_IN,
458
                   listen_channel_accept, s);
459
    return 0;
460
}
461

  
462
/* cleanup state for closed connection/session, start accepting new
463
 * connections if we're in listening mode
464
 */
465
static void conn_channel_close(GAState *s)
466
{
467
    if (strcmp(s->method, "unix-listen") == 0) {
468
        g_io_channel_shutdown(s->conn_channel, true, NULL);
469
        g_object_unref(s->conn_sock);
470
        s->conn_sock = NULL;
471
        listen_channel_add(s, 0, false);
472
    } else if (strcmp(s->method, "virtio-serial") == 0) {
473
        /* we spin on EOF for virtio-serial, so back off a bit. also,
474
         * dont close the connection in this case, it'll resume normal
475
         * operation when another process connects to host chardev
476
         */
477
        usleep(100*1000);
478
        goto out_noclose;
479
    }
480
    g_io_channel_unref(s->conn_channel);
481
    s->conn_channel = NULL;
482
out_noclose:
483
    return;
484
}
485

  
486
static void init_guest_agent(GAState *s)
487
{
488
    struct termios tio;
489
    int ret, fd;
490

  
491
    if (s->method == NULL) {
492
        /* try virtio-serial as our default */
493
        s->method = "virtio-serial";
494
    }
495

  
496
    if (s->path == NULL) {
497
        if (strcmp(s->method, "virtio-serial") != 0) {
498
            g_critical("must specify a path for this channel");
499
            exit(EXIT_FAILURE);
500
        }
501
        /* try the default path for the virtio-serial port */
502
        s->path = QGA_VIRTIO_PATH_DEFAULT;
503
    }
504

  
505
    if (strcmp(s->method, "virtio-serial") == 0) {
506
        s->virtio = true;
507
        fd = qemu_open(s->path, O_RDWR | O_NONBLOCK | O_ASYNC);
508
        if (fd == -1) {
509
            g_critical("error opening channel: %s", strerror(errno));
510
            exit(EXIT_FAILURE);
511
        }
512
        ret = conn_channel_add(s, fd);
513
        if (ret) {
514
            g_critical("error adding channel to main loop");
515
            exit(EXIT_FAILURE);
516
        }
517
    } else if (strcmp(s->method, "isa-serial") == 0) {
518
        fd = qemu_open(s->path, O_RDWR | O_NOCTTY);
519
        if (fd == -1) {
520
            g_critical("error opening channel: %s", strerror(errno));
521
            exit(EXIT_FAILURE);
522
        }
523
        tcgetattr(fd, &tio);
524
        /* set up serial port for non-canonical, dumb byte streaming */
525
        tio.c_iflag &= ~(IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP |
526
                         INLCR | IGNCR | ICRNL | IXON | IXOFF | IXANY |
527
                         IMAXBEL);
528
        tio.c_oflag = 0;
529
        tio.c_lflag = 0;
530
        tio.c_cflag |= QGA_BAUDRATE_DEFAULT;
531
        /* 1 available byte min or reads will block (we'll set non-blocking
532
         * elsewhere, else we have to deal with read()=0 instead)
533
         */
534
        tio.c_cc[VMIN] = 1;
535
        tio.c_cc[VTIME] = 0;
536
        /* flush everything waiting for read/xmit, it's garbage at this point */
537
        tcflush(fd, TCIFLUSH);
538
        tcsetattr(fd, TCSANOW, &tio);
539
        ret = conn_channel_add(s, fd);
540
        if (ret) {
541
            g_error("error adding channel to main loop");
542
        }
543
    } else if (strcmp(s->method, "unix-listen") == 0) {
544
        fd = unix_listen(s->path, NULL, strlen(s->path));
545
        if (fd == -1) {
546
            g_critical("error opening path: %s", strerror(errno));
547
            exit(EXIT_FAILURE);
548
        }
549
        ret = listen_channel_add(s, fd, true);
550
        if (ret) {
551
            g_critical("error binding/listening to specified socket");
552
            exit(EXIT_FAILURE);
553
        }
554
    } else {
555
        g_critical("unsupported channel method/type: %s", s->method);
556
        exit(EXIT_FAILURE);
557
    }
558

  
559
    json_message_parser_init(&s->parser, process_event);
560
    s->main_loop = g_main_loop_new(NULL, false);
561
}
562

  
563
int main(int argc, char **argv)
564
{
565
    const char *sopt = "hVvdm:p:l:f:";
566
    const char *method = NULL, *path = NULL, *pidfile = QGA_PIDFILE_DEFAULT;
567
    const struct option lopt[] = {
568
        { "help", 0, NULL, 'h' },
569
        { "version", 0, NULL, 'V' },
570
        { "logfile", 0, NULL, 'l' },
571
        { "pidfile", 0, NULL, 'f' },
572
        { "verbose", 0, NULL, 'v' },
573
        { "method", 0, NULL, 'm' },
574
        { "path", 0, NULL, 'p' },
575
        { "daemonize", 0, NULL, 'd' },
576
        { NULL, 0, NULL, 0 }
577
    };
578
    int opt_ind = 0, ch, daemonize = 0;
579
    GLogLevelFlags log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL;
580
    FILE *log_file = stderr;
581
    GAState *s;
582

  
583
    while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) {
584
        switch (ch) {
585
        case 'm':
586
            method = optarg;
587
            break;
588
        case 'p':
589
            path = optarg;
590
            break;
591
        case 'l':
592
            log_file = fopen(optarg, "a");
593
            if (!log_file) {
594
                g_critical("unable to open specified log file: %s",
595
                           strerror(errno));
596
                return EXIT_FAILURE;
597
            }
598
            break;
599
        case 'f':
600
            pidfile = optarg;
601
            break;
602
        case 'v':
603
            /* enable all log levels */
604
            log_level = G_LOG_LEVEL_MASK;
605
            break;
606
        case 'V':
607
            printf("QEMU Guest Agent %s\n", QGA_VERSION);
608
            return 0;
609
        case 'd':
610
            daemonize = 1;
611
            break;
612
        case 'h':
613
            usage(argv[0]);
614
            return 0;
615
        case '?':
616
            g_print("Unknown option, try '%s --help' for more information.\n",
617
                    argv[0]);
618
            return EXIT_FAILURE;
619
        }
620
    }
621

  
622
    if (daemonize) {
623
        g_debug("starting daemon");
624
        become_daemon(pidfile);
625
    }
626

  
627
    g_type_init();
628
    g_thread_init(NULL);
629

  
630
    s = qemu_mallocz(sizeof(GAState));
631
    s->conn_channel = NULL;
632
    s->path = path;
633
    s->method = method;
634
    s->log_file = log_file;
635
    s->log_level = log_level;
636
    g_log_set_default_handler(ga_log, s);
637
    g_log_set_fatal_mask(NULL, G_LOG_LEVEL_ERROR);
638
    s->logging_enabled = true;
639
    ga_state = s;
640

  
641
    module_call_init(MODULE_INIT_QAPI);
642
    init_guest_agent(ga_state);
643
    register_signal_handlers();
644

  
645
    g_main_loop_run(ga_state->main_loop);
646

  
647
    unlink(pidfile);
648

  
649
    return 0;
650
}
b/qga/guest-agent-core.h
15 15

  
16 16
#define QGA_VERSION "1.0"
17 17

  
18
typedef struct GAState GAState;
18 19
typedef struct GACommandState GACommandState;
19 20

  
20 21
void ga_command_state_add(GACommandState *cs,
......
23 24
void ga_command_state_init_all(GACommandState *cs);
24 25
void ga_command_state_cleanup_all(GACommandState *cs);
25 26
GACommandState *ga_command_state_new(void);
27
bool ga_logging_enabled(GAState *s);
28
void ga_disable_logging(GAState *s);
29
void ga_enable_logging(GAState *s);

Also available in: Unified diff