]>
git.proxmox.com Git - mirror_qemu.git/blob - tests/ivshmem-test.c
2 * QTest testcase for ivshmem
4 * Copyright (c) 2014 SUSE LINUX Products GmbH
5 * Copyright (c) 2015 Red Hat, Inc.
7 * This work is licensed under the terms of the GNU GPL, version 2 or later.
8 * See the COPYING file in the top-level directory.
11 #include "qemu/osdep.h"
12 #include <glib/gstdio.h>
13 #include "contrib/ivshmem-server/ivshmem-server.h"
14 #include "libqos/libqos-pc.h"
16 #include "qemu-common.h"
18 #define TMPSHMSIZE (1 << 20)
20 static void *tmpshmem
;
22 static char *tmpserver
;
24 static void save_fn(QPCIDevice
*dev
, int devfn
, void *data
)
26 QPCIDevice
**pdev
= (QPCIDevice
**) data
;
31 static QPCIDevice
*get_device(QPCIBus
*pcibus
)
36 qpci_device_foreach(pcibus
, 0x1af4, 0x1110, save_fn
, &dev
);
37 g_assert(dev
!= NULL
);
42 typedef struct _IVState
{
44 QPCIBar reg_bar
, mem_bar
;
55 static const char* reg2str(enum Reg reg
) {
70 static inline unsigned in_reg(IVState
*s
, enum Reg reg
)
72 const char *name
= reg2str(reg
);
73 QTestState
*qtest
= global_qtest
;
76 global_qtest
= s
->qs
->qts
;
77 res
= qpci_io_readl(s
->dev
, s
->reg_bar
, reg
);
78 g_test_message("*%s -> %x\n", name
, res
);
84 static inline void out_reg(IVState
*s
, enum Reg reg
, unsigned v
)
86 const char *name
= reg2str(reg
);
87 QTestState
*qtest
= global_qtest
;
89 global_qtest
= s
->qs
->qts
;
90 g_test_message("%x -> *%s\n", v
, name
);
91 qpci_io_writel(s
->dev
, s
->reg_bar
, reg
, v
);
95 static inline void read_mem(IVState
*s
, uint64_t off
, void *buf
, size_t len
)
97 QTestState
*qtest
= global_qtest
;
99 global_qtest
= s
->qs
->qts
;
100 qpci_memread(s
->dev
, s
->mem_bar
, off
, buf
, len
);
101 global_qtest
= qtest
;
104 static inline void write_mem(IVState
*s
, uint64_t off
,
105 const void *buf
, size_t len
)
107 QTestState
*qtest
= global_qtest
;
109 global_qtest
= s
->qs
->qts
;
110 qpci_memwrite(s
->dev
, s
->mem_bar
, off
, buf
, len
);
111 global_qtest
= qtest
;
114 static void cleanup_vm(IVState
*s
)
117 qtest_shutdown(s
->qs
);
120 static void setup_vm_cmd(IVState
*s
, const char *cmd
, bool msix
)
123 const char *arch
= qtest_get_arch();
125 if (strcmp(arch
, "i386") == 0 || strcmp(arch
, "x86_64") == 0) {
126 s
->qs
= qtest_pc_boot(cmd
);
128 g_printerr("ivshmem-test tests are only available on x86\n");
131 s
->dev
= get_device(s
->qs
->pcibus
);
133 s
->reg_bar
= qpci_iomap(s
->dev
, 0, &barsize
);
134 g_assert_cmpuint(barsize
, ==, 256);
137 qpci_msix_enable(s
->dev
);
140 s
->mem_bar
= qpci_iomap(s
->dev
, 2, &barsize
);
141 g_assert_cmpuint(barsize
, ==, TMPSHMSIZE
);
143 qpci_device_enable(s
->dev
);
146 static void setup_vm(IVState
*s
)
148 char *cmd
= g_strdup_printf("-object memory-backend-file"
149 ",id=mb1,size=1M,share,mem-path=/dev/shm%s"
150 " -device ivshmem-plain,memdev=mb1", tmpshm
);
152 setup_vm_cmd(s
, cmd
, false);
157 static void test_ivshmem_single(void)
166 /* initial state of readable registers */
167 g_assert_cmpuint(in_reg(s
, INTRMASK
), ==, 0);
168 g_assert_cmpuint(in_reg(s
, INTRSTATUS
), ==, 0);
169 g_assert_cmpuint(in_reg(s
, IVPOSITION
), ==, 0);
171 /* trigger interrupt via registers */
172 out_reg(s
, INTRMASK
, 0xffffffff);
173 g_assert_cmpuint(in_reg(s
, INTRMASK
), ==, 0xffffffff);
174 out_reg(s
, INTRSTATUS
, 1);
175 /* check interrupt status */
176 g_assert_cmpuint(in_reg(s
, INTRSTATUS
), ==, 1);
178 g_assert_cmpuint(in_reg(s
, INTRSTATUS
), ==, 0);
179 /* TODO intercept actual interrupt (needs qtest work) */
181 /* invalid register access */
182 out_reg(s
, IVPOSITION
, 1);
185 /* ring the (non-functional) doorbell */
186 out_reg(s
, DOORBELL
, 8 << 16);
188 /* write shared memory */
189 for (i
= 0; i
< G_N_ELEMENTS(data
); i
++) {
192 write_mem(s
, 0, data
, sizeof(data
));
195 for (i
= 0; i
< G_N_ELEMENTS(data
); i
++) {
196 g_assert_cmpuint(((uint32_t *)tmpshmem
)[i
], ==, i
);
199 /* read it back and verify read */
200 memset(data
, 0, sizeof(data
));
201 read_mem(s
, 0, data
, sizeof(data
));
202 for (i
= 0; i
< G_N_ELEMENTS(data
); i
++) {
203 g_assert_cmpuint(data
[i
], ==, i
);
209 static void test_ivshmem_pair(void)
211 IVState state1
, state2
, *s1
, *s2
;
220 data
= g_malloc0(TMPSHMSIZE
);
222 /* host write, guest 1 & 2 read */
223 memset(tmpshmem
, 0x42, TMPSHMSIZE
);
224 read_mem(s1
, 0, data
, TMPSHMSIZE
);
225 for (i
= 0; i
< TMPSHMSIZE
; i
++) {
226 g_assert_cmpuint(data
[i
], ==, 0x42);
228 read_mem(s2
, 0, data
, TMPSHMSIZE
);
229 for (i
= 0; i
< TMPSHMSIZE
; i
++) {
230 g_assert_cmpuint(data
[i
], ==, 0x42);
233 /* guest 1 write, guest 2 read */
234 memset(data
, 0x43, TMPSHMSIZE
);
235 write_mem(s1
, 0, data
, TMPSHMSIZE
);
236 memset(data
, 0, TMPSHMSIZE
);
237 read_mem(s2
, 0, data
, TMPSHMSIZE
);
238 for (i
= 0; i
< TMPSHMSIZE
; i
++) {
239 g_assert_cmpuint(data
[i
], ==, 0x43);
242 /* guest 2 write, guest 1 read */
243 memset(data
, 0x44, TMPSHMSIZE
);
244 write_mem(s2
, 0, data
, TMPSHMSIZE
);
245 memset(data
, 0, TMPSHMSIZE
);
246 read_mem(s1
, 0, data
, TMPSHMSIZE
);
247 for (i
= 0; i
< TMPSHMSIZE
; i
++) {
248 g_assert_cmpuint(data
[i
], ==, 0x44);
256 typedef struct ServerThread
{
258 IvshmemServer
*server
;
259 int pipe
[2]; /* to handle quit */
262 static void *server_thread(void *data
)
264 ServerThread
*t
= data
;
265 IvshmemServer
*server
= t
->server
;
272 FD_SET(t
->pipe
[0], &fds
);
273 maxfd
= t
->pipe
[0] + 1;
275 ivshmem_server_get_fds(server
, &fds
, &maxfd
);
277 ret
= select(maxfd
, &fds
, NULL
, NULL
, NULL
);
280 if (errno
== EINTR
) {
284 g_critical("select error: %s\n", strerror(errno
));
291 if (FD_ISSET(t
->pipe
[0], &fds
)) {
295 if (ivshmem_server_handle_fds(server
, &fds
, maxfd
) < 0) {
296 g_critical("ivshmem_server_handle_fds() failed\n");
304 static void setup_vm_with_server(IVState
*s
, int nvectors
, bool msi
)
306 char *cmd
= g_strdup_printf("-chardev socket,id=chr0,path=%s,nowait "
307 "-device ivshmem%s,chardev=chr0,vectors=%d",
309 msi
? "-doorbell" : ",size=1M,msi=off",
312 setup_vm_cmd(s
, cmd
, msi
);
317 static void test_ivshmem_server(bool msi
)
319 IVState state1
, state2
, *s1
, *s2
;
321 IvshmemServer server
;
324 guint64 end_time
= g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND
;
326 ret
= ivshmem_server_init(&server
, tmpserver
, tmpshm
, true,
327 TMPSHMSIZE
, nvectors
,
329 g_assert_cmpint(ret
, ==, 0);
331 ret
= ivshmem_server_start(&server
);
332 g_assert_cmpint(ret
, ==, 0);
334 thread
.server
= &server
;
335 ret
= pipe(thread
.pipe
);
336 g_assert_cmpint(ret
, ==, 0);
337 thread
.thread
= g_thread_new("ivshmem-server", server_thread
, &thread
);
338 g_assert(thread
.thread
!= NULL
);
340 setup_vm_with_server(&state1
, nvectors
, msi
);
342 setup_vm_with_server(&state2
, nvectors
, msi
);
345 /* check got different VM ids */
346 vm1
= in_reg(s1
, IVPOSITION
);
347 vm2
= in_reg(s2
, IVPOSITION
);
348 g_assert_cmpint(vm1
, >=, 0);
349 g_assert_cmpint(vm2
, >=, 0);
350 g_assert_cmpint(vm1
, !=, vm2
);
352 /* check number of MSI-X vectors */
353 global_qtest
= s1
->qs
->qts
;
355 ret
= qpci_msix_table_size(s1
->dev
);
356 g_assert_cmpuint(ret
, ==, nvectors
);
359 /* TODO test behavior before MSI-X is enabled */
361 /* ping vm2 -> vm1 on vector 0 */
363 ret
= qpci_msix_pending(s1
->dev
, 0);
364 g_assert_cmpuint(ret
, ==, 0);
366 g_assert_cmpuint(in_reg(s1
, INTRSTATUS
), ==, 0);
368 out_reg(s2
, DOORBELL
, vm1
<< 16);
371 ret
= msi
? qpci_msix_pending(s1
->dev
, 0) : in_reg(s1
, INTRSTATUS
);
372 } while (ret
== 0 && g_get_monotonic_time() < end_time
);
373 g_assert_cmpuint(ret
, !=, 0);
375 /* ping vm1 -> vm2 on vector 1 */
376 global_qtest
= s2
->qs
->qts
;
378 ret
= qpci_msix_pending(s2
->dev
, 1);
379 g_assert_cmpuint(ret
, ==, 0);
381 g_assert_cmpuint(in_reg(s2
, INTRSTATUS
), ==, 0);
383 out_reg(s1
, DOORBELL
, vm2
<< 16 | 1);
386 ret
= msi
? qpci_msix_pending(s2
->dev
, 1) : in_reg(s2
, INTRSTATUS
);
387 } while (ret
== 0 && g_get_monotonic_time() < end_time
);
388 g_assert_cmpuint(ret
, !=, 0);
393 if (qemu_write_full(thread
.pipe
[1], "q", 1) != 1) {
394 g_error("qemu_write_full: %s", g_strerror(errno
));
397 g_thread_join(thread
.thread
);
399 ivshmem_server_close(&server
);
400 close(thread
.pipe
[1]);
401 close(thread
.pipe
[0]);
404 static void test_ivshmem_server_msi(void)
406 test_ivshmem_server(true);
409 static void test_ivshmem_server_irq(void)
411 test_ivshmem_server(false);
414 #define PCI_SLOT_HP 0x06
416 static void test_ivshmem_hotplug(void)
422 opts
= g_strdup_printf("'shm': '%s', 'size': '1M'", tmpshm
);
424 qpci_plug_device_test("ivshmem", "iv1", PCI_SLOT_HP
, opts
);
425 qpci_unplug_acpi_device_test("iv1", PCI_SLOT_HP
);
431 static void test_ivshmem_memdev(void)
435 /* just for the sake of checking memory-backend property */
436 setup_vm_cmd(&state
, "-object memory-backend-ram,size=1M,id=mb1"
437 " -device ivshmem-plain,memdev=mb1", false);
442 static void cleanup(void)
445 munmap(tmpshmem
, TMPSHMSIZE
);
467 static void abrt_handler(void *data
)
472 static gchar
*mktempshm(int size
, int *fd
)
477 name
= g_strdup_printf("/qtest-%u-%u", getpid(), g_random_int());
478 *fd
= shm_open(name
, O_CREAT
|O_RDWR
|O_EXCL
,
479 S_IRWXU
|S_IRWXG
|S_IRWXO
);
481 g_assert(ftruncate(*fd
, size
) == 0);
487 if (errno
!= EEXIST
) {
494 int main(int argc
, char **argv
)
497 gchar dir
[] = "/tmp/ivshmem-test.XXXXXX";
499 #if !GLIB_CHECK_VERSION(2, 31, 0)
500 if (!g_thread_supported()) {
505 g_test_init(&argc
, &argv
, NULL
);
507 qtest_add_abrt_handler(abrt_handler
, NULL
);
509 tmpshm
= mktempshm(TMPSHMSIZE
, &fd
);
513 tmpshmem
= mmap(0, TMPSHMSIZE
, PROT_READ
|PROT_WRITE
, MAP_SHARED
, fd
, 0);
514 g_assert(tmpshmem
!= MAP_FAILED
);
516 if (mkdtemp(dir
) == NULL
) {
517 g_error("mkdtemp: %s", g_strerror(errno
));
520 tmpserver
= g_strconcat(tmpdir
, "/server", NULL
);
522 qtest_add_func("/ivshmem/single", test_ivshmem_single
);
523 qtest_add_func("/ivshmem/hotplug", test_ivshmem_hotplug
);
524 qtest_add_func("/ivshmem/memdev", test_ivshmem_memdev
);
526 qtest_add_func("/ivshmem/pair", test_ivshmem_pair
);
527 qtest_add_func("/ivshmem/server-msi", test_ivshmem_server_msi
);
528 qtest_add_func("/ivshmem/server-irq", test_ivshmem_server_irq
);