linux-user: Support for restarting system calls for OpenRISC targets
[qemu.git] / tests / test-qga.c
1 #include "qemu/osdep.h"
2 #include <locale.h>
3 #include <glib.h>
4 #include <glib/gstdio.h>
5 #include <sys/socket.h>
6 #include <sys/un.h>
7
8 #include "libqtest.h"
9
10 typedef struct {
11 char *test_dir;
12 GMainLoop *loop;
13 int fd;
14 GPid pid;
15 } TestFixture;
16
17 static int connect_qga(char *path)
18 {
19 int s, ret, len, i = 0;
20 struct sockaddr_un remote;
21
22 s = socket(AF_UNIX, SOCK_STREAM, 0);
23 g_assert(s != -1);
24
25 remote.sun_family = AF_UNIX;
26 do {
27 strcpy(remote.sun_path, path);
28 len = strlen(remote.sun_path) + sizeof(remote.sun_family);
29 ret = connect(s, (struct sockaddr *)&remote, len);
30 if (ret == -1) {
31 g_usleep(G_USEC_PER_SEC);
32 }
33 if (i++ == 10) {
34 return -1;
35 }
36 } while (ret == -1);
37
38 return s;
39 }
40
41 static void qga_watch(GPid pid, gint status, gpointer user_data)
42 {
43 TestFixture *fixture = user_data;
44
45 g_assert_cmpint(status, ==, 0);
46 g_main_loop_quit(fixture->loop);
47 }
48
49 static void
50 fixture_setup(TestFixture *fixture, gconstpointer data)
51 {
52 const gchar *extra_arg = data;
53 GError *error = NULL;
54 gchar *cwd, *path, *cmd, **argv = NULL;
55
56 fixture->loop = g_main_loop_new(NULL, FALSE);
57
58 fixture->test_dir = g_strdup("/tmp/qgatest.XXXXXX");
59 g_assert_nonnull(mkdtemp(fixture->test_dir));
60
61 path = g_build_filename(fixture->test_dir, "sock", NULL);
62 cwd = g_get_current_dir();
63 cmd = g_strdup_printf("%s%cqemu-ga -m unix-listen -t %s -p %s %s %s",
64 cwd, G_DIR_SEPARATOR,
65 fixture->test_dir, path,
66 getenv("QTEST_LOG") ? "-v" : "",
67 extra_arg ?: "");
68 g_shell_parse_argv(cmd, NULL, &argv, &error);
69 g_assert_no_error(error);
70
71 g_spawn_async(fixture->test_dir, argv, NULL,
72 G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD,
73 NULL, NULL, &fixture->pid, &error);
74 g_assert_no_error(error);
75
76 g_child_watch_add(fixture->pid, qga_watch, fixture);
77
78 fixture->fd = connect_qga(path);
79 g_assert_cmpint(fixture->fd, !=, -1);
80
81 g_strfreev(argv);
82 g_free(cmd);
83 g_free(cwd);
84 g_free(path);
85 }
86
87 static void
88 fixture_tear_down(TestFixture *fixture, gconstpointer data)
89 {
90 gchar *tmp;
91
92 kill(fixture->pid, SIGTERM);
93
94 g_main_loop_run(fixture->loop);
95 g_main_loop_unref(fixture->loop);
96
97 g_spawn_close_pid(fixture->pid);
98
99 tmp = g_build_filename(fixture->test_dir, "foo", NULL);
100 g_unlink(tmp);
101 g_free(tmp);
102
103 tmp = g_build_filename(fixture->test_dir, "qga.state", NULL);
104 g_unlink(tmp);
105 g_free(tmp);
106
107 tmp = g_build_filename(fixture->test_dir, "sock", NULL);
108 g_unlink(tmp);
109 g_free(tmp);
110
111 g_rmdir(fixture->test_dir);
112 g_free(fixture->test_dir);
113 }
114
115 static void qmp_assertion_message_error(const char *domain,
116 const char *file,
117 int line,
118 const char *func,
119 const char *expr,
120 QDict *dict)
121 {
122 const char *class, *desc;
123 char *s;
124 QDict *error;
125
126 error = qdict_get_qdict(dict, "error");
127 class = qdict_get_try_str(error, "class");
128 desc = qdict_get_try_str(error, "desc");
129
130 s = g_strdup_printf("assertion failed %s: %s %s", expr, class, desc);
131 g_assertion_message(domain, file, line, func, s);
132 g_free(s);
133 }
134
135 #define qmp_assert_no_error(err) do { \
136 if (qdict_haskey(err, "error")) { \
137 qmp_assertion_message_error(G_LOG_DOMAIN, __FILE__, __LINE__, \
138 G_STRFUNC, #err, err); \
139 } \
140 } while (0)
141
142 static void test_qga_sync_delimited(gconstpointer fix)
143 {
144 const TestFixture *fixture = fix;
145 guint32 v, r = g_random_int();
146 unsigned char c;
147 QDict *ret;
148 gchar *cmd;
149
150 cmd = g_strdup_printf("%c{'execute': 'guest-sync-delimited',"
151 " 'arguments': {'id': %u } }", 0xff, r);
152 qmp_fd_send(fixture->fd, cmd);
153 g_free(cmd);
154
155 v = read(fixture->fd, &c, 1);
156 g_assert_cmpint(v, ==, 1);
157 g_assert_cmpint(c, ==, 0xff);
158
159 ret = qmp_fd_receive(fixture->fd);
160 g_assert_nonnull(ret);
161 qmp_assert_no_error(ret);
162
163 v = qdict_get_int(ret, "return");
164 g_assert_cmpint(r, ==, v);
165
166 QDECREF(ret);
167 }
168
169 static void test_qga_sync(gconstpointer fix)
170 {
171 const TestFixture *fixture = fix;
172 guint32 v, r = g_random_int();
173 QDict *ret;
174 gchar *cmd;
175
176 cmd = g_strdup_printf("%c{'execute': 'guest-sync',"
177 " 'arguments': {'id': %u } }", 0xff, r);
178 ret = qmp_fd(fixture->fd, cmd);
179 g_free(cmd);
180
181 g_assert_nonnull(ret);
182 qmp_assert_no_error(ret);
183
184 v = qdict_get_int(ret, "return");
185 g_assert_cmpint(r, ==, v);
186
187 QDECREF(ret);
188 }
189
190 static void test_qga_ping(gconstpointer fix)
191 {
192 const TestFixture *fixture = fix;
193 QDict *ret;
194
195 ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping'}");
196 g_assert_nonnull(ret);
197 qmp_assert_no_error(ret);
198
199 QDECREF(ret);
200 }
201
202 static void test_qga_invalid_cmd(gconstpointer fix)
203 {
204 const TestFixture *fixture = fix;
205 QDict *ret, *error;
206 const gchar *class, *desc;
207
208 ret = qmp_fd(fixture->fd, "{'execute': 'guest-invalid-cmd'}");
209 g_assert_nonnull(ret);
210
211 error = qdict_get_qdict(ret, "error");
212 class = qdict_get_try_str(error, "class");
213 desc = qdict_get_try_str(error, "desc");
214
215 g_assert_cmpstr(class, ==, "CommandNotFound");
216 g_assert_cmpint(strlen(desc), >, 0);
217
218 QDECREF(ret);
219 }
220
221 static void test_qga_info(gconstpointer fix)
222 {
223 const TestFixture *fixture = fix;
224 QDict *ret, *val;
225 const gchar *version;
226
227 ret = qmp_fd(fixture->fd, "{'execute': 'guest-info'}");
228 g_assert_nonnull(ret);
229 qmp_assert_no_error(ret);
230
231 val = qdict_get_qdict(ret, "return");
232 version = qdict_get_try_str(val, "version");
233 g_assert_cmpstr(version, ==, QEMU_VERSION);
234
235 QDECREF(ret);
236 }
237
238 static void test_qga_get_vcpus(gconstpointer fix)
239 {
240 const TestFixture *fixture = fix;
241 QDict *ret;
242 QList *list;
243 const QListEntry *entry;
244
245 ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-vcpus'}");
246 g_assert_nonnull(ret);
247 qmp_assert_no_error(ret);
248
249 /* check there is at least a cpu */
250 list = qdict_get_qlist(ret, "return");
251 entry = qlist_first(list);
252 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online"));
253 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "logical-id"));
254
255 QDECREF(ret);
256 }
257
258 static void test_qga_get_fsinfo(gconstpointer fix)
259 {
260 const TestFixture *fixture = fix;
261 QDict *ret;
262 QList *list;
263 const QListEntry *entry;
264
265 ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-fsinfo'}");
266 g_assert_nonnull(ret);
267 qmp_assert_no_error(ret);
268
269 /* sanity-check the response if there are any filesystems */
270 list = qdict_get_qlist(ret, "return");
271 entry = qlist_first(list);
272 if (entry) {
273 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name"));
274 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "mountpoint"));
275 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "type"));
276 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "disk"));
277 }
278
279 QDECREF(ret);
280 }
281
282 static void test_qga_get_memory_block_info(gconstpointer fix)
283 {
284 const TestFixture *fixture = fix;
285 QDict *ret, *val;
286 int64_t size;
287
288 ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-block-info'}");
289 g_assert_nonnull(ret);
290
291 /* some systems might not expose memory block info in sysfs */
292 if (!qdict_haskey(ret, "error")) {
293 /* check there is at least some memory */
294 val = qdict_get_qdict(ret, "return");
295 size = qdict_get_int(val, "size");
296 g_assert_cmpint(size, >, 0);
297 }
298
299 QDECREF(ret);
300 }
301
302 static void test_qga_get_memory_blocks(gconstpointer fix)
303 {
304 const TestFixture *fixture = fix;
305 QDict *ret;
306 QList *list;
307 const QListEntry *entry;
308
309 ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-blocks'}");
310 g_assert_nonnull(ret);
311
312 /* some systems might not expose memory block info in sysfs */
313 if (!qdict_haskey(ret, "error")) {
314 list = qdict_get_qlist(ret, "return");
315 entry = qlist_first(list);
316 /* newer versions of qga may return empty list without error */
317 if (entry) {
318 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "phys-index"));
319 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online"));
320 }
321 }
322
323 QDECREF(ret);
324 }
325
326 static void test_qga_network_get_interfaces(gconstpointer fix)
327 {
328 const TestFixture *fixture = fix;
329 QDict *ret;
330 QList *list;
331 const QListEntry *entry;
332
333 ret = qmp_fd(fixture->fd, "{'execute': 'guest-network-get-interfaces'}");
334 g_assert_nonnull(ret);
335 qmp_assert_no_error(ret);
336
337 /* check there is at least an interface */
338 list = qdict_get_qlist(ret, "return");
339 entry = qlist_first(list);
340 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name"));
341
342 QDECREF(ret);
343 }
344
345 static void test_qga_file_ops(gconstpointer fix)
346 {
347 const TestFixture *fixture = fix;
348 const unsigned char helloworld[] = "Hello World!\n";
349 const char *b64;
350 gchar *cmd, *path, *enc;
351 unsigned char *dec;
352 QDict *ret, *val;
353 int64_t id, eof;
354 gsize count;
355 FILE *f;
356 char tmp[100];
357
358 /* open */
359 ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open',"
360 " 'arguments': { 'path': 'foo', 'mode': 'w+' } }");
361 g_assert_nonnull(ret);
362 qmp_assert_no_error(ret);
363 id = qdict_get_int(ret, "return");
364 QDECREF(ret);
365
366 enc = g_base64_encode(helloworld, sizeof(helloworld));
367 /* write */
368 cmd = g_strdup_printf("{'execute': 'guest-file-write',"
369 " 'arguments': { 'handle': %" PRId64 ","
370 " 'buf-b64': '%s' } }", id, enc);
371 ret = qmp_fd(fixture->fd, cmd);
372 g_assert_nonnull(ret);
373 qmp_assert_no_error(ret);
374
375 val = qdict_get_qdict(ret, "return");
376 count = qdict_get_int(val, "count");
377 eof = qdict_get_bool(val, "eof");
378 g_assert_cmpint(count, ==, sizeof(helloworld));
379 g_assert_cmpint(eof, ==, 0);
380 QDECREF(ret);
381 g_free(cmd);
382
383 /* flush */
384 cmd = g_strdup_printf("{'execute': 'guest-file-flush',"
385 " 'arguments': {'handle': %" PRId64 "} }",
386 id);
387 ret = qmp_fd(fixture->fd, cmd);
388 QDECREF(ret);
389 g_free(cmd);
390
391 /* close */
392 cmd = g_strdup_printf("{'execute': 'guest-file-close',"
393 " 'arguments': {'handle': %" PRId64 "} }",
394 id);
395 ret = qmp_fd(fixture->fd, cmd);
396 QDECREF(ret);
397 g_free(cmd);
398
399 /* check content */
400 path = g_build_filename(fixture->test_dir, "foo", NULL);
401 f = fopen(path, "r");
402 g_assert_nonnull(f);
403 count = fread(tmp, 1, sizeof(tmp), f);
404 g_assert_cmpint(count, ==, sizeof(helloworld));
405 tmp[count] = 0;
406 g_assert_cmpstr(tmp, ==, (char *)helloworld);
407 fclose(f);
408
409 /* open */
410 ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open',"
411 " 'arguments': { 'path': 'foo', 'mode': 'r' } }");
412 g_assert_nonnull(ret);
413 qmp_assert_no_error(ret);
414 id = qdict_get_int(ret, "return");
415 QDECREF(ret);
416
417 /* read */
418 cmd = g_strdup_printf("{'execute': 'guest-file-read',"
419 " 'arguments': { 'handle': %" PRId64 "} }",
420 id);
421 ret = qmp_fd(fixture->fd, cmd);
422 val = qdict_get_qdict(ret, "return");
423 count = qdict_get_int(val, "count");
424 eof = qdict_get_bool(val, "eof");
425 b64 = qdict_get_str(val, "buf-b64");
426 g_assert_cmpint(count, ==, sizeof(helloworld));
427 g_assert(eof);
428 g_assert_cmpstr(b64, ==, enc);
429
430 QDECREF(ret);
431 g_free(cmd);
432 g_free(enc);
433
434 /* read eof */
435 cmd = g_strdup_printf("{'execute': 'guest-file-read',"
436 " 'arguments': { 'handle': %" PRId64 "} }",
437 id);
438 ret = qmp_fd(fixture->fd, cmd);
439 val = qdict_get_qdict(ret, "return");
440 count = qdict_get_int(val, "count");
441 eof = qdict_get_bool(val, "eof");
442 b64 = qdict_get_str(val, "buf-b64");
443 g_assert_cmpint(count, ==, 0);
444 g_assert(eof);
445 g_assert_cmpstr(b64, ==, "");
446 QDECREF(ret);
447 g_free(cmd);
448
449 /* seek */
450 cmd = g_strdup_printf("{'execute': 'guest-file-seek',"
451 " 'arguments': { 'handle': %" PRId64 ", "
452 " 'offset': %d, 'whence': '%s' } }",
453 id, 6, "set");
454 ret = qmp_fd(fixture->fd, cmd);
455 qmp_assert_no_error(ret);
456 val = qdict_get_qdict(ret, "return");
457 count = qdict_get_int(val, "position");
458 eof = qdict_get_bool(val, "eof");
459 g_assert_cmpint(count, ==, 6);
460 g_assert(!eof);
461 QDECREF(ret);
462 g_free(cmd);
463
464 /* partial read */
465 cmd = g_strdup_printf("{'execute': 'guest-file-read',"
466 " 'arguments': { 'handle': %" PRId64 "} }",
467 id);
468 ret = qmp_fd(fixture->fd, cmd);
469 val = qdict_get_qdict(ret, "return");
470 count = qdict_get_int(val, "count");
471 eof = qdict_get_bool(val, "eof");
472 b64 = qdict_get_str(val, "buf-b64");
473 g_assert_cmpint(count, ==, sizeof(helloworld) - 6);
474 g_assert(eof);
475 dec = g_base64_decode(b64, &count);
476 g_assert_cmpint(count, ==, sizeof(helloworld) - 6);
477 g_assert_cmpmem(dec, count, helloworld + 6, sizeof(helloworld) - 6);
478 g_free(dec);
479
480 QDECREF(ret);
481 g_free(cmd);
482
483 /* close */
484 cmd = g_strdup_printf("{'execute': 'guest-file-close',"
485 " 'arguments': {'handle': %" PRId64 "} }",
486 id);
487 ret = qmp_fd(fixture->fd, cmd);
488 QDECREF(ret);
489 g_free(cmd);
490 }
491
492 static void test_qga_file_write_read(gconstpointer fix)
493 {
494 const TestFixture *fixture = fix;
495 const unsigned char helloworld[] = "Hello World!\n";
496 const char *b64;
497 gchar *cmd, *enc;
498 QDict *ret, *val;
499 int64_t id, eof;
500 gsize count;
501
502 /* open */
503 ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open',"
504 " 'arguments': { 'path': 'foo', 'mode': 'w+' } }");
505 g_assert_nonnull(ret);
506 qmp_assert_no_error(ret);
507 id = qdict_get_int(ret, "return");
508 QDECREF(ret);
509
510 enc = g_base64_encode(helloworld, sizeof(helloworld));
511 /* write */
512 cmd = g_strdup_printf("{'execute': 'guest-file-write',"
513 " 'arguments': { 'handle': %" PRId64 ","
514 " 'buf-b64': '%s' } }", id, enc);
515 ret = qmp_fd(fixture->fd, cmd);
516 g_assert_nonnull(ret);
517 qmp_assert_no_error(ret);
518
519 val = qdict_get_qdict(ret, "return");
520 count = qdict_get_int(val, "count");
521 eof = qdict_get_bool(val, "eof");
522 g_assert_cmpint(count, ==, sizeof(helloworld));
523 g_assert_cmpint(eof, ==, 0);
524 QDECREF(ret);
525 g_free(cmd);
526
527 /* read (check implicit flush) */
528 cmd = g_strdup_printf("{'execute': 'guest-file-read',"
529 " 'arguments': { 'handle': %" PRId64 "} }",
530 id);
531 ret = qmp_fd(fixture->fd, cmd);
532 val = qdict_get_qdict(ret, "return");
533 count = qdict_get_int(val, "count");
534 eof = qdict_get_bool(val, "eof");
535 b64 = qdict_get_str(val, "buf-b64");
536 g_assert_cmpint(count, ==, 0);
537 g_assert(eof);
538 g_assert_cmpstr(b64, ==, "");
539 QDECREF(ret);
540 g_free(cmd);
541
542 /* seek to 0 */
543 cmd = g_strdup_printf("{'execute': 'guest-file-seek',"
544 " 'arguments': { 'handle': %" PRId64 ", "
545 " 'offset': %d, 'whence': '%s' } }",
546 id, 0, "set");
547 ret = qmp_fd(fixture->fd, cmd);
548 qmp_assert_no_error(ret);
549 val = qdict_get_qdict(ret, "return");
550 count = qdict_get_int(val, "position");
551 eof = qdict_get_bool(val, "eof");
552 g_assert_cmpint(count, ==, 0);
553 g_assert(!eof);
554 QDECREF(ret);
555 g_free(cmd);
556
557 /* read */
558 cmd = g_strdup_printf("{'execute': 'guest-file-read',"
559 " 'arguments': { 'handle': %" PRId64 "} }",
560 id);
561 ret = qmp_fd(fixture->fd, cmd);
562 val = qdict_get_qdict(ret, "return");
563 count = qdict_get_int(val, "count");
564 eof = qdict_get_bool(val, "eof");
565 b64 = qdict_get_str(val, "buf-b64");
566 g_assert_cmpint(count, ==, sizeof(helloworld));
567 g_assert(eof);
568 g_assert_cmpstr(b64, ==, enc);
569 QDECREF(ret);
570 g_free(cmd);
571 g_free(enc);
572
573 /* close */
574 cmd = g_strdup_printf("{'execute': 'guest-file-close',"
575 " 'arguments': {'handle': %" PRId64 "} }",
576 id);
577 ret = qmp_fd(fixture->fd, cmd);
578 QDECREF(ret);
579 g_free(cmd);
580 }
581
582 static void test_qga_get_time(gconstpointer fix)
583 {
584 const TestFixture *fixture = fix;
585 QDict *ret;
586 int64_t time;
587
588 ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}");
589 g_assert_nonnull(ret);
590 qmp_assert_no_error(ret);
591
592 time = qdict_get_int(ret, "return");
593 g_assert_cmpint(time, >, 0);
594
595 QDECREF(ret);
596 }
597
598 static void test_qga_set_time(gconstpointer fix)
599 {
600 const TestFixture *fixture = fix;
601 QDict *ret;
602 int64_t current, time;
603 gchar *cmd;
604
605 /* get current time */
606 ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}");
607 g_assert_nonnull(ret);
608 qmp_assert_no_error(ret);
609 current = qdict_get_int(ret, "return");
610 g_assert_cmpint(current, >, 0);
611 QDECREF(ret);
612
613 /* set some old time */
614 ret = qmp_fd(fixture->fd, "{'execute': 'guest-set-time',"
615 " 'arguments': { 'time': 1000 } }");
616 g_assert_nonnull(ret);
617 qmp_assert_no_error(ret);
618 QDECREF(ret);
619
620 /* check old time */
621 ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}");
622 g_assert_nonnull(ret);
623 qmp_assert_no_error(ret);
624 time = qdict_get_int(ret, "return");
625 g_assert_cmpint(time / 1000, <, G_USEC_PER_SEC * 10);
626 QDECREF(ret);
627
628 /* set back current time */
629 cmd = g_strdup_printf("{'execute': 'guest-set-time',"
630 " 'arguments': { 'time': %" PRId64 " } }",
631 current + time * 1000);
632 ret = qmp_fd(fixture->fd, cmd);
633 g_free(cmd);
634 g_assert_nonnull(ret);
635 qmp_assert_no_error(ret);
636 QDECREF(ret);
637 }
638
639 static void test_qga_fstrim(gconstpointer fix)
640 {
641 const TestFixture *fixture = fix;
642 QDict *ret;
643 QList *list;
644 const QListEntry *entry;
645
646 ret = qmp_fd(fixture->fd, "{'execute': 'guest-fstrim',"
647 " arguments: { minimum: 4194304 } }");
648 g_assert_nonnull(ret);
649 qmp_assert_no_error(ret);
650 list = qdict_get_qlist(ret, "return");
651 entry = qlist_first(list);
652 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "paths"));
653
654 QDECREF(ret);
655 }
656
657 static void test_qga_blacklist(gconstpointer data)
658 {
659 TestFixture fix;
660 QDict *ret, *error;
661 const gchar *class, *desc;
662
663 fixture_setup(&fix, "-b guest-ping,guest-get-time");
664
665 /* check blacklist */
666 ret = qmp_fd(fix.fd, "{'execute': 'guest-ping'}");
667 g_assert_nonnull(ret);
668 error = qdict_get_qdict(ret, "error");
669 class = qdict_get_try_str(error, "class");
670 desc = qdict_get_try_str(error, "desc");
671 g_assert_cmpstr(class, ==, "GenericError");
672 g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
673 QDECREF(ret);
674
675 ret = qmp_fd(fix.fd, "{'execute': 'guest-get-time'}");
676 g_assert_nonnull(ret);
677 error = qdict_get_qdict(ret, "error");
678 class = qdict_get_try_str(error, "class");
679 desc = qdict_get_try_str(error, "desc");
680 g_assert_cmpstr(class, ==, "GenericError");
681 g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
682 QDECREF(ret);
683
684 /* check something work */
685 ret = qmp_fd(fix.fd, "{'execute': 'guest-get-fsinfo'}");
686 qmp_assert_no_error(ret);
687 QDECREF(ret);
688
689 fixture_tear_down(&fix, NULL);
690 }
691
692 static void test_qga_config(gconstpointer data)
693 {
694 GError *error = NULL;
695 char *cwd, *cmd, *out, *err, *str, **strv, *conf, **argv = NULL;
696 char *env[2];
697 int status, tmp;
698 gsize n;
699 GKeyFile *kf;
700 const char *qga_config =
701 "[general]\n"
702 "daemon=false\n"
703 "method=virtio-serial\n"
704 "path=/path/to/org.qemu.guest_agent.0\n"
705 "pidfile=/var/foo/qemu-ga.pid\n"
706 "statedir=/var/state\n"
707 "verbose=true\n"
708 "blacklist=guest-ping;guest-get-time\n";
709
710 tmp = g_file_open_tmp(NULL, &conf, &error);
711 g_assert_no_error(error);
712 g_assert_cmpint(tmp, >=, 0);
713 g_assert_cmpstr(conf, !=, "");
714
715 g_file_set_contents(conf, qga_config, -1, &error);
716 g_assert_no_error(error);
717
718 cwd = g_get_current_dir();
719 cmd = g_strdup_printf("%s%cqemu-ga -D",
720 cwd, G_DIR_SEPARATOR);
721 g_shell_parse_argv(cmd, NULL, &argv, &error);
722 g_assert_no_error(error);
723
724 env[0] = g_strdup_printf("QGA_CONF=%s", conf);
725 env[1] = NULL;
726 g_spawn_sync(NULL, argv, env, 0,
727 NULL, NULL, &out, &err, &status, &error);
728 g_assert_no_error(error);
729 g_assert_cmpstr(err, ==, "");
730 g_assert_cmpint(status, ==, 0);
731
732 kf = g_key_file_new();
733 g_key_file_load_from_data(kf, out, -1, G_KEY_FILE_NONE, &error);
734 g_assert_no_error(error);
735
736 str = g_key_file_get_start_group(kf);
737 g_assert_cmpstr(str, ==, "general");
738 g_free(str);
739
740 g_assert_false(g_key_file_get_boolean(kf, "general", "daemon", &error));
741 g_assert_no_error(error);
742
743 str = g_key_file_get_string(kf, "general", "method", &error);
744 g_assert_no_error(error);
745 g_assert_cmpstr(str, ==, "virtio-serial");
746 g_free(str);
747
748 str = g_key_file_get_string(kf, "general", "path", &error);
749 g_assert_no_error(error);
750 g_assert_cmpstr(str, ==, "/path/to/org.qemu.guest_agent.0");
751 g_free(str);
752
753 str = g_key_file_get_string(kf, "general", "pidfile", &error);
754 g_assert_no_error(error);
755 g_assert_cmpstr(str, ==, "/var/foo/qemu-ga.pid");
756 g_free(str);
757
758 str = g_key_file_get_string(kf, "general", "statedir", &error);
759 g_assert_no_error(error);
760 g_assert_cmpstr(str, ==, "/var/state");
761 g_free(str);
762
763 g_assert_true(g_key_file_get_boolean(kf, "general", "verbose", &error));
764 g_assert_no_error(error);
765
766 strv = g_key_file_get_string_list(kf, "general", "blacklist", &n, &error);
767 g_assert_cmpint(n, ==, 2);
768 #if GLIB_CHECK_VERSION(2, 44, 0)
769 g_assert_true(g_strv_contains((const char * const *)strv,
770 "guest-ping"));
771 g_assert_true(g_strv_contains((const char * const *)strv,
772 "guest-get-time"));
773 #endif
774 g_assert_no_error(error);
775 g_strfreev(strv);
776
777 g_free(out);
778 g_free(err);
779 g_free(conf);
780 g_free(env[0]);
781 g_key_file_free(kf);
782
783 close(tmp);
784 }
785
786 static void test_qga_fsfreeze_status(gconstpointer fix)
787 {
788 const TestFixture *fixture = fix;
789 QDict *ret;
790 const gchar *status;
791
792 ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-status'}");
793 g_assert_nonnull(ret);
794 qmp_assert_no_error(ret);
795
796 status = qdict_get_try_str(ret, "return");
797 g_assert_cmpstr(status, ==, "thawed");
798
799 QDECREF(ret);
800 }
801
802 static void test_qga_fsfreeze_and_thaw(gconstpointer fix)
803 {
804 const TestFixture *fixture = fix;
805 QDict *ret;
806 const gchar *status;
807
808 ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-freeze'}");
809 g_assert_nonnull(ret);
810 qmp_assert_no_error(ret);
811 QDECREF(ret);
812
813 ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-status'}");
814 g_assert_nonnull(ret);
815 qmp_assert_no_error(ret);
816 status = qdict_get_try_str(ret, "return");
817 g_assert_cmpstr(status, ==, "frozen");
818 QDECREF(ret);
819
820 ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-thaw'}");
821 g_assert_nonnull(ret);
822 qmp_assert_no_error(ret);
823 QDECREF(ret);
824 }
825
826 int main(int argc, char **argv)
827 {
828 TestFixture fix;
829 int ret;
830
831 setlocale (LC_ALL, "");
832 g_test_init(&argc, &argv, NULL);
833 fixture_setup(&fix, NULL);
834
835 g_test_add_data_func("/qga/sync-delimited", &fix, test_qga_sync_delimited);
836 g_test_add_data_func("/qga/sync", &fix, test_qga_sync);
837 g_test_add_data_func("/qga/ping", &fix, test_qga_ping);
838 g_test_add_data_func("/qga/info", &fix, test_qga_info);
839 g_test_add_data_func("/qga/network-get-interfaces", &fix,
840 test_qga_network_get_interfaces);
841 g_test_add_data_func("/qga/get-vcpus", &fix, test_qga_get_vcpus);
842 g_test_add_data_func("/qga/get-fsinfo", &fix, test_qga_get_fsinfo);
843 g_test_add_data_func("/qga/get-memory-block-info", &fix,
844 test_qga_get_memory_block_info);
845 g_test_add_data_func("/qga/get-memory-blocks", &fix,
846 test_qga_get_memory_blocks);
847 g_test_add_data_func("/qga/file-ops", &fix, test_qga_file_ops);
848 g_test_add_data_func("/qga/file-write-read", &fix, test_qga_file_write_read);
849 g_test_add_data_func("/qga/get-time", &fix, test_qga_get_time);
850 g_test_add_data_func("/qga/invalid-cmd", &fix, test_qga_invalid_cmd);
851 g_test_add_data_func("/qga/fsfreeze-status", &fix,
852 test_qga_fsfreeze_status);
853
854 g_test_add_data_func("/qga/blacklist", NULL, test_qga_blacklist);
855 g_test_add_data_func("/qga/config", NULL, test_qga_config);
856
857 if (g_getenv("QGA_TEST_SIDE_EFFECTING")) {
858 g_test_add_data_func("/qga/fsfreeze-and-thaw", &fix,
859 test_qga_fsfreeze_and_thaw);
860 g_test_add_data_func("/qga/set-time", &fix, test_qga_set_time);
861 g_test_add_data_func("/qga/fstrim", &fix, test_qga_fstrim);
862 }
863
864 ret = g_test_run();
865
866 fixture_tear_down(&fix, NULL);
867
868 return ret;
869 }