haraldwolff/qemu-patch-raspberry4
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

-----BEGIN PGP SIGNATURE-----

Browse source 
Version: GnuPG v1
 
 iQIcBAABAgAGBQJWsKRXAAoJENro4Ql1lpzl55YP/0sY2Nnw3S7F1JEJVai7Reil
 VVumgnU6TjFZaLS3bFH7HwWUZgdwI8PkGq6XiMgvsA3O2Pso4XyorQHdWqRwrRpU
 /OVHgEia8xCyDo9rw23paSMouWa/SnT9CFNKzyUg7F2e6gxVGMPp+po1cYwznxhf
 Anz3DgNxf9czT8c+bP5iIoqDiLep9n5Y8/2GltKlfYqyHPTbVG/IzsqXaIa2HYCU
 L3unArALVkcPt68XS72NzuU+uDeixfIwgpeFtb2Zrt7OjKLeJAps4PYYvd4wy11N
 WSCPP3mfjLzX9sNIuktlmOulsJX3lO3SafJ+yD6LSraNxjyuk9jart5yQQVeUue0
 zcwytwwmKdAC9Y/lfwG4H8+S7VgE0q1rmq9V/EHC5TaOWnIjs2UbjjYfGAQDoclo
 d2pujO7AADQIvVcSPVAOX+S/aB62LB0qyUWRDs2YCfZPtMltOMSWhQP7a5Y+A7mw
 LxJmly8l800R6I5wZaBntv+8/MqbjBjG/fdIXrud6LiKmLLdRidUR0cNkyK1smR5
 GYwgD5ZsVpoJRErcCUWMMXGBqCyj0CVsASV2CpRUsZkNLfOjWnYoEaVm5UFnGzJG
 rXAYRs2wGwctLkOINC7M/YuvuJyyRviBE7+E81+dFeV52J0r9jYHwMz+ZukZbJDX
 AxN6BCDe1PZ/8b53NwdU
 =stmx
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/elmarco/tags/ivshmem-pull-request' into staging

# gpg: Signature made Tue 02 Feb 2016 12:43:03 GMT using RSA key ID 75969CE5
# gpg: Good signature from "Marc-André Lureau <marcandre.lureau@redhat.com>"
# gpg:                 aka "Marc-André Lureau <marcandre.lureau@gmail.com>"
# gpg: WARNING: This key is not certified with sufficiently trusted signatures!
# gpg:          It is not certain that the signature belongs to the owner.
# Primary key fingerprint: 87A9 BD93 3F87 C606 D276  F62D DAE8 E109 7596 9CE5

* remotes/elmarco/tags/ivshmem-pull-request:
  char: remove qemu_chr_open_eventfd
  ivshmem: use a single eventfd callback, get rid of CharDriver
  ivshmem: generalize ivshmem_setup_interrupts
  ivshmem-test: test both msi & irq cases
  libqos: remove some leaks
  ivshmem-test: leak fixes
  ivshmem: remove redundant assignment, fix crash with msi=off
  ivshmem: no need for opaque argument

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2016-02-02 13:31:19 +00:00
parent 10ae9d7638 6db2625572
commit 074d1ccb42
5 changed files with 87 additions and 95 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

83
hw/misc/ivshmem.c
View file

@ -263,15 +263,6 @@ static const MemoryRegionOps ivshmem_mmio_ops = {
},
};
static void ivshmem_receive(void *opaque, const uint8_t *buf, int size)
{
IVShmemState *s = opaque;
IVSHMEM_DPRINTF("ivshmem_receive 0x%02x size: %d\n", *buf, size);
ivshmem_IntrStatus_write(s, *buf);
}
static int ivshmem_can_receive(void * opaque)
{
return sizeof(int64_t);
@ -282,15 +273,24 @@ static void ivshmem_event(void *opaque, int event)
IVSHMEM_DPRINTF("ivshmem_event %d\n", event);
}
static void fake_irqfd(void *opaque, const uint8_t *buf, int size) {
static void ivshmem_vector_notify(void *opaque)
{
MSIVector *entry = opaque;
PCIDevice *pdev = entry->pdev;
IVShmemState *s = IVSHMEM(pdev);
int vector = entry - s->msi_vectors;
EventNotifier *n = &s->peers[s->vm_id].eventfds[vector];
if (!event_notifier_test_and_clear(n)) {
return;
}
IVSHMEM_DPRINTF("interrupt on vector %p %d\n", pdev, vector);
msix_notify(pdev, vector);
if (ivshmem_has_feature(s, IVSHMEM_MSI)) {
msix_notify(pdev, vector);
} else {
ivshmem_IntrStatus_write(s, 1);
}
}
static int ivshmem_vector_unmask(PCIDevice *dev, unsigned vector,
@ -350,38 +350,16 @@ static void ivshmem_vector_poll(PCIDevice *dev,
}
}
static CharDriverState* create_eventfd_chr_device(void * opaque, EventNotifier *n,
int vector)
static void watch_vector_notifier(IVShmemState *s, EventNotifier *n,
int vector)
{
/* create a event character device based on the passed eventfd */
IVShmemState *s = opaque;
PCIDevice *pdev = PCI_DEVICE(s);
int eventfd = event_notifier_get_fd(n);
CharDriverState *chr;
s->msi_vectors[vector].pdev = pdev;
chr = qemu_chr_open_eventfd(eventfd);
if (chr == NULL) {
error_report("creating chardriver for eventfd %d failed", eventfd);
return NULL;
}
qemu_chr_fe_claim_no_fail(chr);
/* if MSI is supported we need multiple interrupts */
if (ivshmem_has_feature(s, IVSHMEM_MSI)) {
s->msi_vectors[vector].pdev = PCI_DEVICE(s);
qemu_chr_add_handlers(chr, ivshmem_can_receive, fake_irqfd,
ivshmem_event, &s->msi_vectors[vector]);
} else {
qemu_chr_add_handlers(chr, ivshmem_can_receive, ivshmem_receive,
ivshmem_event, s);
}
return chr;
s->msi_vectors[vector].pdev = PCI_DEVICE(s);
qemu_set_fd_handler(eventfd, ivshmem_vector_notify,
NULL, &s->msi_vectors[vector]);
}
static int check_shm_size(IVShmemState *s, int fd, Error **errp)
@ -591,7 +569,7 @@ static void setup_interrupt(IVShmemState *s, int vector)
if (!with_irqfd) {
IVSHMEM_DPRINTF("with eventfd");
s->eventfd_chr[vector] = create_eventfd_chr_device(s, n, vector);
watch_vector_notifier(s, n, vector);
} else if (msix_enabled(pdev)) {
IVSHMEM_DPRINTF("with irqfd");
if (ivshmem_add_kvm_msi_virq(s, vector) < 0) {
@ -772,18 +750,20 @@ static void ivshmem_reset(DeviceState *d)
ivshmem_use_msix(s);
}
static int ivshmem_setup_msi(IVShmemState * s)
static int ivshmem_setup_interrupts(IVShmemState *s)
{
if (msix_init_exclusive_bar(PCI_DEVICE(s), s->vectors, 1)) {
return -1;
}
IVSHMEM_DPRINTF("msix initialized (%d vectors)\n", s->vectors);
/* allocate QEMU char devices for receiving interrupts */
/* allocate QEMU callback data for receiving interrupts */
s->msi_vectors = g_malloc0(s->vectors * sizeof(MSIVector));
ivshmem_use_msix(s);
if (ivshmem_has_feature(s, IVSHMEM_MSI)) {
if (msix_init_exclusive_bar(PCI_DEVICE(s), s->vectors, 1)) {
return -1;
}
IVSHMEM_DPRINTF("msix initialized (%d vectors)\n", s->vectors);
ivshmem_use_msix(s);
}
return 0;
}
@ -950,9 +930,8 @@ static void pci_ivshmem_realize(PCIDevice *dev, Error **errp)
IVSHMEM_DPRINTF("using shared memory server (socket = %s)\n",
s->server_chr->filename);
if (ivshmem_has_feature(s, IVSHMEM_MSI) &&
ivshmem_setup_msi(s)) {
error_setg(errp, "msix initialization failed");
if (ivshmem_setup_interrupts(s) < 0) {
error_setg(errp, "failed to initialize interrupts");
return;
}

3
include/sysemu/char.h
View file

@ -360,9 +360,6 @@ void register_char_driver(const char *name, ChardevBackendKind kind,
CharDriverState *(*create)(const char *id, ChardevBackend *backend,
ChardevReturn *ret, Error **errp));
/* add an eventfd to the qemu devices that are polled */
CharDriverState *qemu_chr_open_eventfd(int eventfd);
extern int term_escape_char;
CharDriverState *qemu_char_get_next_serial(void);

13
qemu-char.c
View file

@ -2838,19 +2838,6 @@ static int tcp_chr_sync_read(CharDriverState *chr, const uint8_t *buf, int len)
return size;
}
#ifndef _WIN32
CharDriverState *qemu_chr_open_eventfd(int eventfd)
{
CharDriverState *chr = qemu_chr_open_fd(eventfd, eventfd, NULL, NULL);
if (chr) {
chr->avail_connections = 1;
}
return chr;
}
#endif
static void tcp_chr_connect(void *opaque)
{
CharDriverState *chr = opaque;

81
tests/ivshmem-test.c
View file

@ -34,12 +34,10 @@ static void save_fn(QPCIDevice *dev, int devfn, void *data)
*pdev = dev;
}
static QPCIDevice *get_device(void)
static QPCIDevice *get_device(QPCIBus *pcibus)
{
QPCIDevice *dev;
QPCIBus *pcibus;
pcibus = qpci_init_pc();
dev = NULL;
qpci_device_foreach(pcibus, 0x1af4, 0x1110, save_fn, &dev);
g_assert(dev != NULL);
@ -50,6 +48,7 @@ static QPCIDevice *get_device(void)
typedef struct _IVState {
QTestState *qtest;
void *reg_base, *mem_base;
QPCIBus *pcibus;
QPCIDevice *dev;
} IVState;
@ -100,13 +99,20 @@ static inline void out_reg(IVState *s, enum Reg reg, unsigned v)
global_qtest = qtest;
}
static void cleanup_vm(IVState *s)
{
g_free(s->dev);
qpci_free_pc(s->pcibus);
qtest_quit(s->qtest);
}
static void setup_vm_cmd(IVState *s, const char *cmd, bool msix)
{
uint64_t barsize;
s->qtest = qtest_start(cmd);
s->dev = get_device();
s->pcibus = qpci_init_pc();
s->dev = get_device(s->pcibus);
/* FIXME: other bar order fails, mappings changes */
s->mem_base = qpci_iomap(s->dev, 2, &barsize);
@ -173,7 +179,7 @@ static void test_ivshmem_single(void)
g_assert_cmpuint(data[i], ==, i);
}
qtest_quit(s->qtest);
cleanup_vm(s);
}
static void test_ivshmem_pair(void)
@ -218,8 +224,8 @@ static void test_ivshmem_pair(void)
g_assert_cmpuint(data[i], ==, 0x44);
}
qtest_quit(s1->qtest);
qtest_quit(s2->qtest);
cleanup_vm(s1);
cleanup_vm(s2);
g_free(data);
}
@ -271,18 +277,18 @@ static void *server_thread(void *data)
return NULL;
}
static void setup_vm_with_server(IVState *s, int nvectors)
static void setup_vm_with_server(IVState *s, int nvectors, bool msi)
{
char *cmd = g_strdup_printf("-chardev socket,id=chr0,path=%s,nowait "
"-device ivshmem,size=1M,chardev=chr0,vectors=%d",
tmpserver, nvectors);
"-device ivshmem,size=1M,chardev=chr0,vectors=%d,msi=%s",
tmpserver, nvectors, msi ? "true" : "false");
setup_vm_cmd(s, cmd, true);
setup_vm_cmd(s, cmd, msi);
g_free(cmd);
}
static void test_ivshmem_server(void)
static void test_ivshmem_server(bool msi)
{
IVState state1, state2, *s1, *s2;
ServerThread thread;
@ -300,9 +306,9 @@ static void test_ivshmem_server(void)
ret = ivshmem_server_start(&server);
g_assert_cmpint(ret, ==, 0);
setup_vm_with_server(&state1, nvectors);
setup_vm_with_server(&state1, nvectors, msi);
s1 = &state1;
setup_vm_with_server(&state2, nvectors);
setup_vm_with_server(&state2, nvectors, msi);
s2 = &state2;
g_assert_cmpuint(in_reg(s1, IVPOSITION), ==, 0xffffffff);
@ -332,32 +338,42 @@ static void test_ivshmem_server(void)
g_assert_cmpuint(vm1, !=, vm2);
global_qtest = s1->qtest;
ret = qpci_msix_table_size(s1->dev);
g_assert_cmpuint(ret, ==, nvectors);
if (msi) {
ret = qpci_msix_table_size(s1->dev);
g_assert_cmpuint(ret, ==, nvectors);
}
/* ping vm2 -> vm1 */
ret = qpci_msix_pending(s1->dev, 0);
g_assert_cmpuint(ret, ==, 0);
if (msi) {
ret = qpci_msix_pending(s1->dev, 0);
g_assert_cmpuint(ret, ==, 0);
} else {
out_reg(s1, INTRSTATUS, 0);
}
out_reg(s2, DOORBELL, vm1 << 16);
do {
g_usleep(10000);
ret = qpci_msix_pending(s1->dev, 0);
ret = msi ? qpci_msix_pending(s1->dev, 0) : in_reg(s1, INTRSTATUS);
} while (ret == 0 && g_get_monotonic_time() < end_time);
g_assert_cmpuint(ret, !=, 0);
/* ping vm1 -> vm2 */
global_qtest = s2->qtest;
ret = qpci_msix_pending(s2->dev, 0);
g_assert_cmpuint(ret, ==, 0);
if (msi) {
ret = qpci_msix_pending(s2->dev, 0);
g_assert_cmpuint(ret, ==, 0);
} else {
out_reg(s2, INTRSTATUS, 0);
}
out_reg(s1, DOORBELL, vm2 << 16);
do {
g_usleep(10000);
ret = qpci_msix_pending(s2->dev, 0);
ret = msi ? qpci_msix_pending(s2->dev, 0) : in_reg(s2, INTRSTATUS);
} while (ret == 0 && g_get_monotonic_time() < end_time);
g_assert_cmpuint(ret, !=, 0);
qtest_quit(s2->qtest);
qtest_quit(s1->qtest);
cleanup_vm(s2);
cleanup_vm(s1);
if (qemu_write_full(thread.pipe[1], "q", 1) != 1) {
g_error("qemu_write_full: %s", g_strerror(errno));
@ -370,6 +386,16 @@ static void test_ivshmem_server(void)
close(thread.pipe[0]);
}
static void test_ivshmem_server_msi(void)
{
test_ivshmem_server(true);
}
static void test_ivshmem_server_irq(void)
{
test_ivshmem_server(false);
}
#define PCI_SLOT_HP 0x06
static void test_ivshmem_hotplug(void)
@ -395,7 +421,7 @@ static void test_ivshmem_memdev(void)
setup_vm_cmd(&state, "-object memory-backend-ram,size=1M,id=mb1"
" -device ivshmem,x-memdev=mb1", false);
qtest_quit(state.qtest);
cleanup_vm(&state);
}
static void cleanup(void)
@ -483,7 +509,8 @@ int main(int argc, char **argv)
qtest_add_func("/ivshmem/memdev", test_ivshmem_memdev);
if (g_test_slow()) {
qtest_add_func("/ivshmem/pair", test_ivshmem_pair);
qtest_add_func("/ivshmem/server", test_ivshmem_server);
qtest_add_func("/ivshmem/server-msi", test_ivshmem_server_msi);
qtest_add_func("/ivshmem/server-irq", test_ivshmem_server_irq);
}
ret = g_test_run();

2
tests/libqos/pci.c
View file

@ -34,11 +34,13 @@ void qpci_device_foreach(QPCIBus *bus, int vendor_id, int device_id,
if (vendor_id != -1 &&
qpci_config_readw(dev, PCI_VENDOR_ID) != vendor_id) {
g_free(dev);
continue;
}
if (device_id != -1 &&
qpci_config_readw(dev, PCI_DEVICE_ID) != device_id) {
g_free(dev);
continue;
}