Module: xenomai-3
Branch: master
Commit: 65f16f4a3f0d4de3be221bea6b4545b2b4d74321
URL:
http://git.xenomai.org/?p=xenomai-3.git;a=commit;h=65f16f4a3f0d4de3be221bea6b4545b2b4d74321
Author: Philippe Gerum <r...@xenomai.org>
Date: Wed Aug 12 18:27:22 2015 +0200
copperplate/heapobj-pshared: fix and sanitize extent management
---
lib/copperplate/heapobj-pshared.c | 278 +++++++++++++++++++++----------------
lib/copperplate/internal.h | 3 -
2 files changed, 159 insertions(+), 122 deletions(-)
diff --git a/lib/copperplate/heapobj-pshared.c
b/lib/copperplate/heapobj-pshared.c
index 5fe899a..0df08c3 100644
--- a/lib/copperplate/heapobj-pshared.c
+++ b/lib/copperplate/heapobj-pshared.c
@@ -57,17 +57,17 @@ enum {
page_list =2
};
-struct page_map {
+struct page_entry {
unsigned int type : 8; /* free, cont, list or log2 */
unsigned int bcount : 24; /* Number of active blocks. */
};
struct shared_extent {
struct holder link;
- memoff_t membase; /* Base address of the page array */
- memoff_t memlim; /* Memory limit of page array */
- memoff_t freelist; /* Head of the free page list */
- struct page_map pagemap[1]; /* Start of page map */
+ memoff_t membase; /* Base offset of page array */
+ memoff_t memlim; /* Offset limit of page array */
+ memoff_t freelist; /* Head of free page list */
+ struct page_entry pagemap[1]; /* Start of page map */
};
/*
@@ -75,7 +75,7 @@ struct shared_extent {
* additional session-wide information.
*/
struct session_heap {
- struct shared_heap base;
+ struct shared_heap heap;
int cpid;
memoff_t maplen;
struct hash_table catalog;
@@ -91,6 +91,12 @@ struct session_heap {
*/
void *__main_heap;
#define main_heap (*(struct session_heap *)__main_heap)
+/*
+ * Base address for offset-based addressing, which is the start of
+ * the session heap since all memory objects are allocated from it,
+ * including other (sub-)heaps.
+ */
+#define main_base __main_heap
/* A table of shared clusters for the session. */
struct hash_table *__main_catalog;
@@ -100,10 +106,10 @@ struct sysgroup *__main_sysgroup;
static struct heapobj main_pool;
-#define __shoff(h, p) ((caddr_t)(p) - (caddr_t)(h))
-#define __shoff_check(h, p) ((p) ? __shoff(h, p) : 0)
-#define __shref(h, o) ((void *)((caddr_t)(h) + (o)))
-#define __shref_check(h, o) ((o) ? __shref(h, o) : NULL)
+#define __shoff(b, p) ((caddr_t)(p) - (caddr_t)(b))
+#define __shoff_check(b, p) ((p) ? __shoff(b, p) : 0)
+#define __shref(b, o) ((void *)((caddr_t)(b) + (o)))
+#define __shref_check(b, o) ((o) ? __shref(b, o) : NULL)
static inline size_t __align_to(size_t size, size_t al)
{
@@ -111,33 +117,39 @@ static inline size_t __align_to(size_t size, size_t al)
return ((size+al-1)&(~(al-1)));
}
-static inline size_t internal_overhead(size_t hsize)
+static inline size_t get_pagemap_size(size_t h)
{
- /* o = (h - o) * m / p + e
- o * p = (h - o) * m + e * p
- o * (p + m) = h * m + e * p
- o = (h * m + e *p) / (p + m)
- */
- return __align_to((sizeof(struct shared_extent) * HOBJ_PAGE_SIZE
- + sizeof(struct page_map) * hsize)
- / (HOBJ_PAGE_SIZE + sizeof(struct page_map)),
HOBJ_PAGE_SIZE);
+ /*
+ * Return the size of the meta data required to map 'h' bytes
+ * of user memory in pages of HOBJ_PAGE_SIZE bytes. The meta
+ * data includes the length of the extent descriptor, plus the
+ * length of the page mapping array. 'h' must be a multiple of
+ * HOBJ_PAGE_SIZE on entry.
+ */
+ assert((h & ~HOBJ_PAGE_MASK) == 0);
+ return __align_to((h >> HOBJ_PAGE_SHIFT) * sizeof(struct page_entry)
+ + sizeof(struct shared_extent), HOBJ_PAGE_SIZE);
}
-static void init_extent(struct shared_heap *heap, struct shared_extent *extent)
+static void init_extent(void *base, struct shared_extent *extent)
{
caddr_t freepage;
int n, lastpgnum;
- __holder_init_nocheck(heap, &extent->link);
+ __holder_init_nocheck(base, &extent->link);
- /* The initial extent starts right after the header. */
- extent->membase = __shoff(heap, extent) + heap->hdrsize;
- lastpgnum = heap->npages - 1;
+ lastpgnum = ((extent->memlim - extent->membase) >> HOBJ_PAGE_SHIFT) - 1;
+ /*
+ * An extent must contain at least two addressable pages to
+ * cope with allocation sizes between PAGESIZE and 2 *
+ * PAGESIZE.
+ */
+ assert(lastpgnum >= 1);
/* Mark each page as free in the page map. */
- for (n = 0, freepage = __shref(heap, extent->membase);
+ for (n = 0, freepage = __shref(base, extent->membase);
n < lastpgnum; n++, freepage += HOBJ_PAGE_SIZE) {
- *((memoff_t *)freepage) = __shoff(heap, freepage) +
HOBJ_PAGE_SIZE;
+ *((memoff_t *)freepage) = __shoff(base, freepage) +
HOBJ_PAGE_SIZE;
extent->pagemap[n].type = page_free;
extent->pagemap[n].bcount = 0;
}
@@ -145,13 +157,13 @@ static void init_extent(struct shared_heap *heap, struct
shared_extent *extent)
*((memoff_t *)freepage) = 0;
extent->pagemap[lastpgnum].type = page_free;
extent->pagemap[lastpgnum].bcount = 0;
- extent->memlim = __shoff(heap, freepage) + HOBJ_PAGE_SIZE;
/* The first page starts the free list of a new extent. */
extent->freelist = extent->membase;
}
-static int init_heap(struct shared_heap *heap, const char *name,
+static int init_heap(struct shared_heap *heap, void *base,
+ const char *name,
void *mem, size_t size)
{
struct shared_extent *extent;
@@ -159,21 +171,11 @@ static int init_heap(struct shared_heap *heap, const char
*name,
int ret;
namecpy(heap->name, name);
- heap->extentsize = size;
- heap->hdrsize = internal_overhead(size);
- heap->npages = (size - heap->hdrsize) >> HOBJ_PAGE_SHIFT;
-
- /*
- * An extent must contain at least two addressable pages to
- * cope with allocation sizes between PAGESIZE and 2 *
- * PAGESIZE.
- */
- assert(heap->npages >= 2);
heap->ubytes = 0;
- heap->total = heap->npages * HOBJ_PAGE_SIZE;
+ heap->total = size;
heap->maxcont = heap->total;
- __list_init_nocheck(heap, &heap->extents);
+ __list_init_nocheck(base, &heap->extents);
pthread_mutexattr_init(&mattr);
pthread_mutexattr_settype(&mattr, mutex_type_attribute);
@@ -185,19 +187,45 @@ static int init_heap(struct shared_heap *heap, const char
*name,
return ret;
memset(heap->buckets, 0, sizeof(heap->buckets));
+
+ /*
+ * The heap descriptor is followed in memory by the initial
+ * extent covering the 'size' bytes of user memory, which is a
+ * multiple of HOBJ_PAGE_SIZE. The extent starts with a
+ * descriptor, which is in turn followed by a page mapping
+ * array. The length of the page mapping array depends on the
+ * size of the user memory to map.
+ *
+ * +-------------------+
+ * | heap descriptor |
+ * +-------------------+
+ * | extent descriptor |
+ * /...................\
+ * \....(page map)...../
+ * /...................\
+ * +-------------------+ <= extent->membase
+ * | |
+ * | (user memory) |
+ * | |
+ * +-------------------+
+ * <= extent->memlim
+ */
extent = mem;
- init_extent(heap, extent);
- __list_append(heap, &extent->link, &heap->extents);
+ extent->membase = __shoff(base, mem) + get_pagemap_size(size);
+ extent->memlim = extent->membase + size;
+ init_extent(base, extent);
+ __list_append(base, &extent->link, &heap->extents);
return 0;
}
-static int init_main_heap(struct session_heap *m_heap, void *mem, size_t size)
+static int init_main_heap(struct session_heap *m_heap,
+ size_t size)
{
pthread_mutexattr_t mattr;
int ret;
- ret = init_heap(&m_heap->base, "main", mem, size);
+ ret = init_heap(&m_heap->heap, m_heap, "main", m_heap + 1, size);
if (ret)
return __bt(ret);
@@ -226,9 +254,10 @@ static caddr_t get_free_range(struct shared_heap *heap,
size_t bsize, int log2si
caddr_t block, eblock, freepage, lastpage, headpage, freehead = NULL;
struct shared_extent *extent;
size_t pnum, pcont, fcont;
+ void *base = main_base;
- __list_for_each_entry(heap, extent, &heap->extents, link) {
- freepage = __shref_check(heap, extent->freelist);
+ __list_for_each_entry(base, extent, &heap->extents, link) {
+ freepage = __shref_check(base, extent->freelist);
while (freepage) {
headpage = freepage;
fcont = 0;
@@ -239,7 +268,7 @@ static caddr_t get_free_range(struct shared_heap *heap,
size_t bsize, int log2si
*/
do {
lastpage = freepage;
- freepage = __shref_check(heap, *((memoff_t
*)freepage));
+ freepage = __shref_check(base, *((memoff_t
*)freepage));
fcont += HOBJ_PAGE_SIZE;
} while (freepage == lastpage + HOBJ_PAGE_SIZE
&& fcont < bsize);
@@ -249,7 +278,7 @@ static caddr_t get_free_range(struct shared_heap *heap,
size_t bsize, int log2si
* page list, then proceed to the next
* step.
*/
- if (__shoff(heap, headpage) == extent->freelist)
+ if (__shoff(base, headpage) == extent->freelist)
extent->freelist = *((memoff_t
*)lastpage);
else
*((memoff_t *)freehead) = *((memoff_t
*)lastpage);
@@ -278,13 +307,13 @@ splitpage:
for (block = headpage, eblock =
headpage + HOBJ_PAGE_SIZE - bsize; block < eblock;
block += bsize)
- *((memoff_t *)block) = __shoff(heap, block) + bsize;
+ *((memoff_t *)block) = __shoff(base, block) + bsize;
*((memoff_t *)eblock) = 0;
} else
*((memoff_t *)headpage) = 0;
- pnum = (__shoff(heap, headpage) - extent->membase) >> HOBJ_PAGE_SHIFT;
+ pnum = (__shoff(base, headpage) - extent->membase) >> HOBJ_PAGE_SHIFT;
/*
* Update the page map. If log2size is non-zero (i.e. bsize
@@ -296,7 +325,7 @@ splitpage:
* In any case, the following pages slots are marked as
* 'continued' (page_cont).
*/
- extent->pagemap[pnum].type = log2size ? : page_list;
+ extent->pagemap[pnum].type = log2size ?: page_list;
extent->pagemap[pnum].bcount = 1;
for (pcont = bsize >> HOBJ_PAGE_SHIFT; pcont > 1; pcont--) {
@@ -323,6 +352,7 @@ align_alloc_size(size_t size)
static void *alloc_block(struct shared_heap *heap, size_t size)
{
struct shared_extent *extent;
+ void *base = main_base;
int log2size, ilog;
size_t pnum, bsize;
caddr_t block;
@@ -351,7 +381,7 @@ static void *alloc_block(struct shared_heap *heap, size_t
size)
write_lock_nocancel(&heap->lock);
- block = __shref_check(heap, heap->buckets[ilog].freelist);
+ block = __shref_check(base, heap->buckets[ilog].freelist);
if (block == NULL) {
block = get_free_range(heap, bsize, log2size);
if (block == NULL)
@@ -363,14 +393,14 @@ static void *alloc_block(struct shared_heap *heap, size_t
size)
--heap->buckets[ilog].fcount;
/* Search for the source extent of block. */
- __list_for_each_entry(heap, extent, &heap->extents,
link) {
- if (__shoff(heap, block) >= extent->membase &&
- __shoff(heap, block) < extent->memlim)
+ __list_for_each_entry(base, extent, &heap->extents,
link) {
+ if (__shoff(base, block) >= extent->membase &&
+ __shoff(base, block) < extent->memlim)
goto found;
}
assert(0);
found:
- pnum = (__shoff(heap, block) - extent->membase) >>
HOBJ_PAGE_SHIFT;
+ pnum = (__shoff(base, block) - extent->membase) >>
HOBJ_PAGE_SHIFT;
++extent->pagemap[pnum].bcount;
}
@@ -395,10 +425,11 @@ done:
static int free_block(struct shared_heap *heap, void *block)
{
+ int log2size, ret = 0, nblocks, xpage, ilog, pagenr, maxpages;
caddr_t freepage, lastpage, nextpage, tailpage, freeptr;
- int log2size, ret = 0, nblocks, xpage, ilog;
- size_t pnum, pcont, boffset, bsize, npages;
+ size_t pnum, pcont, boffset, bsize;
struct shared_extent *extent;
+ void *base = main_base;
memoff_t *tailptr;
write_lock_nocancel(&heap->lock);
@@ -407,9 +438,9 @@ static int free_block(struct shared_heap *heap, void *block)
* Find the extent from which the returned block is
* originating from.
*/
- __list_for_each_entry(heap, extent, &heap->extents, link) {
- if (__shoff(heap, block) >= extent->membase &&
- __shoff(heap, block) < extent->memlim)
+ __list_for_each_entry(base, extent, &heap->extents, link) {
+ if (__shoff(base, block) >= extent->membase &&
+ __shoff(base, block) < extent->memlim)
goto found;
}
@@ -417,8 +448,8 @@ static int free_block(struct shared_heap *heap, void *block)
goto out;
found:
/* Compute the heading page number in the page map. */
- pnum = (__shoff(heap, block) - extent->membase) >> HOBJ_PAGE_SHIFT;
- boffset = (__shoff(heap, block) -
+ pnum = (__shoff(base, block) - extent->membase) >> HOBJ_PAGE_SHIFT;
+ boffset = (__shoff(base, block) -
(extent->membase + (pnum << HOBJ_PAGE_SHIFT)));
switch (extent->pagemap[pnum].type) {
@@ -428,37 +459,38 @@ found:
goto out;
case page_list:
- npages = 1;
- while (npages < heap->npages &&
- extent->pagemap[pnum + npages].type == page_cont)
- npages++;
- bsize = npages * HOBJ_PAGE_SIZE;
+ pagenr = 1;
+ maxpages = (extent->memlim - extent->membase) >>
HOBJ_PAGE_SHIFT;
+ while (pagenr < maxpages &&
+ extent->pagemap[pnum + pagenr].type == page_cont)
+ pagenr++;
+ bsize = pagenr * HOBJ_PAGE_SIZE;
free_page_list:
/* Link all freed pages in a single sub-list. */
for (freepage = (caddr_t)block,
tailpage = (caddr_t)block + bsize - HOBJ_PAGE_SIZE;
freepage < tailpage; freepage += HOBJ_PAGE_SIZE)
- *((memoff_t *)freepage) = __shoff(heap, freepage) +
HOBJ_PAGE_SIZE;
+ *((memoff_t *)freepage) = __shoff(base, freepage) +
HOBJ_PAGE_SIZE;
free_pages:
/* Mark the released pages as free in the extent's page map. */
- for (pcont = 0; pcont < npages; pcont++)
+ for (pcont = 0; pcont < pagenr; pcont++)
extent->pagemap[pnum + pcont].type = page_free;
/*
* Return the sub-list to the free page list, keeping
* an increasing address order to favor coalescence.
*/
- for (nextpage = __shref_check(heap, extent->freelist), lastpage
= NULL;
+ for (nextpage = __shref_check(base, extent->freelist), lastpage
= NULL;
nextpage && nextpage < (caddr_t)block;
- lastpage = nextpage, nextpage = __shref_check(heap,
*((memoff_t *)nextpage)))
+ lastpage = nextpage, nextpage = __shref_check(base,
*((memoff_t *)nextpage)))
; /* Loop */
- *((memoff_t *)tailpage) = __shoff_check(heap, nextpage);
+ *((memoff_t *)tailpage) = __shoff_check(base, nextpage);
if (lastpage)
- *((memoff_t *)lastpage) = __shoff(heap, block);
+ *((memoff_t *)lastpage) = __shoff(base, block);
else
- extent->freelist = __shoff(heap, block);
+ extent->freelist = __shoff(base, block);
break;
default:
@@ -479,13 +511,13 @@ found:
if (--extent->pagemap[pnum].bcount > 0) {
/* Return the block to the bucketed memory space. */
*((memoff_t *)block) = heap->buckets[ilog].freelist;
- heap->buckets[ilog].freelist = __shoff(heap, block);
+ heap->buckets[ilog].freelist = __shoff(base, block);
++heap->buckets[ilog].fcount;
break;
}
- npages = bsize >> HOBJ_PAGE_SHIFT;
- if (npages > 1)
+ pagenr = bsize >> HOBJ_PAGE_SHIFT;
+ if (pagenr > 1)
/*
* The simplest case: we only have a single
* block to deal with, which spans multiple
@@ -495,7 +527,7 @@ found:
*/
goto free_page_list;
- freepage = __shref(heap, extent->membase) + (pnum <<
HOBJ_PAGE_SHIFT);
+ freepage = __shref(base, extent->membase) + (pnum <<
HOBJ_PAGE_SHIFT);
block = freepage;
tailpage = freepage;
nextpage = freepage + HOBJ_PAGE_SIZE;
@@ -522,12 +554,12 @@ found:
* comes first.
*/
for (tailptr = &heap->buckets[ilog].freelist,
- freeptr = __shref_check(heap, *tailptr), xpage = 1;
+ freeptr = __shref_check(base, *tailptr), xpage = 1;
freeptr && nblocks > 0;
- freeptr = __shref_check(heap, *((memoff_t *)freeptr))) {
+ freeptr = __shref_check(base, *((memoff_t *)freeptr))) {
if (freeptr < freepage || freeptr >= nextpage) {
if (xpage) { /* Limit random writes */
- *tailptr = __shoff(heap, freeptr);
+ *tailptr = __shoff(base, freeptr);
xpage = 0;
}
tailptr = (memoff_t *)freeptr;
@@ -536,7 +568,7 @@ found:
xpage = 1;
}
}
- *tailptr = __shoff_check(heap, freeptr);
+ *tailptr = __shoff_check(base, freeptr);
goto free_pages;
}
@@ -551,6 +583,7 @@ static size_t check_block(struct shared_heap *heap, void
*block)
{
size_t pnum, boffset, bsize, ret = 0;
struct shared_extent *extent;
+ void *base = main_base;
int ptype;
read_lock_nocancel(&heap->lock);
@@ -558,21 +591,21 @@ static size_t check_block(struct shared_heap *heap, void
*block)
/*
* Find the extent the checked block is originating from.
*/
- __list_for_each_entry(heap, extent, &heap->extents, link) {
- if (__shoff(heap, block) >= extent->membase &&
- __shoff(heap, block) < extent->memlim)
+ __list_for_each_entry(base, extent, &heap->extents, link) {
+ if (__shoff(base, block) >= extent->membase &&
+ __shoff(base, block) < extent->memlim)
goto found;
}
goto out;
found:
/* Compute the heading page number in the page map. */
- pnum = (__shoff(heap, block) - extent->membase) >> HOBJ_PAGE_SHIFT;
+ pnum = (__shoff(base, block) - extent->membase) >> HOBJ_PAGE_SHIFT;
ptype = extent->pagemap[pnum].type;
if (ptype == page_free || ptype == page_cont)
goto out;
bsize = (1 << ptype);
- boffset = (__shoff(heap, block) -
+ boffset = (__shoff(base, block) -
(extent->membase + (pnum << HOBJ_PAGE_SHIFT)));
if ((boffset & (bsize - 1)) != 0) /* Not a block start? */
goto out;
@@ -604,15 +637,15 @@ static int create_main_heap(pid_t *cnode_r)
assert(HOBJ_PAGE_SIZE > sizeof(struct shared_extent));
*cnode_r = -1;
- size += internal_overhead(size);
size = __align_to(size, HOBJ_PAGE_SIZE);
if (size > HOBJ_MAXEXTSZ)
return __bt(-EINVAL);
- if (size - sizeof(struct shared_extent) < HOBJ_PAGE_SIZE * 2)
- size += HOBJ_PAGE_SIZE * 2;
+ if (size < HOBJ_PAGE_SIZE * 2)
+ size = HOBJ_PAGE_SIZE * 2;
len = size + sizeof(*m_heap);
+ len += get_pagemap_size(size);
/*
* Bind to (and optionally create) the main session's heap:
@@ -652,7 +685,7 @@ static int create_main_heap(pid_t *cnode_r)
/* CAUTION: __moff() depends on __main_heap. */
__main_heap = m_heap;
__main_sysgroup = &m_heap->sysgroup;
- hobj->pool_ref = __moff(&m_heap->base);
+ hobj->pool_ref = __moff(&m_heap->heap);
goto done;
}
*cnode_r = m_heap->cpid;
@@ -677,8 +710,8 @@ init:
m_heap->maplen = len;
/* CAUTION: init_main_heap() depends on hobj->pool_ref. */
- hobj->pool_ref = __moff(&m_heap->base);
- ret = init_main_heap(m_heap, (caddr_t)m_heap + sizeof(*m_heap), size);
+ hobj->pool_ref = __moff(&m_heap->heap);
+ ret = init_main_heap(m_heap, size);
if (ret) {
errno = -ret;
goto unmap_fail;
@@ -687,11 +720,11 @@ init:
/* We need these globals set up before updating a sysgroup. */
__main_heap = m_heap;
__main_sysgroup = &m_heap->sysgroup;
- sysgroup_add(heap, &m_heap->base.memspec);
+ sysgroup_add(heap, &m_heap->heap.memspec);
done:
flock(fd, LOCK_UN);
__STD(close(fd));
- hobj->size = m_heap->base.total;
+ hobj->size = m_heap->heap.total;
__main_catalog = &m_heap->catalog;
return 0;
@@ -753,8 +786,8 @@ static int bind_main_heap(const char *session)
return -ENOENT;
}
- hobj->pool_ref = __moff(&m_heap->base);
- hobj->size = m_heap->base.total;
+ hobj->pool_ref = __moff(&m_heap->heap);
+ hobj->size = m_heap->heap.total;
__main_heap = m_heap;
__main_catalog = &m_heap->catalog;
__main_sysgroup = &m_heap->sysgroup;
@@ -781,7 +814,7 @@ int pshared_check(void *__heap, void *__addr)
* memory range.
*/
if (__moff(heap) == main_pool.pool_ref) {
- m_heap = container_of(heap, struct session_heap, base);
+ m_heap = container_of(heap, struct session_heap, heap);
return __addr >= (void *)m_heap &&
__addr < (void *)m_heap + m_heap->maplen;
}
@@ -800,9 +833,9 @@ int pshared_check(void *__heap, void *__addr)
*/
assert(!list_empty(&heap->extents));
- __list_for_each_entry(heap, extent, &heap->extents, link) {
- if (__shoff(heap, __addr) >= extent->membase &&
- __shoff(heap, __addr) < extent->memlim)
+ __list_for_each_entry(main_base, extent, &heap->extents, link) {
+ if (__shoff(main_base, __addr) >= extent->membase &&
+ __shoff(main_base, __addr) < extent->memlim)
return 1;
}
@@ -813,23 +846,24 @@ int heapobj_init(struct heapobj *hobj, const char *name,
size_t size)
{
const char *session = __copperplate_setup_data.session_label;
struct shared_heap *heap;
+ size_t len;
- size += internal_overhead(size);
size = __align_to(size, HOBJ_PAGE_SIZE);
if (size > HOBJ_MAXEXTSZ)
return __bt(-EINVAL);
- if (size - sizeof(struct shared_extent) < HOBJ_PAGE_SIZE * 2) {
- size += HOBJ_PAGE_SIZE * 2;
- size = __align_to(size, HOBJ_PAGE_SIZE);
- }
+ if (size < HOBJ_PAGE_SIZE * 2)
+ size = HOBJ_PAGE_SIZE * 2;
+
+ len = size + sizeof(*heap);
+ len += get_pagemap_size(size);
/*
* Create a heap nested in the main shared heap to hold data
* we can share among processes which belong to the same
* session.
*/
- heap = alloc_block(&main_heap.base, size + sizeof(*heap));
+ heap = alloc_block(&main_heap.heap, len);
if (heap == NULL) {
warning("%s() failed for %Zu bytes, raise --mem-pool-size?",
__func__);
@@ -837,11 +871,13 @@ int heapobj_init(struct heapobj *hobj, const char *name,
size_t size)
}
if (name)
- snprintf(hobj->name, sizeof(hobj->name), "%s.%s", session,
name);
+ snprintf(hobj->name, sizeof(hobj->name), "%s.%s",
+ session, name);
else
- snprintf(hobj->name, sizeof(hobj->name), "%s.%p", session,
hobj);
+ snprintf(hobj->name, sizeof(hobj->name), "%s.%p",
+ session, hobj);
- init_heap(heap, hobj->name, (caddr_t)heap + sizeof(*heap), size);
+ init_heap(heap, main_base, hobj->name, heap + 1, size);
hobj->pool_ref = __moff(heap);
hobj->size = heap->total;
sysgroup_add(heap, &heap->memspec);
@@ -864,7 +900,7 @@ void heapobj_destroy(struct heapobj *hobj)
if (hobj != &main_pool) {
__RT(pthread_mutex_destroy(&heap->lock));
sysgroup_remove(heap, &heap->memspec);
- free_block(&main_heap.base, heap);
+ free_block(&main_heap.heap, heap);
return;
}
@@ -884,18 +920,22 @@ int heapobj_extend(struct heapobj *hobj, size_t size,
void *unused)
{
struct shared_heap *heap = __mptr(hobj->pool_ref);
struct shared_extent *extent;
+ size_t metasz;
int state;
if (hobj == &main_pool) /* Can't extend the main pool. */
return __bt(-EINVAL);
- if (size <= HOBJ_PAGE_SIZE * 2)
- return __bt(-EINVAL);
+ size = __align_to(size, HOBJ_PAGE_SIZE);
+ metasz = get_pagemap_size(size);
+ extent = alloc_block(&main_heap.heap, size + metasz);
+ if (extent == NULL)
+ return __bt(-ENOMEM);
- size = align_alloc_size(size);
+ extent->membase = __shoff(main_base, extent) + metasz;
+ extent->memlim = extent->membase + size;
+ init_extent(main_base, extent);
write_lock_safe(&heap->lock, state);
- extent = alloc_block(&main_heap.base, size + sizeof(*extent));
- init_extent(heap, extent);
__list_append(heap, &extent->link, &heap->extents);
if (size > heap->maxcont)
heap->maxcont = size;
@@ -929,12 +969,12 @@ size_t heapobj_inquire(struct heapobj *hobj)
void *xnmalloc(size_t size)
{
- return alloc_block(&main_heap.base, size);
+ return alloc_block(&main_heap.heap, size);
}
void xnfree(void *ptr)
{
- free_block(&main_heap.base, ptr);
+ free_block(&main_heap.heap, ptr);
}
char *xnstrdup(const char *ptr)
diff --git a/lib/copperplate/internal.h b/lib/copperplate/internal.h
index 7837fb7..5d0d41e 100644
--- a/lib/copperplate/internal.h
+++ b/lib/copperplate/internal.h
@@ -50,9 +50,6 @@ struct shared_heap {
char name[XNOBJECT_NAME_LEN];
pthread_mutex_t lock;
struct listobj extents;
- size_t extentsize;
- size_t hdrsize;
- size_t npages;
size_t ubytes;
size_t total;
size_t maxcont;
_______________________________________________
Xenomai-git mailing list
Xenomai-git@xenomai.org
http://xenomai.org/mailman/listinfo/xenomai-git
