1 #include "qemu/osdep.h"
2 #include <glib/gstdio.h>
3 #include <gio/gio.h>
4 #include "libqtest.h"
5 #include "dbus-vmstate1.h"
6 #include "migration-helpers.h"
7 
8 static char *workdir;
9 
10 typedef struct TestServerId {
11     const char *name;
12     const char *data;
13     size_t size;
14 } TestServerId;
15 
16 static const TestServerId idA = {
17     "idA", "I'am\0idA!", sizeof("I'am\0idA!")
18 };
19 
20 static const TestServerId idB = {
21     "idB", "I'am\0idB!", sizeof("I'am\0idB!")
22 };
23 
24 typedef struct TestServer {
25     const TestServerId *id;
26     bool save_called;
27     bool load_called;
28 } TestServer;
29 
30 typedef struct Test {
31     const char *id_list;
32     bool migrate_fail;
33     bool without_dst_b;
34     TestServer srcA;
35     TestServer dstA;
36     TestServer srcB;
37     TestServer dstB;
38     GMainLoop *loop;
39     QTestState *src_qemu;
40 } Test;
41 
42 static gboolean
43 vmstate_load(VMState1 *object, GDBusMethodInvocation *invocation,
44              const gchar *arg_data, gpointer user_data)
45 {
46     TestServer *h = user_data;
47     g_autoptr(GVariant) var = NULL;
48     GVariant *args;
49     const uint8_t *data;
50     size_t size;
51 
52     args = g_dbus_method_invocation_get_parameters(invocation);
53     var = g_variant_get_child_value(args, 0);
54     data = g_variant_get_fixed_array(var, &size, sizeof(char));
55     g_assert_cmpuint(size, ==, h->id->size);
56     g_assert(!memcmp(data, h->id->data, h->id->size));
57     h->load_called = true;
58 
59     g_dbus_method_invocation_return_value(invocation, g_variant_new("()"));
60     return TRUE;
61 }
62 
63 static gboolean
64 vmstate_save(VMState1 *object, GDBusMethodInvocation *invocation,
65              gpointer user_data)
66 {
67     TestServer *h = user_data;
68     GVariant *var;
69 
70     var = g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE,
71                                     h->id->data, h->id->size, sizeof(char));
72     g_dbus_method_invocation_return_value(invocation,
73                                           g_variant_new("(@ay)", var));
74     h->save_called = true;
75 
76     return TRUE;
77 }
78 
79 typedef struct WaitNamed {
80     GMainLoop *loop;
81     bool named;
82 } WaitNamed;
83 
84 static void
85 named_cb(GDBusConnection *connection,
86          const gchar *name,
87          gpointer user_data)
88 {
89     WaitNamed *t = user_data;
90 
91     t->named = true;
92     g_main_loop_quit(t->loop);
93 }
94 
95 static GDBusConnection *
96 get_connection(Test *test, guint *ownid)
97 {
98     g_autofree gchar *addr = NULL;
99     WaitNamed *wait;
100     GError *err = NULL;
101     GDBusConnection *c;
102 
103     wait = g_new0(WaitNamed, 1);
104     wait->loop = test->loop;
105     addr = g_dbus_address_get_for_bus_sync(G_BUS_TYPE_SESSION, NULL, &err);
106     g_assert_no_error(err);
107 
108     c = g_dbus_connection_new_for_address_sync(
109         addr,
110         G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION |
111         G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
112         NULL, NULL, &err);
113     g_assert_no_error(err);
114     *ownid = g_bus_own_name_on_connection(c, "org.qemu.VMState1",
115                                           G_BUS_NAME_OWNER_FLAGS_NONE,
116                                           named_cb, named_cb, wait, g_free);
117     if (!wait->named) {
118         g_main_loop_run(wait->loop);
119     }
120 
121     return c;
122 }
123 
124 static GDBusObjectManagerServer *
125 get_server(GDBusConnection *conn, TestServer *s, const TestServerId *id)
126 {
127     g_autoptr(GDBusObjectSkeleton) sk = NULL;
128     g_autoptr(VMState1Skeleton) v = NULL;
129     GDBusObjectManagerServer *os;
130 
131     s->id = id;
132     os = g_dbus_object_manager_server_new("/org/qemu");
133     sk = g_dbus_object_skeleton_new("/org/qemu/VMState1");
134 
135     v = VMSTATE1_SKELETON(vmstate1_skeleton_new());
136     g_object_set(v, "id", id->name, NULL);
137 
138     g_signal_connect(v, "handle-load", G_CALLBACK(vmstate_load), s);
139     g_signal_connect(v, "handle-save", G_CALLBACK(vmstate_save), s);
140 
141     g_dbus_object_skeleton_add_interface(sk, G_DBUS_INTERFACE_SKELETON(v));
142     g_dbus_object_manager_server_export(os, sk);
143     g_dbus_object_manager_server_set_connection(os, conn);
144 
145     return os;
146 }
147 
148 static void
149 set_id_list(Test *test, QTestState *s)
150 {
151     if (!test->id_list) {
152         return;
153     }
154 
155     g_assert(!qmp_rsp_is_err(qtest_qmp(s,
156         "{ 'execute': 'qom-set', 'arguments': "
157         "{ 'path': '/objects/dv', 'property': 'id-list', 'value': %s } }",
158         test->id_list)));
159 }
160 
161 static gpointer
162 dbus_vmstate_thread(gpointer data)
163 {
164     GMainLoop *loop = data;
165 
166     g_main_loop_run(loop);
167 
168     return NULL;
169 }
170 
171 static void
172 test_dbus_vmstate(Test *test)
173 {
174     g_autofree char *src_qemu_args = NULL;
175     g_autofree char *dst_qemu_args = NULL;
176     g_autoptr(GTestDBus) srcbus = NULL;
177     g_autoptr(GTestDBus) dstbus = NULL;
178     g_autoptr(GDBusConnection) srcconnA = NULL;
179     g_autoptr(GDBusConnection) srcconnB = NULL;
180     g_autoptr(GDBusConnection) dstconnA = NULL;
181     g_autoptr(GDBusConnection) dstconnB = NULL;
182     g_autoptr(GDBusObjectManagerServer) srcserverA = NULL;
183     g_autoptr(GDBusObjectManagerServer) srcserverB = NULL;
184     g_autoptr(GDBusObjectManagerServer) dstserverA = NULL;
185     g_autoptr(GDBusObjectManagerServer) dstserverB = NULL;
186     g_auto(GStrv) srcaddr = NULL;
187     g_auto(GStrv) dstaddr = NULL;
188     g_autoptr(GThread) thread = NULL;
189     g_autoptr(GMainLoop) loop = NULL;
190     g_autofree char *uri = NULL;
191     QTestState *src_qemu = NULL, *dst_qemu = NULL;
192     guint ownsrcA, ownsrcB, owndstA, owndstB;
193 
194     uri = g_strdup_printf("unix:%s/migsocket", workdir);
195 
196     loop = g_main_loop_new(NULL, FALSE);
197     test->loop = loop;
198 
199     srcbus = g_test_dbus_new(G_TEST_DBUS_NONE);
200     g_test_dbus_up(srcbus);
201     srcconnA = get_connection(test, &ownsrcA);
202     srcserverA = get_server(srcconnA, &test->srcA, &idA);
203     srcconnB = get_connection(test, &ownsrcB);
204     srcserverB = get_server(srcconnB, &test->srcB, &idB);
205 
206     /* remove ,guid=foo part */
207     srcaddr = g_strsplit(g_test_dbus_get_bus_address(srcbus), ",", 2);
208     src_qemu_args =
209         g_strdup_printf("-object dbus-vmstate,id=dv,addr=%s", srcaddr[0]);
210 
211     dstbus = g_test_dbus_new(G_TEST_DBUS_NONE);
212     g_test_dbus_up(dstbus);
213     dstconnA = get_connection(test, &owndstA);
214     dstserverA = get_server(dstconnA, &test->dstA, &idA);
215     if (!test->without_dst_b) {
216         dstconnB = get_connection(test, &owndstB);
217         dstserverB = get_server(dstconnB, &test->dstB, &idB);
218     }
219 
220     dstaddr = g_strsplit(g_test_dbus_get_bus_address(dstbus), ",", 2);
221     dst_qemu_args =
222         g_strdup_printf("-object dbus-vmstate,id=dv,addr=%s -incoming %s",
223                         dstaddr[0], uri);
224 
225     src_qemu = qtest_init(src_qemu_args);
226     dst_qemu = qtest_init(dst_qemu_args);
227     set_id_list(test, src_qemu);
228     set_id_list(test, dst_qemu);
229 
230     thread = g_thread_new("dbus-vmstate-thread", dbus_vmstate_thread, loop);
231 
232     migrate_qmp(src_qemu, uri, "{}");
233     test->src_qemu = src_qemu;
234     if (test->migrate_fail) {
235         wait_for_migration_fail(src_qemu, true);
236         qtest_set_expected_status(dst_qemu, 1);
237     } else {
238         wait_for_migration_complete(src_qemu);
239     }
240 
241     qtest_quit(dst_qemu);
242     qtest_quit(src_qemu);
243     g_bus_unown_name(ownsrcA);
244     g_bus_unown_name(ownsrcB);
245     g_bus_unown_name(owndstA);
246     if (!test->without_dst_b) {
247         g_bus_unown_name(owndstB);
248     }
249 
250     g_main_loop_quit(test->loop);
251 }
252 
253 static void
254 check_not_migrated(TestServer *s, TestServer *d)
255 {
256     assert(!s->save_called);
257     assert(!s->load_called);
258     assert(!d->save_called);
259     assert(!d->load_called);
260 }
261 
262 static void
263 check_migrated(TestServer *s, TestServer *d)
264 {
265     assert(s->save_called);
266     assert(!s->load_called);
267     assert(!d->save_called);
268     assert(d->load_called);
269 }
270 
271 static void
272 test_dbus_vmstate_without_list(void)
273 {
274     Test test = { 0, };
275 
276     test_dbus_vmstate(&test);
277 
278     check_migrated(&test.srcA, &test.dstA);
279     check_migrated(&test.srcB, &test.dstB);
280 }
281 
282 static void
283 test_dbus_vmstate_with_list(void)
284 {
285     Test test = { .id_list = "idA,idB" };
286 
287     test_dbus_vmstate(&test);
288 
289     check_migrated(&test.srcA, &test.dstA);
290     check_migrated(&test.srcB, &test.dstB);
291 }
292 
293 static void
294 test_dbus_vmstate_only_a(void)
295 {
296     Test test = { .id_list = "idA" };
297 
298     test_dbus_vmstate(&test);
299 
300     check_migrated(&test.srcA, &test.dstA);
301     check_not_migrated(&test.srcB, &test.dstB);
302 }
303 
304 static void
305 test_dbus_vmstate_missing_src(void)
306 {
307     Test test = { .id_list = "idA,idC", .migrate_fail = true };
308 
309     /* run in subprocess to silence QEMU error reporting */
310     if (g_test_subprocess()) {
311         test_dbus_vmstate(&test);
312         check_not_migrated(&test.srcA, &test.dstA);
313         check_not_migrated(&test.srcB, &test.dstB);
314         return;
315     }
316 
317     g_test_trap_subprocess(NULL, 0, 0);
318     g_test_trap_assert_passed();
319 }
320 
321 static void
322 test_dbus_vmstate_missing_dst(void)
323 {
324     Test test = { .id_list = "idA,idB",
325                   .without_dst_b = true,
326                   .migrate_fail = true };
327 
328     /* run in subprocess to silence QEMU error reporting */
329     if (g_test_subprocess()) {
330         test_dbus_vmstate(&test);
331         assert(test.srcA.save_called);
332         assert(test.srcB.save_called);
333         assert(!test.dstB.save_called);
334         return;
335     }
336 
337     g_test_trap_subprocess(NULL, 0, 0);
338     g_test_trap_assert_passed();
339 }
340 
341 int
342 main(int argc, char **argv)
343 {
344     GError *err = NULL;
345     g_autofree char *dbus_daemon = NULL;
346     int ret;
347 
348     dbus_daemon = g_build_filename(G_STRINGIFY(SRCDIR),
349                                    "tests",
350                                    "dbus-vmstate-daemon.sh",
351                                    NULL);
352     g_setenv("G_TEST_DBUS_DAEMON", dbus_daemon, true);
353 
354     g_test_init(&argc, &argv, NULL);
355 
356     workdir = g_dir_make_tmp("dbus-vmstate-test-XXXXXX", &err);
357     if (!workdir) {
358         g_error("Unable to create temporary dir: %s\n", err->message);
359         exit(1);
360     }
361 
362     g_setenv("DBUS_VMSTATE_TEST_TMPDIR", workdir, true);
363 
364     qtest_add_func("/dbus-vmstate/without-list",
365                    test_dbus_vmstate_without_list);
366     qtest_add_func("/dbus-vmstate/with-list",
367                    test_dbus_vmstate_with_list);
368     qtest_add_func("/dbus-vmstate/only-a",
369                    test_dbus_vmstate_only_a);
370     qtest_add_func("/dbus-vmstate/missing-src",
371                    test_dbus_vmstate_missing_src);
372     qtest_add_func("/dbus-vmstate/missing-dst",
373                    test_dbus_vmstate_missing_dst);
374 
375     ret = g_test_run();
376 
377     rmdir(workdir);
378     g_free(workdir);
379 
380     return ret;
381 }
382