Commit 074d1ccb authored by Peter Maydell's avatar Peter Maydell
Browse files

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: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 10ae9d76 6db26255

hw/misc/ivshmem.c

+30 −51
Original line number Diff line number Diff line
@@ -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);

    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,

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;



    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)

{

    /* allocate QEMU callback data for receiving interrupts */

    s->msi_vectors = g_malloc0(s->vectors * sizeof(MSIVector));



    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);



    /* allocate QEMU char devices for receiving interrupts */

    s->msi_vectors = g_malloc0(s->vectors * sizeof(MSIVector));



        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;

        }

include/sysemu/char.h

+0 −3
Original line number Diff line number Diff line
@@ -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);

qemu-char.c

+0 −13
Original line number Diff line number Diff line
@@ -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;

tests/ivshmem-test.c

+54 −27
Original line number Diff line number Diff line
@@ -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;

    if (msi) {

        ret = qpci_msix_table_size(s1->dev);

        g_assert_cmpuint(ret, ==, nvectors);

    }



    /* ping vm2 -> vm1 */

    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;

    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();

tests/libqos/pci.c

+2 −0
Original line number Diff line number Diff line
@@ -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;

            }