s = g_new0(AHCIQState, 1);
s->parent = qtest_pc_vboot(cli, ap);
global_qtest = s->parent->qts;
- alloc_set_flags(s->parent->alloc, ALLOC_LEAK_ASSERT);
+ alloc_set_flags(&s->parent->alloc, ALLOC_LEAK_ASSERT);
/* Verify that we have an AHCI device present. */
s->dev = get_ahci_device(s->parent->qts, &s->fingerprint);
generate_pattern(tx, bufsize, AHCI_SECTOR_SIZE);
/* Create a DMA buffer in guest memory, and write our pattern to it. */
- ptr = guest_alloc(ahci->parent->alloc, bufsize);
+ ptr = guest_alloc(&ahci->parent->alloc, bufsize);
g_assert(ptr);
bufwrite(ptr, tx, bufsize);
/* Read back the guest's receive buffer into local memory */
bufread(ptr, rx, bufsize);
- guest_free(ahci->parent->alloc, ptr);
+ guest_free(&ahci->parent->alloc, ptr);
g_assert_cmphex(memcmp(tx, rx, bufsize), ==, 0);
} e1000e_device;
static int test_sockets[2];
-static QGuestAllocator *test_alloc;
+static QGuestAllocator test_alloc;
static QPCIBus *test_bus;
static void e1000e_pci_foreach_callback(QPCIDevice *dev, int devfn, void *data)
val | E1000E_CTRL_EXT_DRV_LOAD | E1000E_CTRL_EXT_TXLSFLOW);
/* Allocate and setup TX ring */
- d->tx_ring = guest_alloc(test_alloc, E1000E_RING_LEN);
+ d->tx_ring = guest_alloc(&test_alloc, E1000E_RING_LEN);
g_assert(d->tx_ring != 0);
e1000e_macreg_write(d, E1000E_TDBAL, (uint32_t) d->tx_ring);
e1000e_macreg_write(d, E1000E_TCTL, E1000E_TCTL_EN);
/* Allocate and setup RX ring */
- d->rx_ring = guest_alloc(test_alloc, E1000E_RING_LEN);
+ d->rx_ring = guest_alloc(&test_alloc, E1000E_RING_LEN);
g_assert(d->rx_ring != 0);
e1000e_macreg_write(d, E1000E_RDBAL, (uint32_t)d->rx_ring);
uint32_t recv_len;
/* Prepare test data buffer */
- uint64_t data = guest_alloc(test_alloc, data_len);
+ uint64_t data = guest_alloc(&test_alloc, data_len);
memwrite(data, "TEST", 5);
/* Prepare TX descriptor */
g_assert_cmpstr(buffer, == , "TEST");
/* Free test data buffer */
- guest_free(test_alloc, data);
+ guest_free(&test_alloc, data);
}
static void e1000e_receive_verify(e1000e_device *d)
g_assert_cmpint(ret, == , sizeof(test) + sizeof(len));
/* Prepare test data buffer */
- uint64_t data = guest_alloc(test_alloc, data_len);
+ uint64_t data = guest_alloc(&test_alloc, data_len);
/* Prepare RX descriptor */
memset(&descr, 0, sizeof(descr));
g_assert_cmpstr(buffer, == , "TEST");
/* Free test data buffer */
- guest_free(test_alloc, data);
+ guest_free(&test_alloc, data);
}
static void e1000e_device_clear(QPCIBus *bus, e1000e_device *d)
qtest_start(cmdline);
g_free(cmdline);
- test_alloc = pc_alloc_init(global_qtest);
- g_assert_nonnull(test_alloc);
-
- test_bus = qpci_new_pc(global_qtest, test_alloc);
+ pc_alloc_init(&test_alloc, global_qtest, 0);
+ test_bus = qpci_new_pc(global_qtest, &test_alloc);
g_assert_nonnull(test_bus);
e1000e_device_init(test_bus, d);
{
e1000e_device_clear(test_bus, d);
close(test_sockets[0]);
- pc_alloc_uninit(test_alloc);
+ alloc_destroy(&test_alloc);
g_free(d->pci_dev);
qpci_free_pc(test_bus);
qtest_end();
#define assert_bit_clear(data, mask) g_assert_cmphex((data) & (mask), ==, 0)
static QPCIBus *pcibus = NULL;
-static QGuestAllocator *guest_malloc;
+static QGuestAllocator guest_malloc;
static char tmp_path[] = "/tmp/qtest.XXXXXX";
static char debug_path[] = "/tmp/qtest-blkdebug.XXXXXX";
va_end(ap);
qtest_start(cmdline);
- guest_malloc = pc_alloc_init(global_qtest);
+ pc_alloc_init(&guest_malloc, global_qtest, 0);
g_free(cmdline);
}
qpci_free_pc(pcibus);
pcibus = NULL;
}
- pc_alloc_uninit(guest_malloc);
- guest_malloc = NULL;
+ alloc_destroy(&guest_malloc);
qtest_end();
}
/* Setup PRDT */
len = sizeof(*prdt) * prdt_entries;
- guest_prdt = guest_alloc(guest_malloc, len);
+ guest_prdt = guest_alloc(&guest_malloc, len);
memwrite(guest_prdt, prdt, len);
qpci_io_writel(dev, bmdma_bar, bmreg_prdt, guest_prdt);
uint8_t *buf;
uint8_t *cmpbuf;
size_t len = 512;
- uintptr_t guest_buf = guest_alloc(guest_malloc, len);
+ uintptr_t guest_buf = guest_alloc(&guest_malloc, len);
PrdtEntry prdt[] = {
{
const uint64_t bad_range = trim_range_le(TEST_IMAGE_SIZE / 512 - 1, 2);
size_t len = 512;
uint8_t *buf;
- uintptr_t guest_buf = guest_alloc(guest_malloc, len);
+ uintptr_t guest_buf = guest_alloc(&guest_malloc, len);
PrdtEntry prdt[] = {
{
dev = get_pci_device(&bmdma_bar, &ide_bar);
- guest_buf = guest_alloc(guest_malloc, len);
+ guest_buf = guest_alloc(&guest_malloc, len);
buf = g_malloc(len);
memset(buf, rand() % 255 + 1, len);
g_assert(guest_buf);
"-device ide-cd,drive=sr0,bus=ide.0", tmp_path);
qtest_irq_intercept_in(global_qtest, "ioapic");
- guest_buf = guest_alloc(guest_malloc, len);
+ guest_buf = guest_alloc(&guest_malloc, len);
prdt[0].addr = cpu_to_le32(guest_buf);
prdt[0].size = cpu_to_le32(len | PRDT_EOT);
#include "libqos/pci-pc.h"
static QOSOps qos_ops = {
- .init_allocator = pc_alloc_init_flags,
- .uninit_allocator = pc_alloc_uninit,
+ .alloc_init = pc_alloc_init,
.qpci_new = qpci_new_pc,
.qpci_free = qpci_free_pc,
.shutdown = qtest_pc_shutdown,
#include "libqos/pci-spapr.h"
static QOSOps qos_ops = {
- .init_allocator = spapr_alloc_init_flags,
- .uninit_allocator = spapr_alloc_uninit,
+ .alloc_init = spapr_alloc_init,
.qpci_new = qpci_new_spapr,
.qpci_free = qpci_free_spapr,
.shutdown = qtest_spapr_shutdown,
qs->qts = qtest_init(cmdline);
qs->ops = ops;
if (ops) {
- qs->alloc = ops->init_allocator(qs->qts, ALLOC_NO_FLAGS);
- qs->pcibus = ops->qpci_new(qs->qts, qs->alloc);
+ ops->alloc_init(&qs->alloc, qs->qts, ALLOC_NO_FLAGS);
+ qs->pcibus = ops->qpci_new(qs->qts, &qs->alloc);
}
g_free(cmdline);
qs->ops->qpci_free(qs->pcibus);
qs->pcibus = NULL;
}
- if (qs->alloc && qs->ops->uninit_allocator) {
- qs->ops->uninit_allocator(qs->alloc);
- qs->alloc = NULL;
- }
}
+ alloc_destroy(&qs->alloc);
qtest_quit(qs->qts);
g_free(qs);
}
/* If we were running, we can wait for an event. */
if (running) {
- migrate_allocator(from->alloc, to->alloc);
+ migrate_allocator(&from->alloc, &to->alloc);
set_context(to);
qtest_qmp_eventwait(to->qts, "RESUME");
return;
g_assert_not_reached();
}
- migrate_allocator(from->alloc, to->alloc);
+ migrate_allocator(&from->alloc, &to->alloc);
set_context(to);
}
#include "libqtest.h"
#include "libqos/pci.h"
-#include "libqos/malloc-pc.h"
+#include "libqos/malloc.h"
typedef struct QOSState QOSState;
typedef struct QOSOps {
- QGuestAllocator *(*init_allocator)(QTestState *qts, QAllocOpts);
- void (*uninit_allocator)(QGuestAllocator *);
+ void (*alloc_init)(QGuestAllocator *, QTestState *, QAllocOpts);
QPCIBus *(*qpci_new)(QTestState *qts, QGuestAllocator *alloc);
void (*qpci_free)(QPCIBus *bus);
void (*shutdown)(QOSState *);
struct QOSState {
QTestState *qts;
- QGuestAllocator *alloc;
+ QGuestAllocator alloc;
QPCIBus *pcibus;
QOSOps *ops;
};
static inline uint64_t qmalloc(QOSState *q, size_t bytes)
{
- return guest_alloc(q->alloc, bytes);
+ return guest_alloc(&q->alloc, bytes);
}
static inline void qfree(QOSState *q, uint64_t addr)
{
- guest_free(q->alloc, addr);
+ guest_free(&q->alloc, addr);
}
#endif
#include "libqos/malloc-generic.h"
#include "libqos/malloc.h"
-/*
- * Mostly for valgrind happiness, but it does offer
- * a chokepoint for debugging guest memory leaks, too.
- */
-void generic_alloc_uninit(QGuestAllocator *allocator)
-{
- alloc_uninit(allocator);
-}
-
-QGuestAllocator *generic_alloc_init_flags(uint64_t base_addr, uint64_t size,
- uint32_t page_size, QAllocOpts flags)
+void generic_alloc_init(QGuestAllocator *s, uint64_t base_addr,
+ uint64_t size, uint32_t page_size)
{
- QGuestAllocator *s;
uint64_t start = base_addr + (1 << 20); /* Start at 1MB */
- s = alloc_init_flags(flags, start, start + size);
- alloc_set_page_size(s, page_size);
-
- return s;
-}
-
-inline QGuestAllocator *generic_alloc_init(uint64_t base_addr, uint64_t size,
- uint32_t page_size)
-{
- return generic_alloc_init_flags(base_addr, size, page_size, ALLOC_NO_FLAGS);
+ alloc_init(s, 0, start, start + size, page_size);
}
#include "libqos/malloc.h"
-QGuestAllocator *generic_alloc_init(uint64_t base_addr, uint64_t size,
- uint32_t page_size);
-QGuestAllocator *generic_alloc_init_flags(uint64_t base_addr, uint64_t size,
- uint32_t page_size, QAllocOpts flags);
-void generic_alloc_uninit(QGuestAllocator *allocator);
+void generic_alloc_init(QGuestAllocator *s, uint64_t base_addr, uint64_t size,
+ uint32_t page_size);
#endif
#define PAGE_SIZE (4096)
-/*
- * Mostly for valgrind happiness, but it does offer
- * a chokepoint for debugging guest memory leaks, too.
- */
-void pc_alloc_uninit(QGuestAllocator *allocator)
-{
- alloc_uninit(allocator);
-}
-
-QGuestAllocator *pc_alloc_init_flags(QTestState *qts, QAllocOpts flags)
+void pc_alloc_init(QGuestAllocator *s, QTestState *qts, QAllocOpts flags)
{
- QGuestAllocator *s;
uint64_t ram_size;
QFWCFG *fw_cfg = pc_fw_cfg_init(qts);
ram_size = qfw_cfg_get_u64(fw_cfg, FW_CFG_RAM_SIZE);
- s = alloc_init_flags(flags, 1 << 20, MIN(ram_size, 0xE0000000));
- alloc_set_page_size(s, PAGE_SIZE);
+ alloc_init(s, flags, 1 << 20, MIN(ram_size, 0xE0000000), PAGE_SIZE);
/* clean-up */
g_free(fw_cfg);
-
- return s;
-}
-
-inline QGuestAllocator *pc_alloc_init(QTestState *qts)
-{
- return pc_alloc_init_flags(qts, ALLOC_NO_FLAGS);
}
#include "libqos/malloc.h"
-QGuestAllocator *pc_alloc_init(QTestState *qts);
-QGuestAllocator *pc_alloc_init_flags(QTestState *qts, QAllocOpts flags);
-void pc_alloc_uninit(QGuestAllocator *allocator);
+void pc_alloc_init(QGuestAllocator *s, QTestState *qts, QAllocOpts flags);
#endif
*/
#define SPAPR_MIN_SIZE 0x10000000
-void spapr_alloc_uninit(QGuestAllocator *allocator)
+void spapr_alloc_init(QGuestAllocator *s, QTestState *qts, QAllocOpts flags)
{
- alloc_uninit(allocator);
-}
-
-QGuestAllocator *spapr_alloc_init_flags(QTestState *qts, QAllocOpts flags)
-{
- QGuestAllocator *s;
-
- s = alloc_init_flags(flags, 1 << 20, SPAPR_MIN_SIZE);
- alloc_set_page_size(s, PAGE_SIZE);
-
- return s;
-}
-
-QGuestAllocator *spapr_alloc_init(void)
-{
- return spapr_alloc_init_flags(NULL, ALLOC_NO_FLAGS);
+ alloc_init(s, flags, 1 << 20, SPAPR_MIN_SIZE, PAGE_SIZE);
}
#include "libqos/malloc.h"
-QGuestAllocator *spapr_alloc_init(void);
-QGuestAllocator *spapr_alloc_init_flags(QTestState *qts, QAllocOpts flags);
-void spapr_alloc_uninit(QGuestAllocator *allocator);
+void spapr_alloc_init(QGuestAllocator *s, QTestState *qts, QAllocOpts flags);
#endif
#include "qemu-common.h"
#include "qemu/host-utils.h"
-typedef QTAILQ_HEAD(MemList, MemBlock) MemList;
-
typedef struct MemBlock {
QTAILQ_ENTRY(MemBlock) MLIST_ENTNAME;
uint64_t size;
uint64_t addr;
} MemBlock;
-struct QGuestAllocator {
- QAllocOpts opts;
- uint64_t start;
- uint64_t end;
- uint32_t page_size;
-
- MemList *used;
- MemList *free;
-};
-
#define DEFAULT_PAGE_SIZE 4096
static void mlist_delete(MemList *list, MemBlock *node)
* Mostly for valgrind happiness, but it does offer
* a chokepoint for debugging guest memory leaks, too.
*/
-void alloc_uninit(QGuestAllocator *allocator)
+void alloc_destroy(QGuestAllocator *allocator)
{
MemBlock *node;
MemBlock *tmp;
g_free(allocator->used);
g_free(allocator->free);
- g_free(allocator);
}
uint64_t guest_alloc(QGuestAllocator *allocator, size_t size)
}
}
-QGuestAllocator *alloc_init(uint64_t start, uint64_t end)
+void alloc_init(QGuestAllocator *s, QAllocOpts opts,
+ uint64_t start, uint64_t end,
+ size_t page_size)
{
- QGuestAllocator *s = g_malloc0(sizeof(*s));
MemBlock *node;
+ s->opts = opts;
s->start = start;
s->end = end;
node = mlist_new(s->start, s->end - s->start);
QTAILQ_INSERT_HEAD(s->free, node, MLIST_ENTNAME);
- s->page_size = DEFAULT_PAGE_SIZE;
-
- return s;
-}
-
-QGuestAllocator *alloc_init_flags(QAllocOpts opts,
- uint64_t start, uint64_t end)
-{
- QGuestAllocator *s = alloc_init(start, end);
- s->opts = opts;
- return s;
-}
-
-void alloc_set_page_size(QGuestAllocator *allocator, size_t page_size)
-{
- /* Can't alter the page_size for an allocator in-use */
- g_assert(QTAILQ_EMPTY(allocator->used));
-
- g_assert(is_power_of_2(page_size));
- allocator->page_size = page_size;
+ s->page_size = page_size;
}
void alloc_set_flags(QGuestAllocator *allocator, QAllocOpts opts)
ALLOC_PARANOID = 0x04
} QAllocOpts;
-typedef struct QGuestAllocator QGuestAllocator;
+typedef QTAILQ_HEAD(MemList, MemBlock) MemList;
-void alloc_uninit(QGuestAllocator *allocator);
+typedef struct QGuestAllocator {
+ QAllocOpts opts;
+ uint64_t start;
+ uint64_t end;
+ uint32_t page_size;
+
+ MemList *used;
+ MemList *free;
+} QGuestAllocator;
/* Always returns page aligned values */
uint64_t guest_alloc(QGuestAllocator *allocator, size_t size);
void guest_free(QGuestAllocator *allocator, uint64_t addr);
void migrate_allocator(QGuestAllocator *src, QGuestAllocator *dst);
-QGuestAllocator *alloc_init(uint64_t start, uint64_t end);
-QGuestAllocator *alloc_init_flags(QAllocOpts flags,
- uint64_t start, uint64_t end);
-void alloc_set_page_size(QGuestAllocator *allocator, size_t page_size);
void alloc_set_flags(QGuestAllocator *allocator, QAllocOpts opts);
+void alloc_init(QGuestAllocator *alloc, QAllocOpts flags,
+ uint64_t start, uint64_t end,
+ size_t page_size);
+void alloc_destroy(QGuestAllocator *allocator);
+
#endif
global_qtest = qs->qts;
t1 = time(NULL);
- ret = qrtas_get_time_of_day(qs->qts, qs->alloc, &tm, &ns);
+ ret = qrtas_get_time_of_day(qs->qts, &qs->alloc, &tm, &ns);
g_assert_cmpint(ret, ==, 0);
t2 = mktimegm(&tm);
g_assert(t2 - t1 < 5); /* 5 sec max to run the test */
bool test_fail;
int test_flags;
int queues;
- QGuestAllocator *alloc;
+ QGuestAllocator alloc;
} TestServer;
static TestServer *test_server_new(const gchar *name);
qvirtio_pci_device_enable(s->dev);
qvirtio_start_device(&s->dev->vdev);
- s->alloc = pc_alloc_init(qts);
+ pc_alloc_init(&s->alloc, qts, 0);
for (i = 0; i < s->queues * 2; i++) {
- s->vq[i] = qvirtqueue_setup(&s->dev->vdev, s->alloc, i);
+ s->vq[i] = qvirtqueue_setup(&s->dev->vdev, &s->alloc, i);
}
features = qvirtio_get_features(&s->dev->vdev);
int i;
for (i = 0; i < s->queues * 2; i++) {
- qvirtqueue_cleanup(s->dev->vdev.bus, s->vq[i], s->alloc);
+ qvirtqueue_cleanup(s->dev->vdev.bus, s->vq[i], &s->alloc);
}
- pc_alloc_uninit(s->alloc);
+ alloc_destroy(&s->alloc);
qvirtio_pci_device_free(s->dev);
}
qvirtio_pci_device_enable(dev);
qvirtio_start_device(v9p->dev);
- v9p->vq = qvirtqueue_setup(v9p->dev, v9p->qs->alloc, 0);
+ v9p->vq = qvirtqueue_setup(v9p->dev, &v9p->qs->alloc, 0);
qvirtio_set_driver_ok(v9p->dev);
static void qvirtio_9p_pci_stop(QVirtIO9P *v9p)
{
- qvirtqueue_cleanup(v9p->dev->bus, v9p->vq, v9p->qs->alloc);
+ qvirtqueue_cleanup(v9p->dev->bus, v9p->vq, &v9p->qs->alloc);
qvirtio_pci_device_disable(container_of(v9p->dev, QVirtioPCIDevice, vdev));
qvirtio_pci_device_free((QVirtioPCIDevice *)v9p->dev);
qvirtio_9p_stop(v9p);
req->v9p = v9p;
req->t_size = total_size;
- req->t_msg = guest_alloc(v9p->qs->alloc, req->t_size);
+ req->t_msg = guest_alloc(&v9p->qs->alloc, req->t_size);
v9fs_memwrite(req, &hdr, 7);
req->tag = tag;
return req;
{
QVirtIO9P *v9p = req->v9p;
- req->r_msg = guest_alloc(v9p->qs->alloc, P9_MAX_SIZE);
+ req->r_msg = guest_alloc(&v9p->qs->alloc, P9_MAX_SIZE);
req->free_head = qvirtqueue_add(v9p->vq, req->t_msg, req->t_size, false,
true);
qvirtqueue_add(v9p->vq, req->r_msg, P9_MAX_SIZE, true, false);
{
QVirtIO9P *v9p = req->v9p;
- guest_free(v9p->qs->alloc, req->t_msg);
- guest_free(v9p->qs->alloc, req->r_msg);
+ guest_free(&v9p->qs->alloc, req->t_msg);
+ guest_free(&v9p->qs->alloc, req->r_msg);
g_free(req);
}
#include "libqos/virtio.h"
#include "libqos/virtio-pci.h"
#include "libqos/virtio-mmio.h"
+#include "libqos/malloc.h"
#include "libqos/malloc-generic.h"
#include "qapi/qmp/qdict.h"
#include "qemu/bswap.h"
qs = pci_test_start();
dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT);
- vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 0);
+ vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, &qs->alloc, 0);
- test_basic(&dev->vdev, qs->alloc, &vqpci->vq);
+ test_basic(&dev->vdev, &qs->alloc, &vqpci->vq);
/* End test */
- qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
+ qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, &qs->alloc);
qvirtio_pci_device_disable(dev);
qvirtio_pci_device_free(dev);
qtest_shutdown(qs);
(1u << VIRTIO_BLK_F_SCSI));
qvirtio_set_features(&dev->vdev, features);
- vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 0);
+ vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, &qs->alloc, 0);
qvirtio_set_driver_ok(&dev->vdev);
/* Write request */
req.data = g_malloc0(512);
strcpy(req.data, "TEST");
- req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
+ req_addr = virtio_blk_request(&qs->alloc, &dev->vdev, &req, 512);
g_free(req.data);
- indirect = qvring_indirect_desc_setup(&dev->vdev, qs->alloc, 2);
+ indirect = qvring_indirect_desc_setup(&dev->vdev, &qs->alloc, 2);
qvring_indirect_desc_add(indirect, req_addr, 528, false);
qvring_indirect_desc_add(indirect, req_addr + 528, 1, true);
free_head = qvirtqueue_add_indirect(&vqpci->vq, indirect);
g_assert_cmpint(status, ==, 0);
g_free(indirect);
- guest_free(qs->alloc, req_addr);
+ guest_free(&qs->alloc, req_addr);
/* Read request */
req.type = VIRTIO_BLK_T_IN;
req.data = g_malloc0(512);
strcpy(req.data, "TEST");
- req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
+ req_addr = virtio_blk_request(&qs->alloc, &dev->vdev, &req, 512);
g_free(req.data);
- indirect = qvring_indirect_desc_setup(&dev->vdev, qs->alloc, 2);
+ indirect = qvring_indirect_desc_setup(&dev->vdev, &qs->alloc, 2);
qvring_indirect_desc_add(indirect, req_addr, 16, false);
qvring_indirect_desc_add(indirect, req_addr + 16, 513, true);
free_head = qvirtqueue_add_indirect(&vqpci->vq, indirect);
g_free(data);
g_free(indirect);
- guest_free(qs->alloc, req_addr);
+ guest_free(&qs->alloc, req_addr);
/* End test */
- qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
+ qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, &qs->alloc);
qvirtio_pci_device_disable(dev);
qvirtio_pci_device_free(dev);
qtest_shutdown(qs);
dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT);
qpci_msix_enable(dev->pdev);
- qvirtio_pci_set_msix_configuration_vector(dev, qs->alloc, 0);
+ qvirtio_pci_set_msix_configuration_vector(dev, &qs->alloc, 0);
capacity = qvirtio_config_readq(&dev->vdev, 0);
g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
(1u << VIRTIO_BLK_F_SCSI));
qvirtio_set_features(&dev->vdev, features);
- vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 0);
- qvirtqueue_pci_msix_setup(dev, vqpci, qs->alloc, 1);
+ vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, &qs->alloc, 0);
+ qvirtqueue_pci_msix_setup(dev, vqpci, &qs->alloc, 1);
qvirtio_set_driver_ok(&dev->vdev);
req.data = g_malloc0(512);
strcpy(req.data, "TEST");
- req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
+ req_addr = virtio_blk_request(&qs->alloc, &dev->vdev, &req, 512);
g_free(req.data);
status = readb(req_addr + 528);
g_assert_cmpint(status, ==, 0);
- guest_free(qs->alloc, req_addr);
+ guest_free(&qs->alloc, req_addr);
/* Read request */
req.type = VIRTIO_BLK_T_IN;
req.sector = 0;
req.data = g_malloc0(512);
- req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
+ req_addr = virtio_blk_request(&qs->alloc, &dev->vdev, &req, 512);
g_free(req.data);
g_assert_cmpstr(data, ==, "TEST");
g_free(data);
- guest_free(qs->alloc, req_addr);
+ guest_free(&qs->alloc, req_addr);
/* End test */
- qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
+ qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, &qs->alloc);
qpci_msix_disable(dev->pdev);
qvirtio_pci_device_disable(dev);
qvirtio_pci_device_free(dev);
dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT);
qpci_msix_enable(dev->pdev);
- qvirtio_pci_set_msix_configuration_vector(dev, qs->alloc, 0);
+ qvirtio_pci_set_msix_configuration_vector(dev, &qs->alloc, 0);
capacity = qvirtio_config_readq(&dev->vdev, 0);
g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
(1u << VIRTIO_BLK_F_SCSI));
qvirtio_set_features(&dev->vdev, features);
- vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 0);
- qvirtqueue_pci_msix_setup(dev, vqpci, qs->alloc, 1);
+ vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, &qs->alloc, 0);
+ qvirtqueue_pci_msix_setup(dev, vqpci, &qs->alloc, 1);
qvirtio_set_driver_ok(&dev->vdev);
req.data = g_malloc0(512);
strcpy(req.data, "TEST");
- req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
+ req_addr = virtio_blk_request(&qs->alloc, &dev->vdev, &req, 512);
g_free(req.data);
req.data = g_malloc0(512);
strcpy(req.data, "TEST");
- req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
+ req_addr = virtio_blk_request(&qs->alloc, &dev->vdev, &req, 512);
g_free(req.data);
QVIRTIO_BLK_TIMEOUT_US);
g_assert_cmpint(status, ==, 0);
- guest_free(qs->alloc, req_addr);
+ guest_free(&qs->alloc, req_addr);
/* Read request */
req.type = VIRTIO_BLK_T_IN;
req.sector = 1;
req.data = g_malloc0(512);
- req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
+ req_addr = virtio_blk_request(&qs->alloc, &dev->vdev, &req, 512);
g_free(req.data);
g_assert_cmpstr(data, ==, "TEST");
g_free(data);
- guest_free(qs->alloc, req_addr);
+ guest_free(&qs->alloc, req_addr);
/* End test */
- qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
+ qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, &qs->alloc);
qpci_msix_disable(dev->pdev);
qvirtio_pci_device_disable(dev);
qvirtio_pci_device_free(dev);
{
QVirtioMMIODevice *dev;
QVirtQueue *vq;
- QGuestAllocator *alloc;
+ QGuestAllocator alloc;
int n_size = TEST_IMAGE_SIZE / 2;
uint64_t capacity;
qvirtio_start_device(&dev->vdev);
- alloc = generic_alloc_init(MMIO_RAM_ADDR, MMIO_RAM_SIZE, MMIO_PAGE_SIZE);
- vq = qvirtqueue_setup(&dev->vdev, alloc, 0);
+ generic_alloc_init(&alloc, MMIO_RAM_ADDR, MMIO_RAM_SIZE, MMIO_PAGE_SIZE);
+ vq = qvirtqueue_setup(&dev->vdev, &alloc, 0);
- test_basic(&dev->vdev, alloc, vq);
+ test_basic(&dev->vdev, &alloc, vq);
qmp_discard_response("{ 'execute': 'block_resize', "
" 'arguments': { 'device': 'drive0', "
g_assert_cmpint(capacity, ==, n_size / 512);
/* End test */
- qvirtqueue_cleanup(dev->vdev.bus, vq, alloc);
+ qvirtqueue_cleanup(dev->vdev.bus, vq, &alloc);
g_free(dev);
- generic_alloc_uninit(alloc);
+ alloc_destroy(&alloc);
test_end();
}
"virtio-net-pci,netdev=hs0", sv[1]);
dev = virtio_net_pci_init(qs->pcibus, PCI_SLOT);
- rx = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 0);
- tx = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 1);
+ rx = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, &qs->alloc, 0);
+ tx = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, &qs->alloc, 1);
driver_init(&dev->vdev);
- func(&dev->vdev, qs->alloc, &rx->vq, &tx->vq, sv[0]);
+ func(&dev->vdev, &qs->alloc, &rx->vq, &tx->vq, sv[0]);
/* End test */
close(sv[0]);
- qvirtqueue_cleanup(dev->vdev.bus, &tx->vq, qs->alloc);
- qvirtqueue_cleanup(dev->vdev.bus, &rx->vq, qs->alloc);
+ qvirtqueue_cleanup(dev->vdev.bus, &tx->vq, &qs->alloc);
+ qvirtqueue_cleanup(dev->vdev.bus, &rx->vq, &qs->alloc);
qvirtio_pci_device_disable(dev);
g_free(dev->pdev);
g_free(dev);
int i;
for (i = 0; i < vs->num_queues + 2; i++) {
- qvirtqueue_cleanup(vs->dev->bus, vs->vq[i], vs->qs->alloc);
+ qvirtqueue_cleanup(vs->dev->bus, vs->vq[i], &vs->qs->alloc);
}
qvirtio_pci_device_disable(container_of(vs->dev, QVirtioPCIDevice, vdev));
qvirtio_pci_device_free((QVirtioPCIDevice *)vs->dev);
{
uint64_t addr;
- addr = guest_alloc(vs->qs->alloc, alloc_size);
+ addr = guest_alloc(&vs->qs->alloc, alloc_size);
if (data) {
memwrite(addr, data, alloc_size);
}
memread(resp_addr, resp_out, sizeof(*resp_out));
}
- guest_free(vs->qs->alloc, req_addr);
- guest_free(vs->qs->alloc, resp_addr);
- guest_free(vs->qs->alloc, data_in_addr);
- guest_free(vs->qs->alloc, data_out_addr);
+ guest_free(&vs->qs->alloc, req_addr);
+ guest_free(&vs->qs->alloc, resp_addr);
+ guest_free(&vs->qs->alloc, data_in_addr);
+ guest_free(&vs->qs->alloc, data_out_addr);
return response;
}
g_assert_cmpint(vs->num_queues, <, MAX_NUM_QUEUES);
for (i = 0; i < vs->num_queues + 2; i++) {
- vs->vq[i] = qvirtqueue_setup(vs->dev, vs->qs->alloc, i);
+ vs->vq[i] = qvirtqueue_setup(vs->dev, &vs->qs->alloc, i);
}
/* Clear the POWER ON OCCURRED unit attention */
projects / qemu.git / commitdiff