#include "qemu/iov.h"
#include "qemu/module.h"
#include "qemu/bitops.h"
-#include "libqos/malloc.h"
+#include "libqos/libqos-malloc.h"
#include "libqos/e1000e.h"
static void e1000e_send_verify(QE1000E *d, int *test_sockets, QGuestAllocator *alloc)
#include "qemu/main-loop.h"
#include "tests/qtest/libqtest.h"
-#include "tests/qtest/libqos/malloc.h"
+#include "tests/qtest/libqos/libqos-malloc.h"
#include "tests/qtest/libqos/qgraph.h"
#include "tests/qtest/libqos/qgraph_internal.h"
#include "tests/qtest/libqos/qos_external.h"
#include "qemu/osdep.h"
#include "../libqtest.h"
#include "qemu/module.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "qgraph.h"
#include "sdhci.h"
#include "qemu/osdep.h"
#include "../libqtest.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "qgraph.h"
#include "i2c.h"
#include "qemu/osdep.h"
#include "../libqtest.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "qgraph.h"
#include "i2c.h"
#include "qemu/osdep.h"
#include "../libqtest.h"
#include "qemu/module.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "qgraph.h"
#include "sdhci.h"
#include "qemu/osdep.h"
#include "../libqtest.h"
#include "qemu/module.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "qgraph.h"
#include "sdhci.h"
#include "qemu/osdep.h"
#include "../libqtest.h"
#include "qemu/module.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "qgraph.h"
#include "sdhci.h"
#include "qemu/osdep.h"
#include "../libqtest.h"
#include "qemu/module.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "qgraph.h"
#include "virtio-mmio.h"
#include "generic-pcihost.h"
#include "qemu/osdep.h"
#include "../libqtest.h"
#include "qemu/module.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "qgraph.h"
#include "sdhci.h"
#include "qemu/iov.h"
#include "qemu/module.h"
#include "qemu/bitops.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "qgraph.h"
#include "e1000e.h"
#define LIBQOS_GENERIC_PCIHOST_H
#include "pci.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "qgraph.h"
typedef struct QGenericPCIBus {
--- /dev/null
+/*
+ * libqos malloc support
+ *
+ * Copyright (c) 2014
+ *
+ * Author:
+ * John Snow <jsnow@redhat.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#include "qemu/osdep.h"
+#include "libqos-malloc.h"
+#include "qemu/host-utils.h"
+
+typedef struct MemBlock {
+ QTAILQ_ENTRY(MemBlock) MLIST_ENTNAME;
+ uint64_t size;
+ uint64_t addr;
+} MemBlock;
+
+#define DEFAULT_PAGE_SIZE 4096
+
+static void mlist_delete(MemList *list, MemBlock *node)
+{
+ g_assert(list && node);
+ QTAILQ_REMOVE(list, node, MLIST_ENTNAME);
+ g_free(node);
+}
+
+static MemBlock *mlist_find_key(MemList *head, uint64_t addr)
+{
+ MemBlock *node;
+ QTAILQ_FOREACH(node, head, MLIST_ENTNAME) {
+ if (node->addr == addr) {
+ return node;
+ }
+ }
+ return NULL;
+}
+
+static MemBlock *mlist_find_space(MemList *head, uint64_t size)
+{
+ MemBlock *node;
+
+ QTAILQ_FOREACH(node, head, MLIST_ENTNAME) {
+ if (node->size >= size) {
+ return node;
+ }
+ }
+ return NULL;
+}
+
+static MemBlock *mlist_sort_insert(MemList *head, MemBlock *insr)
+{
+ MemBlock *node;
+ g_assert(head && insr);
+
+ QTAILQ_FOREACH(node, head, MLIST_ENTNAME) {
+ if (insr->addr < node->addr) {
+ QTAILQ_INSERT_BEFORE(node, insr, MLIST_ENTNAME);
+ return insr;
+ }
+ }
+
+ QTAILQ_INSERT_TAIL(head, insr, MLIST_ENTNAME);
+ return insr;
+}
+
+static inline uint64_t mlist_boundary(MemBlock *node)
+{
+ return node->size + node->addr;
+}
+
+static MemBlock *mlist_join(MemList *head, MemBlock *left, MemBlock *right)
+{
+ g_assert(head && left && right);
+
+ left->size += right->size;
+ mlist_delete(head, right);
+ return left;
+}
+
+static void mlist_coalesce(MemList *head, MemBlock *node)
+{
+ g_assert(node);
+ MemBlock *left;
+ MemBlock *right;
+ char merge;
+
+ do {
+ merge = 0;
+ left = QTAILQ_PREV(node, MLIST_ENTNAME);
+ right = QTAILQ_NEXT(node, MLIST_ENTNAME);
+
+ /* clowns to the left of me */
+ if (left && mlist_boundary(left) == node->addr) {
+ node = mlist_join(head, left, node);
+ merge = 1;
+ }
+
+ /* jokers to the right */
+ if (right && mlist_boundary(node) == right->addr) {
+ node = mlist_join(head, node, right);
+ merge = 1;
+ }
+
+ } while (merge);
+}
+
+static MemBlock *mlist_new(uint64_t addr, uint64_t size)
+{
+ MemBlock *block;
+
+ if (!size) {
+ return NULL;
+ }
+ block = g_new0(MemBlock, 1);
+
+ block->addr = addr;
+ block->size = size;
+
+ return block;
+}
+
+static uint64_t mlist_fulfill(QGuestAllocator *s, MemBlock *freenode,
+ uint64_t size)
+{
+ uint64_t addr;
+ MemBlock *usednode;
+
+ g_assert(freenode);
+ g_assert_cmpint(freenode->size, >=, size);
+
+ addr = freenode->addr;
+ if (freenode->size == size) {
+ /* re-use this freenode as our used node */
+ QTAILQ_REMOVE(s->free, freenode, MLIST_ENTNAME);
+ usednode = freenode;
+ } else {
+ /* adjust the free node and create a new used node */
+ freenode->addr += size;
+ freenode->size -= size;
+ usednode = mlist_new(addr, size);
+ }
+
+ mlist_sort_insert(s->used, usednode);
+ return addr;
+}
+
+/* To assert the correctness of the list.
+ * Used only if ALLOC_PARANOID is set. */
+static void mlist_check(QGuestAllocator *s)
+{
+ MemBlock *node;
+ uint64_t addr = s->start > 0 ? s->start - 1 : 0;
+ uint64_t next = s->start;
+
+ QTAILQ_FOREACH(node, s->free, MLIST_ENTNAME) {
+ g_assert_cmpint(node->addr, >, addr);
+ g_assert_cmpint(node->addr, >=, next);
+ addr = node->addr;
+ next = node->addr + node->size;
+ }
+
+ addr = s->start > 0 ? s->start - 1 : 0;
+ next = s->start;
+ QTAILQ_FOREACH(node, s->used, MLIST_ENTNAME) {
+ g_assert_cmpint(node->addr, >, addr);
+ g_assert_cmpint(node->addr, >=, next);
+ addr = node->addr;
+ next = node->addr + node->size;
+ }
+}
+
+static uint64_t mlist_alloc(QGuestAllocator *s, uint64_t size)
+{
+ MemBlock *node;
+
+ node = mlist_find_space(s->free, size);
+ if (!node) {
+ fprintf(stderr, "Out of guest memory.\n");
+ g_assert_not_reached();
+ }
+ return mlist_fulfill(s, node, size);
+}
+
+static void mlist_free(QGuestAllocator *s, uint64_t addr)
+{
+ MemBlock *node;
+
+ if (addr == 0) {
+ return;
+ }
+
+ node = mlist_find_key(s->used, addr);
+ if (!node) {
+ fprintf(stderr, "Error: no record found for an allocation at "
+ "0x%016" PRIx64 ".\n",
+ addr);
+ g_assert_not_reached();
+ }
+
+ /* Rip it out of the used list and re-insert back into the free list. */
+ QTAILQ_REMOVE(s->used, node, MLIST_ENTNAME);
+ mlist_sort_insert(s->free, node);
+ mlist_coalesce(s->free, node);
+}
+
+/*
+ * Mostly for valgrind happiness, but it does offer
+ * a chokepoint for debugging guest memory leaks, too.
+ */
+void alloc_destroy(QGuestAllocator *allocator)
+{
+ MemBlock *node;
+ MemBlock *tmp;
+ QAllocOpts mask;
+
+ /* Check for guest leaks, and destroy the list. */
+ QTAILQ_FOREACH_SAFE(node, allocator->used, MLIST_ENTNAME, tmp) {
+ if (allocator->opts & (ALLOC_LEAK_WARN | ALLOC_LEAK_ASSERT)) {
+ fprintf(stderr, "guest malloc leak @ 0x%016" PRIx64 "; "
+ "size 0x%016" PRIx64 ".\n",
+ node->addr, node->size);
+ }
+ if (allocator->opts & (ALLOC_LEAK_ASSERT)) {
+ g_assert_not_reached();
+ }
+ g_free(node);
+ }
+
+ /* If we have previously asserted that there are no leaks, then there
+ * should be only one node here with a specific address and size. */
+ mask = ALLOC_LEAK_ASSERT | ALLOC_PARANOID;
+ QTAILQ_FOREACH_SAFE(node, allocator->free, MLIST_ENTNAME, tmp) {
+ if ((allocator->opts & mask) == mask) {
+ if ((node->addr != allocator->start) ||
+ (node->size != allocator->end - allocator->start)) {
+ fprintf(stderr, "Free list is corrupted.\n");
+ g_assert_not_reached();
+ }
+ }
+
+ g_free(node);
+ }
+
+ g_free(allocator->used);
+ g_free(allocator->free);
+}
+
+uint64_t guest_alloc(QGuestAllocator *allocator, size_t size)
+{
+ uint64_t rsize = size;
+ uint64_t naddr;
+
+ if (!size) {
+ return 0;
+ }
+
+ rsize += (allocator->page_size - 1);
+ rsize &= -allocator->page_size;
+ g_assert_cmpint((allocator->start + rsize), <=, allocator->end);
+ g_assert_cmpint(rsize, >=, size);
+
+ naddr = mlist_alloc(allocator, rsize);
+ if (allocator->opts & ALLOC_PARANOID) {
+ mlist_check(allocator);
+ }
+
+ return naddr;
+}
+
+void guest_free(QGuestAllocator *allocator, uint64_t addr)
+{
+ if (!addr) {
+ return;
+ }
+ mlist_free(allocator, addr);
+ if (allocator->opts & ALLOC_PARANOID) {
+ mlist_check(allocator);
+ }
+}
+
+void alloc_init(QGuestAllocator *s, QAllocOpts opts,
+ uint64_t start, uint64_t end,
+ size_t page_size)
+{
+ MemBlock *node;
+
+ s->opts = opts;
+ s->start = start;
+ s->end = end;
+
+ s->used = g_new(MemList, 1);
+ s->free = g_new(MemList, 1);
+ QTAILQ_INIT(s->used);
+ QTAILQ_INIT(s->free);
+
+ node = mlist_new(s->start, s->end - s->start);
+ QTAILQ_INSERT_HEAD(s->free, node, MLIST_ENTNAME);
+
+ s->page_size = page_size;
+}
+
+void alloc_set_flags(QGuestAllocator *allocator, QAllocOpts opts)
+{
+ allocator->opts |= opts;
+}
+
+void migrate_allocator(QGuestAllocator *src,
+ QGuestAllocator *dst)
+{
+ MemBlock *node, *tmp;
+ MemList *tmpused, *tmpfree;
+
+ /* The general memory layout should be equivalent,
+ * though opts can differ. */
+ g_assert_cmphex(src->start, ==, dst->start);
+ g_assert_cmphex(src->end, ==, dst->end);
+
+ /* Destroy (silently, regardless of options) the dest-list: */
+ QTAILQ_FOREACH_SAFE(node, dst->used, MLIST_ENTNAME, tmp) {
+ g_free(node);
+ }
+ QTAILQ_FOREACH_SAFE(node, dst->free, MLIST_ENTNAME, tmp) {
+ g_free(node);
+ }
+
+ tmpused = dst->used;
+ tmpfree = dst->free;
+
+ /* Inherit the lists of the source allocator: */
+ dst->used = src->used;
+ dst->free = src->free;
+
+ /* Source is now re-initialized, the source memory is 'invalid' now: */
+ src->used = tmpused;
+ src->free = tmpfree;
+ QTAILQ_INIT(src->used);
+ QTAILQ_INIT(src->free);
+ node = mlist_new(src->start, src->end - src->start);
+ QTAILQ_INSERT_HEAD(src->free, node, MLIST_ENTNAME);
+ return;
+}
--- /dev/null
+/*
+ * libqos malloc support
+ *
+ * Copyright IBM, Corp. 2012-2013
+ *
+ * Authors:
+ * Anthony Liguori <aliguori@us.ibm.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#ifndef LIBQOS_MALLOC_H
+#define LIBQOS_MALLOC_H
+
+#include "qemu/queue.h"
+#include "../libqtest.h"
+
+typedef enum {
+ ALLOC_NO_FLAGS = 0x00,
+ ALLOC_LEAK_WARN = 0x01,
+ ALLOC_LEAK_ASSERT = 0x02,
+ ALLOC_PARANOID = 0x04
+} QAllocOpts;
+
+typedef QTAILQ_HEAD(MemList, MemBlock) MemList;
+
+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);
+
+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
#include "../libqtest.h"
#include "pci.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
typedef struct QOSState QOSState;
#ifndef LIBQOS_MALLOC_PC_H
#define LIBQOS_MALLOC_PC_H
-#include "malloc.h"
+#include "libqos-malloc.h"
void pc_alloc_init(QGuestAllocator *s, QTestState *qts, QAllocOpts flags);
#ifndef LIBQOS_MALLOC_SPAPR_H
#define LIBQOS_MALLOC_SPAPR_H
-#include "malloc.h"
+#include "libqos-malloc.h"
void spapr_alloc_init(QGuestAllocator *s, QTestState *qts, QAllocOpts flags);
+++ /dev/null
-/*
- * libqos malloc support
- *
- * Copyright (c) 2014
- *
- * Author:
- * John Snow <jsnow@redhat.com>
- *
- * This work is licensed under the terms of the GNU GPL, version 2 or later.
- * See the COPYING file in the top-level directory.
- */
-
-#include "qemu/osdep.h"
-#include "malloc.h"
-#include "qemu/host-utils.h"
-
-typedef struct MemBlock {
- QTAILQ_ENTRY(MemBlock) MLIST_ENTNAME;
- uint64_t size;
- uint64_t addr;
-} MemBlock;
-
-#define DEFAULT_PAGE_SIZE 4096
-
-static void mlist_delete(MemList *list, MemBlock *node)
-{
- g_assert(list && node);
- QTAILQ_REMOVE(list, node, MLIST_ENTNAME);
- g_free(node);
-}
-
-static MemBlock *mlist_find_key(MemList *head, uint64_t addr)
-{
- MemBlock *node;
- QTAILQ_FOREACH(node, head, MLIST_ENTNAME) {
- if (node->addr == addr) {
- return node;
- }
- }
- return NULL;
-}
-
-static MemBlock *mlist_find_space(MemList *head, uint64_t size)
-{
- MemBlock *node;
-
- QTAILQ_FOREACH(node, head, MLIST_ENTNAME) {
- if (node->size >= size) {
- return node;
- }
- }
- return NULL;
-}
-
-static MemBlock *mlist_sort_insert(MemList *head, MemBlock *insr)
-{
- MemBlock *node;
- g_assert(head && insr);
-
- QTAILQ_FOREACH(node, head, MLIST_ENTNAME) {
- if (insr->addr < node->addr) {
- QTAILQ_INSERT_BEFORE(node, insr, MLIST_ENTNAME);
- return insr;
- }
- }
-
- QTAILQ_INSERT_TAIL(head, insr, MLIST_ENTNAME);
- return insr;
-}
-
-static inline uint64_t mlist_boundary(MemBlock *node)
-{
- return node->size + node->addr;
-}
-
-static MemBlock *mlist_join(MemList *head, MemBlock *left, MemBlock *right)
-{
- g_assert(head && left && right);
-
- left->size += right->size;
- mlist_delete(head, right);
- return left;
-}
-
-static void mlist_coalesce(MemList *head, MemBlock *node)
-{
- g_assert(node);
- MemBlock *left;
- MemBlock *right;
- char merge;
-
- do {
- merge = 0;
- left = QTAILQ_PREV(node, MLIST_ENTNAME);
- right = QTAILQ_NEXT(node, MLIST_ENTNAME);
-
- /* clowns to the left of me */
- if (left && mlist_boundary(left) == node->addr) {
- node = mlist_join(head, left, node);
- merge = 1;
- }
-
- /* jokers to the right */
- if (right && mlist_boundary(node) == right->addr) {
- node = mlist_join(head, node, right);
- merge = 1;
- }
-
- } while (merge);
-}
-
-static MemBlock *mlist_new(uint64_t addr, uint64_t size)
-{
- MemBlock *block;
-
- if (!size) {
- return NULL;
- }
- block = g_new0(MemBlock, 1);
-
- block->addr = addr;
- block->size = size;
-
- return block;
-}
-
-static uint64_t mlist_fulfill(QGuestAllocator *s, MemBlock *freenode,
- uint64_t size)
-{
- uint64_t addr;
- MemBlock *usednode;
-
- g_assert(freenode);
- g_assert_cmpint(freenode->size, >=, size);
-
- addr = freenode->addr;
- if (freenode->size == size) {
- /* re-use this freenode as our used node */
- QTAILQ_REMOVE(s->free, freenode, MLIST_ENTNAME);
- usednode = freenode;
- } else {
- /* adjust the free node and create a new used node */
- freenode->addr += size;
- freenode->size -= size;
- usednode = mlist_new(addr, size);
- }
-
- mlist_sort_insert(s->used, usednode);
- return addr;
-}
-
-/* To assert the correctness of the list.
- * Used only if ALLOC_PARANOID is set. */
-static void mlist_check(QGuestAllocator *s)
-{
- MemBlock *node;
- uint64_t addr = s->start > 0 ? s->start - 1 : 0;
- uint64_t next = s->start;
-
- QTAILQ_FOREACH(node, s->free, MLIST_ENTNAME) {
- g_assert_cmpint(node->addr, >, addr);
- g_assert_cmpint(node->addr, >=, next);
- addr = node->addr;
- next = node->addr + node->size;
- }
-
- addr = s->start > 0 ? s->start - 1 : 0;
- next = s->start;
- QTAILQ_FOREACH(node, s->used, MLIST_ENTNAME) {
- g_assert_cmpint(node->addr, >, addr);
- g_assert_cmpint(node->addr, >=, next);
- addr = node->addr;
- next = node->addr + node->size;
- }
-}
-
-static uint64_t mlist_alloc(QGuestAllocator *s, uint64_t size)
-{
- MemBlock *node;
-
- node = mlist_find_space(s->free, size);
- if (!node) {
- fprintf(stderr, "Out of guest memory.\n");
- g_assert_not_reached();
- }
- return mlist_fulfill(s, node, size);
-}
-
-static void mlist_free(QGuestAllocator *s, uint64_t addr)
-{
- MemBlock *node;
-
- if (addr == 0) {
- return;
- }
-
- node = mlist_find_key(s->used, addr);
- if (!node) {
- fprintf(stderr, "Error: no record found for an allocation at "
- "0x%016" PRIx64 ".\n",
- addr);
- g_assert_not_reached();
- }
-
- /* Rip it out of the used list and re-insert back into the free list. */
- QTAILQ_REMOVE(s->used, node, MLIST_ENTNAME);
- mlist_sort_insert(s->free, node);
- mlist_coalesce(s->free, node);
-}
-
-/*
- * Mostly for valgrind happiness, but it does offer
- * a chokepoint for debugging guest memory leaks, too.
- */
-void alloc_destroy(QGuestAllocator *allocator)
-{
- MemBlock *node;
- MemBlock *tmp;
- QAllocOpts mask;
-
- /* Check for guest leaks, and destroy the list. */
- QTAILQ_FOREACH_SAFE(node, allocator->used, MLIST_ENTNAME, tmp) {
- if (allocator->opts & (ALLOC_LEAK_WARN | ALLOC_LEAK_ASSERT)) {
- fprintf(stderr, "guest malloc leak @ 0x%016" PRIx64 "; "
- "size 0x%016" PRIx64 ".\n",
- node->addr, node->size);
- }
- if (allocator->opts & (ALLOC_LEAK_ASSERT)) {
- g_assert_not_reached();
- }
- g_free(node);
- }
-
- /* If we have previously asserted that there are no leaks, then there
- * should be only one node here with a specific address and size. */
- mask = ALLOC_LEAK_ASSERT | ALLOC_PARANOID;
- QTAILQ_FOREACH_SAFE(node, allocator->free, MLIST_ENTNAME, tmp) {
- if ((allocator->opts & mask) == mask) {
- if ((node->addr != allocator->start) ||
- (node->size != allocator->end - allocator->start)) {
- fprintf(stderr, "Free list is corrupted.\n");
- g_assert_not_reached();
- }
- }
-
- g_free(node);
- }
-
- g_free(allocator->used);
- g_free(allocator->free);
-}
-
-uint64_t guest_alloc(QGuestAllocator *allocator, size_t size)
-{
- uint64_t rsize = size;
- uint64_t naddr;
-
- if (!size) {
- return 0;
- }
-
- rsize += (allocator->page_size - 1);
- rsize &= -allocator->page_size;
- g_assert_cmpint((allocator->start + rsize), <=, allocator->end);
- g_assert_cmpint(rsize, >=, size);
-
- naddr = mlist_alloc(allocator, rsize);
- if (allocator->opts & ALLOC_PARANOID) {
- mlist_check(allocator);
- }
-
- return naddr;
-}
-
-void guest_free(QGuestAllocator *allocator, uint64_t addr)
-{
- if (!addr) {
- return;
- }
- mlist_free(allocator, addr);
- if (allocator->opts & ALLOC_PARANOID) {
- mlist_check(allocator);
- }
-}
-
-void alloc_init(QGuestAllocator *s, QAllocOpts opts,
- uint64_t start, uint64_t end,
- size_t page_size)
-{
- MemBlock *node;
-
- s->opts = opts;
- s->start = start;
- s->end = end;
-
- s->used = g_new(MemList, 1);
- s->free = g_new(MemList, 1);
- QTAILQ_INIT(s->used);
- QTAILQ_INIT(s->free);
-
- node = mlist_new(s->start, s->end - s->start);
- QTAILQ_INSERT_HEAD(s->free, node, MLIST_ENTNAME);
-
- s->page_size = page_size;
-}
-
-void alloc_set_flags(QGuestAllocator *allocator, QAllocOpts opts)
-{
- allocator->opts |= opts;
-}
-
-void migrate_allocator(QGuestAllocator *src,
- QGuestAllocator *dst)
-{
- MemBlock *node, *tmp;
- MemList *tmpused, *tmpfree;
-
- /* The general memory layout should be equivalent,
- * though opts can differ. */
- g_assert_cmphex(src->start, ==, dst->start);
- g_assert_cmphex(src->end, ==, dst->end);
-
- /* Destroy (silently, regardless of options) the dest-list: */
- QTAILQ_FOREACH_SAFE(node, dst->used, MLIST_ENTNAME, tmp) {
- g_free(node);
- }
- QTAILQ_FOREACH_SAFE(node, dst->free, MLIST_ENTNAME, tmp) {
- g_free(node);
- }
-
- tmpused = dst->used;
- tmpfree = dst->free;
-
- /* Inherit the lists of the source allocator: */
- dst->used = src->used;
- dst->free = src->free;
-
- /* Source is now re-initialized, the source memory is 'invalid' now: */
- src->used = tmpused;
- src->free = tmpfree;
- QTAILQ_INIT(src->used);
- QTAILQ_INIT(src->free);
- node = mlist_new(src->start, src->end - src->start);
- QTAILQ_INSERT_HEAD(src->free, node, MLIST_ENTNAME);
- return;
-}
+++ /dev/null
-/*
- * libqos malloc support
- *
- * Copyright IBM, Corp. 2012-2013
- *
- * Authors:
- * Anthony Liguori <aliguori@us.ibm.com>
- *
- * This work is licensed under the terms of the GNU GPL, version 2 or later.
- * See the COPYING file in the top-level directory.
- */
-
-#ifndef LIBQOS_MALLOC_H
-#define LIBQOS_MALLOC_H
-
-#include "qemu/queue.h"
-#include "../libqtest.h"
-
-typedef enum {
- ALLOC_NO_FLAGS = 0x00,
- ALLOC_LEAK_WARN = 0x01,
- ALLOC_LEAK_ASSERT = 0x02,
- ALLOC_PARANOID = 0x04
-} QAllocOpts;
-
-typedef QTAILQ_HEAD(MemList, MemBlock) MemList;
-
-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);
-
-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
'qos_external.c',
'pci.c',
'fw_cfg.c',
- 'malloc.c',
+ 'libqos-malloc.c',
'libqos.c',
'sdhci-cmd.c',
#define LIBQOS_PCI_PC_H
#include "pci.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "qgraph.h"
typedef struct QPCIBusPC {
#ifndef LIBQOS_PCI_SPAPR_H
#define LIBQOS_PCI_SPAPR_H
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "pci.h"
#include "qgraph.h"
#include <gmodule.h>
#include "qemu/module.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
/* maximum path length */
#define QOS_PATH_MAX_ELEMENT_SIZE 50
#include "qapi/qmp/qstring.h"
#include "qemu/module.h"
#include "qapi/qmp/qlist.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "qgraph.h"
#include "qgraph_internal.h"
#include "qos_external.h"
#include "qgraph.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "qapi/qapi-types-machine.h"
#include "qapi/qapi-types-qom.h"
#ifndef LIBQOS_RTAS_H
#define LIBQOS_RTAS_H
-#include "malloc.h"
+#include "libqos-malloc.h"
int qrtas_get_time_of_day(QTestState *qts, QGuestAllocator *alloc,
struct tm *tm, uint32_t *ns);
#include "qemu/module.h"
#include "virtio.h"
#include "virtio-mmio.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "qgraph.h"
#include "standard-headers/linux/virtio_ring.h"
#include "virtio-pci.h"
#include "pci.h"
#include "pci-pc.h"
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "malloc-pc.h"
#include "qgraph.h"
#include "standard-headers/linux/virtio_ring.h"
#ifndef LIBQOS_VIRTIO_H
#define LIBQOS_VIRTIO_H
-#include "malloc.h"
+#include "libqos-malloc.h"
#include "standard-headers/linux/virtio_ring.h"
#define QVIRTIO_F_BAD_FEATURE 0x40000000ull
#include "qapi/qobject-input-visitor.h"
#include "qapi/qapi-visit-machine.h"
#include "qapi/qapi-visit-qom.h"
-#include "libqos/malloc.h"
+#include "libqos/libqos-malloc.h"
#include "libqos/qgraph.h"
#include "libqos/qgraph_internal.h"
#include "libqos/qos_external.h"
projects / qemu.git / commitdiff