]>
Commit | Line | Data |
---|---|---|
2d888c09 AF |
1 | /* |
2 | * QTest testcase for VirtIO 9P | |
3 | * | |
4 | * Copyright (c) 2014 SUSE LINUX Products GmbH | |
5 | * | |
6 | * This work is licensed under the terms of the GNU GPL, version 2 or later. | |
7 | * See the COPYING file in the top-level directory. | |
8 | */ | |
9 | ||
fbc04127 | 10 | #include "qemu/osdep.h" |
2d888c09 AF |
11 | #include "libqtest.h" |
12 | #include "qemu-common.h" | |
a980f7f2 | 13 | #include "libqos/libqos-pc.h" |
30ca440e | 14 | #include "libqos/libqos-spapr.h" |
557a4cc0 GK |
15 | #include "libqos/virtio.h" |
16 | #include "libqos/virtio-pci.h" | |
557a4cc0 GK |
17 | #include "standard-headers/linux/virtio_ids.h" |
18 | #include "standard-headers/linux/virtio_pci.h" | |
6cc9906b | 19 | #include "hw/9pfs/9p.h" |
2d888c09 | 20 | |
65b70fc7 GK |
21 | #define QVIRTIO_9P_TIMEOUT_US (10 * 1000 * 1000) |
22 | ||
993f8054 | 23 | static const char mount_tag[] = "qtest"; |
2d888c09 | 24 | |
1211d81b GK |
25 | typedef struct { |
26 | QVirtioDevice *dev; | |
27 | QOSState *qs; | |
28 | QVirtQueue *vq; | |
29 | char *test_share; | |
5c3df1f0 | 30 | uint16_t p9_req_tag; |
1211d81b | 31 | } QVirtIO9P; |
a980f7f2 | 32 | |
1211d81b | 33 | static QVirtIO9P *qvirtio_9p_start(const char *driver) |
2d888c09 | 34 | { |
30ca440e | 35 | const char *arch = qtest_get_arch(); |
a980f7f2 | 36 | const char *cmd = "-fsdev local,id=fsdev0,security_model=none,path=%s " |
1211d81b GK |
37 | "-device %s,fsdev=fsdev0,mount_tag=%s"; |
38 | QVirtIO9P *v9p = g_new0(QVirtIO9P, 1); | |
2d888c09 | 39 | |
1211d81b GK |
40 | v9p->test_share = g_strdup("/tmp/qtest.XXXXXX"); |
41 | g_assert_nonnull(mkdtemp(v9p->test_share)); | |
2d888c09 | 42 | |
30ca440e | 43 | if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) { |
1211d81b GK |
44 | v9p->qs = qtest_pc_boot(cmd, v9p->test_share, driver, mount_tag); |
45 | } else if (strcmp(arch, "ppc64") == 0) { | |
46 | v9p->qs = qtest_spapr_boot(cmd, v9p->test_share, driver, mount_tag); | |
47 | } else { | |
48 | g_printerr("virtio-9p tests are only available on x86 or ppc64\n"); | |
49 | exit(EXIT_FAILURE); | |
30ca440e LV |
50 | } |
51 | ||
1211d81b | 52 | return v9p; |
993f8054 GK |
53 | } |
54 | ||
1211d81b | 55 | static void qvirtio_9p_stop(QVirtIO9P *v9p) |
993f8054 | 56 | { |
1211d81b GK |
57 | qtest_shutdown(v9p->qs); |
58 | rmdir(v9p->test_share); | |
59 | g_free(v9p->test_share); | |
60 | g_free(v9p); | |
993f8054 GK |
61 | } |
62 | ||
1211d81b | 63 | static QVirtIO9P *qvirtio_9p_pci_start(void) |
557a4cc0 | 64 | { |
1211d81b GK |
65 | QVirtIO9P *v9p = qvirtio_9p_start("virtio-9p-pci"); |
66 | QVirtioPCIDevice *dev = qvirtio_pci_device_find(v9p->qs->pcibus, | |
67 | VIRTIO_ID_9P); | |
557a4cc0 GK |
68 | g_assert_nonnull(dev); |
69 | g_assert_cmphex(dev->vdev.device_type, ==, VIRTIO_ID_9P); | |
70 | v9p->dev = (QVirtioDevice *) dev; | |
71 | ||
72 | qvirtio_pci_device_enable(dev); | |
6b9cdf4c LV |
73 | qvirtio_reset(v9p->dev); |
74 | qvirtio_set_acknowledge(v9p->dev); | |
75 | qvirtio_set_driver(v9p->dev); | |
557a4cc0 | 76 | |
a980f7f2 | 77 | v9p->vq = qvirtqueue_setup(v9p->dev, v9p->qs->alloc, 0); |
d8803b1a GK |
78 | |
79 | qvirtio_set_driver_ok(v9p->dev); | |
80 | ||
557a4cc0 GK |
81 | return v9p; |
82 | } | |
83 | ||
1211d81b | 84 | static void qvirtio_9p_pci_stop(QVirtIO9P *v9p) |
557a4cc0 | 85 | { |
a980f7f2 | 86 | qvirtqueue_cleanup(v9p->dev->bus, v9p->vq, v9p->qs->alloc); |
557a4cc0 | 87 | qvirtio_pci_device_disable(container_of(v9p->dev, QVirtioPCIDevice, vdev)); |
2b880bcd | 88 | qvirtio_pci_device_free((QVirtioPCIDevice *)v9p->dev); |
1211d81b | 89 | qvirtio_9p_stop(v9p); |
557a4cc0 GK |
90 | } |
91 | ||
1211d81b | 92 | static void pci_config(QVirtIO9P *v9p) |
557a4cc0 | 93 | { |
1211d81b | 94 | size_t tag_len = qvirtio_config_readw(v9p->dev, 0); |
557a4cc0 GK |
95 | char *tag; |
96 | int i; | |
557a4cc0 | 97 | |
557a4cc0 | 98 | g_assert_cmpint(tag_len, ==, strlen(mount_tag)); |
557a4cc0 GK |
99 | |
100 | tag = g_malloc(tag_len); | |
101 | for (i = 0; i < tag_len; i++) { | |
246fc0fb | 102 | tag[i] = qvirtio_config_readb(v9p->dev, i + 2); |
557a4cc0 GK |
103 | } |
104 | g_assert_cmpmem(tag, tag_len, mount_tag, tag_len); | |
105 | g_free(tag); | |
1211d81b GK |
106 | } |
107 | ||
6cc9906b GK |
108 | #define P9_MAX_SIZE 4096 /* Max size of a T-message or R-message */ |
109 | ||
110 | typedef struct { | |
111 | QVirtIO9P *v9p; | |
112 | uint16_t tag; | |
113 | uint64_t t_msg; | |
114 | uint32_t t_size; | |
115 | uint64_t r_msg; | |
116 | /* No r_size, it is hardcoded to P9_MAX_SIZE */ | |
117 | size_t t_off; | |
118 | size_t r_off; | |
65b70fc7 | 119 | uint32_t free_head; |
6cc9906b GK |
120 | } P9Req; |
121 | ||
122 | static void v9fs_memwrite(P9Req *req, const void *addr, size_t len) | |
123 | { | |
124 | memwrite(req->t_msg + req->t_off, addr, len); | |
125 | req->t_off += len; | |
126 | } | |
127 | ||
128 | static void v9fs_memskip(P9Req *req, size_t len) | |
129 | { | |
130 | req->r_off += len; | |
131 | } | |
132 | ||
6cc9906b GK |
133 | static void v9fs_memread(P9Req *req, void *addr, size_t len) |
134 | { | |
135 | memread(req->r_msg + req->r_off, addr, len); | |
136 | req->r_off += len; | |
137 | } | |
138 | ||
139 | static void v9fs_uint16_write(P9Req *req, uint16_t val) | |
140 | { | |
141 | uint16_t le_val = cpu_to_le16(val); | |
142 | ||
143 | v9fs_memwrite(req, &le_val, 2); | |
144 | } | |
145 | ||
146 | static void v9fs_uint16_read(P9Req *req, uint16_t *val) | |
147 | { | |
148 | v9fs_memread(req, val, 2); | |
149 | le16_to_cpus(val); | |
150 | } | |
151 | ||
152 | static void v9fs_uint32_write(P9Req *req, uint32_t val) | |
153 | { | |
154 | uint32_t le_val = cpu_to_le32(val); | |
155 | ||
156 | v9fs_memwrite(req, &le_val, 4); | |
157 | } | |
158 | ||
159 | static void v9fs_uint32_read(P9Req *req, uint32_t *val) | |
160 | { | |
161 | v9fs_memread(req, val, 4); | |
162 | le32_to_cpus(val); | |
163 | } | |
164 | ||
165 | /* len[2] string[len] */ | |
166 | static uint16_t v9fs_string_size(const char *string) | |
167 | { | |
168 | size_t len = strlen(string); | |
169 | ||
170 | g_assert_cmpint(len, <=, UINT16_MAX); | |
171 | ||
172 | return 2 + len; | |
173 | } | |
174 | ||
175 | static void v9fs_string_write(P9Req *req, const char *string) | |
176 | { | |
177 | int len = strlen(string); | |
178 | ||
179 | g_assert_cmpint(len, <=, UINT16_MAX); | |
180 | ||
181 | v9fs_uint16_write(req, (uint16_t) len); | |
182 | v9fs_memwrite(req, string, len); | |
183 | } | |
184 | ||
185 | static void v9fs_string_read(P9Req *req, uint16_t *len, char **string) | |
186 | { | |
187 | uint16_t local_len; | |
188 | ||
189 | v9fs_uint16_read(req, &local_len); | |
190 | if (len) { | |
191 | *len = local_len; | |
192 | } | |
193 | if (string) { | |
194 | *string = g_malloc(local_len); | |
195 | v9fs_memread(req, *string, local_len); | |
196 | } else { | |
197 | v9fs_memskip(req, local_len); | |
198 | } | |
199 | } | |
200 | ||
201 | typedef struct { | |
202 | uint32_t size; | |
203 | uint8_t id; | |
204 | uint16_t tag; | |
205 | } QEMU_PACKED P9Hdr; | |
206 | ||
207 | static P9Req *v9fs_req_init(QVirtIO9P *v9p, uint32_t size, uint8_t id, | |
208 | uint16_t tag) | |
209 | { | |
210 | P9Req *req = g_new0(P9Req, 1); | |
211 | uint32_t t_size = 7 + size; /* 9P header has well-known size of 7 bytes */ | |
212 | P9Hdr hdr = { | |
213 | .size = cpu_to_le32(t_size), | |
214 | .id = id, | |
215 | .tag = cpu_to_le16(tag) | |
216 | }; | |
217 | ||
218 | g_assert_cmpint(t_size, <=, P9_MAX_SIZE); | |
219 | ||
220 | req->v9p = v9p; | |
221 | req->t_size = t_size; | |
222 | req->t_msg = guest_alloc(v9p->qs->alloc, req->t_size); | |
223 | v9fs_memwrite(req, &hdr, 7); | |
224 | req->tag = tag; | |
225 | return req; | |
226 | } | |
227 | ||
228 | static void v9fs_req_send(P9Req *req) | |
229 | { | |
230 | QVirtIO9P *v9p = req->v9p; | |
6cc9906b GK |
231 | |
232 | req->r_msg = guest_alloc(v9p->qs->alloc, P9_MAX_SIZE); | |
65b70fc7 GK |
233 | req->free_head = qvirtqueue_add(v9p->vq, req->t_msg, req->t_size, false, |
234 | true); | |
6cc9906b | 235 | qvirtqueue_add(v9p->vq, req->r_msg, P9_MAX_SIZE, true, false); |
65b70fc7 | 236 | qvirtqueue_kick(v9p->dev, v9p->vq, req->free_head); |
6cc9906b GK |
237 | req->t_off = 0; |
238 | } | |
239 | ||
6e37f458 GK |
240 | static const char *rmessage_name(uint8_t id) |
241 | { | |
242 | return | |
243 | id == P9_RLERROR ? "RLERROR" : | |
244 | id == P9_RVERSION ? "RVERSION" : | |
245 | id == P9_RATTACH ? "RATTACH" : | |
246 | id == P9_RWALK ? "RWALK" : | |
247 | "<unknown>"; | |
248 | } | |
249 | ||
6cc9906b GK |
250 | static void v9fs_req_recv(P9Req *req, uint8_t id) |
251 | { | |
252 | QVirtIO9P *v9p = req->v9p; | |
253 | P9Hdr hdr; | |
6cc9906b | 254 | |
65b70fc7 GK |
255 | qvirtio_wait_used_elem(v9p->dev, v9p->vq, req->free_head, |
256 | QVIRTIO_9P_TIMEOUT_US); | |
6cc9906b | 257 | |
65b70fc7 GK |
258 | v9fs_memread(req, &hdr, 7); |
259 | hdr.size = ldl_le_p(&hdr.size); | |
260 | hdr.tag = lduw_le_p(&hdr.tag); | |
6cc9906b GK |
261 | |
262 | g_assert_cmpint(hdr.size, >=, 7); | |
263 | g_assert_cmpint(hdr.size, <=, P9_MAX_SIZE); | |
264 | g_assert_cmpint(hdr.tag, ==, req->tag); | |
265 | ||
6e37f458 GK |
266 | if (hdr.id != id) { |
267 | g_printerr("Received response %d (%s) instead of %d (%s)\n", | |
268 | hdr.id, rmessage_name(hdr.id), id, rmessage_name(id)); | |
269 | ||
270 | if (hdr.id == P9_RLERROR) { | |
271 | uint32_t err; | |
272 | v9fs_uint32_read(req, &err); | |
273 | g_printerr("Rlerror has errno %d (%s)\n", err, strerror(err)); | |
274 | } | |
6cc9906b GK |
275 | } |
276 | g_assert_cmpint(hdr.id, ==, id); | |
277 | } | |
278 | ||
279 | static void v9fs_req_free(P9Req *req) | |
280 | { | |
281 | QVirtIO9P *v9p = req->v9p; | |
282 | ||
283 | guest_free(v9p->qs->alloc, req->t_msg); | |
284 | guest_free(v9p->qs->alloc, req->r_msg); | |
285 | g_free(req); | |
286 | } | |
287 | ||
ba0d1037 GK |
288 | /* size[4] Rlerror tag[2] ecode[4] */ |
289 | static void v9fs_rlerror(P9Req *req, uint32_t *err) | |
290 | { | |
291 | v9fs_req_recv(req, P9_RLERROR); | |
292 | v9fs_uint32_read(req, err); | |
293 | v9fs_req_free(req); | |
294 | } | |
295 | ||
6cc9906b GK |
296 | /* size[4] Tversion tag[2] msize[4] version[s] */ |
297 | static P9Req *v9fs_tversion(QVirtIO9P *v9p, uint32_t msize, const char *version) | |
298 | { | |
299 | P9Req *req = v9fs_req_init(v9p, 4 + v9fs_string_size(version), P9_TVERSION, | |
300 | P9_NOTAG); | |
301 | ||
302 | v9fs_uint32_write(req, msize); | |
303 | v9fs_string_write(req, version); | |
304 | v9fs_req_send(req); | |
305 | return req; | |
306 | } | |
307 | ||
308 | /* size[4] Rversion tag[2] msize[4] version[s] */ | |
309 | static void v9fs_rversion(P9Req *req, uint16_t *len, char **version) | |
310 | { | |
311 | uint32_t msize; | |
312 | ||
313 | v9fs_req_recv(req, P9_RVERSION); | |
314 | v9fs_uint32_read(req, &msize); | |
315 | ||
316 | g_assert_cmpint(msize, ==, P9_MAX_SIZE); | |
317 | ||
318 | if (len || version) { | |
319 | v9fs_string_read(req, len, version); | |
320 | } | |
321 | ||
322 | v9fs_req_free(req); | |
323 | } | |
324 | ||
5c3df1f0 GK |
325 | /* size[4] Tattach tag[2] fid[4] afid[4] uname[s] aname[s] n_uname[4] */ |
326 | static P9Req *v9fs_tattach(QVirtIO9P *v9p, uint32_t fid, uint32_t n_uname) | |
327 | { | |
328 | const char *uname = ""; /* ignored by QEMU */ | |
329 | const char *aname = ""; /* ignored by QEMU */ | |
330 | P9Req *req = v9fs_req_init(v9p, 4 + 4 + 2 + 2 + 4, P9_TATTACH, | |
331 | ++(v9p->p9_req_tag)); | |
332 | ||
333 | v9fs_uint32_write(req, fid); | |
334 | v9fs_uint32_write(req, P9_NOFID); | |
335 | v9fs_string_write(req, uname); | |
336 | v9fs_string_write(req, aname); | |
337 | v9fs_uint32_write(req, n_uname); | |
338 | v9fs_req_send(req); | |
339 | return req; | |
340 | } | |
341 | ||
342 | typedef char v9fs_qid[13]; | |
343 | ||
344 | /* size[4] Rattach tag[2] qid[13] */ | |
345 | static void v9fs_rattach(P9Req *req, v9fs_qid *qid) | |
346 | { | |
347 | v9fs_req_recv(req, P9_RATTACH); | |
348 | if (qid) { | |
349 | v9fs_memread(req, qid, 13); | |
350 | } | |
351 | v9fs_req_free(req); | |
352 | } | |
353 | ||
04b88c84 GK |
354 | /* size[4] Twalk tag[2] fid[4] newfid[4] nwname[2] nwname*(wname[s]) */ |
355 | static P9Req *v9fs_twalk(QVirtIO9P *v9p, uint32_t fid, uint32_t newfid, | |
356 | uint16_t nwname, char *const wnames[]) | |
357 | { | |
358 | P9Req *req; | |
359 | int i; | |
360 | uint32_t size = 4 + 4 + 2; | |
361 | ||
362 | for (i = 0; i < nwname; i++) { | |
363 | size += v9fs_string_size(wnames[i]); | |
364 | } | |
365 | req = v9fs_req_init(v9p, size, P9_TWALK, ++(v9p->p9_req_tag)); | |
366 | v9fs_uint32_write(req, fid); | |
367 | v9fs_uint32_write(req, newfid); | |
368 | v9fs_uint16_write(req, nwname); | |
369 | for (i = 0; i < nwname; i++) { | |
370 | v9fs_string_write(req, wnames[i]); | |
371 | } | |
372 | v9fs_req_send(req); | |
373 | return req; | |
374 | } | |
375 | ||
376 | /* size[4] Rwalk tag[2] nwqid[2] nwqid*(wqid[13]) */ | |
377 | static void v9fs_rwalk(P9Req *req, uint16_t *nwqid, v9fs_qid **wqid) | |
378 | { | |
379 | uint16_t local_nwqid; | |
380 | ||
381 | v9fs_req_recv(req, P9_RWALK); | |
382 | v9fs_uint16_read(req, &local_nwqid); | |
383 | if (nwqid) { | |
384 | *nwqid = local_nwqid; | |
385 | } | |
386 | if (wqid) { | |
387 | *wqid = g_malloc(local_nwqid * 13); | |
388 | v9fs_memread(req, *wqid, local_nwqid * 13); | |
389 | } | |
390 | v9fs_req_free(req); | |
391 | } | |
392 | ||
6cc9906b GK |
393 | static void fs_version(QVirtIO9P *v9p) |
394 | { | |
395 | const char *version = "9P2000.L"; | |
396 | uint16_t server_len; | |
397 | char *server_version; | |
398 | P9Req *req; | |
399 | ||
400 | req = v9fs_tversion(v9p, P9_MAX_SIZE, version); | |
401 | v9fs_rversion(req, &server_len, &server_version); | |
402 | ||
403 | g_assert_cmpmem(server_version, server_len, version, strlen(version)); | |
404 | ||
405 | g_free(server_version); | |
406 | } | |
407 | ||
5c3df1f0 GK |
408 | static void fs_attach(QVirtIO9P *v9p) |
409 | { | |
410 | P9Req *req; | |
411 | ||
412 | fs_version(v9p); | |
413 | req = v9fs_tattach(v9p, 0, getuid()); | |
414 | v9fs_rattach(req, NULL); | |
415 | } | |
416 | ||
04b88c84 GK |
417 | static void fs_walk(QVirtIO9P *v9p) |
418 | { | |
419 | char *wnames[P9_MAXWELEM], *paths[P9_MAXWELEM]; | |
420 | char *last_path = v9p->test_share; | |
421 | uint16_t nwqid; | |
422 | v9fs_qid *wqid; | |
423 | int i; | |
424 | P9Req *req; | |
425 | ||
426 | for (i = 0; i < P9_MAXWELEM; i++) { | |
427 | wnames[i] = g_strdup_printf("%s%d", __func__, i); | |
428 | last_path = paths[i] = g_strdup_printf("%s/%s", last_path, wnames[i]); | |
429 | g_assert(!mkdir(paths[i], 0700)); | |
430 | } | |
431 | ||
432 | fs_attach(v9p); | |
433 | req = v9fs_twalk(v9p, 0, 1, P9_MAXWELEM, wnames); | |
434 | v9fs_rwalk(req, &nwqid, &wqid); | |
435 | ||
436 | g_assert_cmpint(nwqid, ==, P9_MAXWELEM); | |
437 | ||
438 | for (i = 0; i < P9_MAXWELEM; i++) { | |
439 | rmdir(paths[P9_MAXWELEM - i - 1]); | |
440 | g_free(paths[P9_MAXWELEM - i - 1]); | |
441 | g_free(wnames[i]); | |
442 | } | |
443 | ||
444 | g_free(wqid); | |
445 | } | |
446 | ||
ba0d1037 GK |
447 | static void fs_walk_no_slash(QVirtIO9P *v9p) |
448 | { | |
449 | char *const wnames[] = { g_strdup(" /") }; | |
450 | P9Req *req; | |
451 | uint32_t err; | |
452 | ||
453 | fs_attach(v9p); | |
454 | req = v9fs_twalk(v9p, 0, 1, 1, wnames); | |
455 | v9fs_rlerror(req, &err); | |
456 | ||
457 | g_assert_cmpint(err, ==, ENOENT); | |
458 | ||
459 | g_free(wnames[0]); | |
460 | } | |
461 | ||
a37c0702 GK |
462 | static void fs_walk_dotdot(QVirtIO9P *v9p) |
463 | { | |
464 | char *const wnames[] = { g_strdup("..") }; | |
465 | v9fs_qid root_qid, *wqid; | |
466 | P9Req *req; | |
467 | ||
468 | fs_version(v9p); | |
469 | req = v9fs_tattach(v9p, 0, getuid()); | |
470 | v9fs_rattach(req, &root_qid); | |
471 | ||
472 | req = v9fs_twalk(v9p, 0, 1, 1, wnames); | |
473 | v9fs_rwalk(req, NULL, &wqid); /* We now we'll get one qid */ | |
474 | ||
475 | g_assert_cmpmem(&root_qid, 13, wqid[0], 13); | |
476 | ||
477 | g_free(wqid); | |
478 | g_free(wnames[0]); | |
479 | } | |
480 | ||
1211d81b GK |
481 | typedef void (*v9fs_test_fn)(QVirtIO9P *v9p); |
482 | ||
483 | static void v9fs_run_pci_test(gconstpointer data) | |
484 | { | |
485 | v9fs_test_fn fn = data; | |
486 | QVirtIO9P *v9p = qvirtio_9p_pci_start(); | |
557a4cc0 | 487 | |
1211d81b GK |
488 | if (fn) { |
489 | fn(v9p); | |
490 | } | |
491 | qvirtio_9p_pci_stop(v9p); | |
492 | } | |
493 | ||
494 | static void v9fs_qtest_pci_add(const char *path, v9fs_test_fn fn) | |
495 | { | |
496 | qtest_add_data_func(path, fn, v9fs_run_pci_test); | |
557a4cc0 GK |
497 | } |
498 | ||
993f8054 GK |
499 | int main(int argc, char **argv) |
500 | { | |
501 | g_test_init(&argc, &argv, NULL); | |
1211d81b GK |
502 | v9fs_qtest_pci_add("/virtio/9p/pci/nop", NULL); |
503 | v9fs_qtest_pci_add("/virtio/9p/pci/config", pci_config); | |
6cc9906b | 504 | v9fs_qtest_pci_add("/virtio/9p/pci/fs/version/basic", fs_version); |
5c3df1f0 | 505 | v9fs_qtest_pci_add("/virtio/9p/pci/fs/attach/basic", fs_attach); |
04b88c84 | 506 | v9fs_qtest_pci_add("/virtio/9p/pci/fs/walk/basic", fs_walk); |
ba0d1037 | 507 | v9fs_qtest_pci_add("/virtio/9p/pci/fs/walk/no_slash", fs_walk_no_slash); |
a37c0702 GK |
508 | v9fs_qtest_pci_add("/virtio/9p/pci/fs/walk/dotdot_from_root", |
509 | fs_walk_dotdot); | |
2d888c09 | 510 | |
993f8054 | 511 | return g_test_run(); |
2d888c09 | 512 | } |