/*
|
* Copyright (C) 2008 Philippe Gerum <rpm@xenomai.org>.
|
*
|
* This library is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU Lesser General Public
|
* License as published by the Free Software Foundation; either
|
* version 2 of the License, or (at your option) any later version.
|
*
|
* This library is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
* Lesser General Public License for more details.
|
|
* You should have received a copy of the GNU Lesser General Public
|
* License along with this library; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
*/
|
|
#include <errno.h>
|
#include <stdio.h>
|
#include <string.h>
|
#include <malloc.h>
|
#include <assert.h>
|
#include <pthread.h>
|
#include "boilerplate/lock.h"
|
#include "copperplate/heapobj.h"
|
#include "copperplate/debug.h"
|
|
#define MALLOC_MAGIC 0xabbfcddc
|
|
struct pool_header {
|
pthread_mutex_t lock;
|
size_t used;
|
};
|
|
struct block_header {
|
unsigned int magic;
|
size_t size;
|
};
|
|
int __heapobj_init_private(struct heapobj *hobj, const char *name,
|
size_t size, void *mem)
|
{
|
pthread_mutexattr_t mattr;
|
struct pool_header *ph;
|
int ret;
|
|
/*
|
* There is no local pool when working with malloc, we just
|
* use the global process arena. This should not be an issue
|
* since this mode is aimed at debugging, particularly to be
|
* used along with Valgrind.
|
*
|
* However, we maintain a control header to track the amount
|
* of memory currently consumed in each heap.
|
*/
|
ph = malloc(sizeof(*ph));
|
if (ph == NULL)
|
return __bt(-ENOMEM);
|
|
pthread_mutexattr_init(&mattr);
|
pthread_mutexattr_settype(&mattr, mutex_type_attribute);
|
pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_INHERIT);
|
pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_PRIVATE);
|
ret = __bt(-__RT(pthread_mutex_init(&ph->lock, &mattr)));
|
pthread_mutexattr_destroy(&mattr);
|
if (ret) {
|
free(ph);
|
return ret;
|
}
|
|
ph->used = 0;
|
|
hobj->pool = ph;
|
hobj->size = size;
|
if (name)
|
snprintf(hobj->name, sizeof(hobj->name), "%s", name);
|
else
|
snprintf(hobj->name, sizeof(hobj->name), "%p", hobj);
|
|
return 0;
|
}
|
|
int heapobj_init_array_private(struct heapobj *hobj, const char *name,
|
size_t size, int elems)
|
{
|
if (size == 0 || elems <= 0)
|
return __bt(-EINVAL);
|
|
return __bt(__heapobj_init_private(hobj, name, size * elems, NULL));
|
}
|
|
void pvheapobj_destroy(struct heapobj *hobj)
|
{
|
struct pool_header *ph = hobj->pool;
|
|
__RT(pthread_mutex_destroy(&ph->lock));
|
free(ph);
|
}
|
|
int pvheapobj_extend(struct heapobj *hobj, size_t size, void *mem)
|
{
|
struct pool_header *ph = hobj->pool;
|
|
write_lock_nocancel(&ph->lock);
|
hobj->size += size;
|
write_unlock(&ph->lock);
|
|
return 0;
|
}
|
|
void *pvheapobj_alloc(struct heapobj *hobj, size_t size)
|
{
|
struct pool_header *ph = hobj->pool;
|
struct block_header *bh;
|
void *ptr;
|
|
write_lock(&ph->lock);
|
|
ph->used += size;
|
/* Enforce hard limit. */
|
if (ph->used > hobj->size)
|
goto fail;
|
|
write_unlock(&ph->lock);
|
|
/* malloc(3) is not a cancellation point. */
|
ptr = malloc(size + sizeof(*bh));
|
if (ptr == NULL) {
|
write_lock(&ph->lock);
|
goto fail;
|
}
|
|
bh = ptr;
|
bh->magic = MALLOC_MAGIC;
|
bh->size = size;
|
|
return bh + 1;
|
fail:
|
ph->used -= size;
|
write_unlock(&ph->lock);
|
|
return NULL;
|
}
|
|
void pvheapobj_free(struct heapobj *hobj, void *ptr)
|
{
|
struct block_header *bh = ptr - sizeof(*bh);
|
struct pool_header *ph = hobj->pool;
|
|
assert(hobj->size >= bh->size);
|
write_lock(&ph->lock);
|
ph->used -= bh->size;
|
write_unlock(&ph->lock);
|
free(bh);
|
}
|
|
size_t pvheapobj_inquire(struct heapobj *hobj)
|
{
|
struct pool_header *ph = hobj->pool;
|
|
return ph->used;
|
}
|
|
size_t pvheapobj_validate(struct heapobj *hobj, void *ptr)
|
{
|
struct block_header *bh;
|
|
/* Catch trivially wrong cases: NULL or unaligned. */
|
if (ptr == NULL)
|
return 0;
|
|
if ((unsigned long)ptr & (sizeof(unsigned long)-1))
|
return 0;
|
|
/*
|
* We will likely get hard validation here, i.e. crash or
|
* abort if the pointer is out of the address space. TLSF is a
|
* bit smarter, and pshared definitely does the right thing.
|
*/
|
|
bh = ptr - sizeof(*bh);
|
if (bh->magic != MALLOC_MAGIC)
|
return 0;
|
|
return bh->size;
|
}
|
|
int heapobj_pkg_init_private(void)
|
{
|
return 0;
|
}
|
