205 lines
2.9 KiB
C
205 lines
2.9 KiB
C
#include <sys/types.h>
|
|
#include <sys/mman.h>
|
|
#include <fcntl.h>
|
|
#include <abi_mutex.h>
|
|
#include <malloc.h>
|
|
#include <unistd.h>
|
|
#include <ns_api.h>
|
|
#include <ns_daemon.h>
|
|
|
|
typedef struct mem {
|
|
void *src;
|
|
size_t len;
|
|
struct mem *next;
|
|
} mem_t;
|
|
|
|
typedef struct arena {
|
|
void *arena;
|
|
mem_t *parts;
|
|
struct arena *next;
|
|
} arena_t;
|
|
arena_t *arenas = 0;
|
|
abilock_t alock = {0};
|
|
|
|
static void *
|
|
grow(size_t len, void *arena)
|
|
{
|
|
arena_t *ap;
|
|
mem_t *mp;
|
|
void *vp;
|
|
int fd;
|
|
void *guess;
|
|
|
|
fd = nsd_open("/dev/zero", O_RDWR, 0);
|
|
if (fd < 0) {
|
|
return (void *)-1;
|
|
}
|
|
|
|
for (ap = arenas; ap && (ap->arena != arena); ap = ap->next);
|
|
|
|
guess = (ap && ap->parts) ? (char *)ap->parts->src + ap->parts->len : 0;
|
|
|
|
vp = nsd_mmap(guess, len, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
|
|
close(fd);
|
|
if (vp == MAP_FAILED) {
|
|
return (void *)-1;
|
|
}
|
|
|
|
if (guess && (vp == guess)) {
|
|
ap->parts->len += len;
|
|
return vp;
|
|
}
|
|
|
|
mp = nsd_calloc(1, sizeof(*mp));
|
|
if (! mp) {
|
|
munmap(vp, len);
|
|
return (void *)-1;
|
|
}
|
|
mp->src = vp;
|
|
mp->len = len;
|
|
|
|
if (ap) {
|
|
mp->next = ap->parts;
|
|
ap->parts = mp;
|
|
} else {
|
|
ap = nsd_calloc(1, sizeof(*ap));
|
|
if (! ap) {
|
|
munmap(vp, len);
|
|
free(mp);
|
|
return (void *)-1;
|
|
}
|
|
ap->arena = (arena) ? arena : vp;
|
|
ap->parts = mp;
|
|
ap->next = arenas;
|
|
arenas = ap;
|
|
}
|
|
|
|
return vp;
|
|
}
|
|
|
|
void
|
|
m_release(void *arena)
|
|
{
|
|
arena_t *ap, **end;
|
|
mem_t *mp;
|
|
|
|
spin_lock(&alock);
|
|
|
|
for (end = &arenas, ap = arenas; ap && (ap->arena != arena);
|
|
end = &ap->next, ap = ap->next);
|
|
if (ap) {
|
|
for (mp = ap->parts; mp; mp = ap->parts) {
|
|
ap->parts = mp->next;
|
|
munmap(mp->src, mp->len);
|
|
free(mp);
|
|
}
|
|
*end = ap->next;
|
|
free(ap);
|
|
}
|
|
|
|
release_lock(&alock);
|
|
}
|
|
|
|
void *
|
|
m_arena(void)
|
|
{
|
|
void *vp, *r;
|
|
|
|
spin_lock(&alock);
|
|
|
|
vp = grow(1024, 0);
|
|
if (! vp) {
|
|
return (void *)-1;
|
|
}
|
|
|
|
r = acreate(vp, 1024, 0, 0, grow);
|
|
if (! r) {
|
|
m_release(vp);
|
|
release_lock(&alock);
|
|
return (void *)vp;
|
|
}
|
|
|
|
release_lock(&alock);
|
|
return r;
|
|
}
|
|
|
|
char *
|
|
m_strdup(char *s, size_t len, void *a)
|
|
{
|
|
char *r;
|
|
|
|
if (! len) {
|
|
len = strlen(s);
|
|
}
|
|
if (a) {
|
|
spin_lock(&alock);
|
|
r = amalloc(len + 1, a);
|
|
release_lock(&alock);
|
|
} else {
|
|
r = nsd_malloc(len + 1);
|
|
}
|
|
if (r) {
|
|
memcpy(r, s, len);
|
|
r[len] = 0;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
void *
|
|
m_malloc(size_t len, void *a)
|
|
{
|
|
void *vp;
|
|
|
|
if (a) {
|
|
spin_lock(&alock);
|
|
vp = amalloc(len, a);
|
|
release_lock(&alock);
|
|
return vp;
|
|
} else {
|
|
return nsd_malloc(len);
|
|
}
|
|
}
|
|
|
|
void *
|
|
m_calloc(int c, size_t len, void *a)
|
|
{
|
|
void *vp;
|
|
|
|
if (a) {
|
|
spin_lock(&alock);
|
|
vp = acalloc(c, len, a);
|
|
release_lock(&alock);
|
|
return vp;
|
|
} else {
|
|
return nsd_calloc(c, len);
|
|
}
|
|
}
|
|
|
|
void *
|
|
m_realloc(void *m, size_t len, void *a)
|
|
{
|
|
void *vp;
|
|
|
|
if (a) {
|
|
spin_lock(&alock);
|
|
vp = arealloc(m, len, a);
|
|
release_lock(&alock);
|
|
return vp;
|
|
} else {
|
|
return nsd_realloc(m, len);
|
|
}
|
|
}
|
|
|
|
void
|
|
m_free(void *m, void *a)
|
|
{
|
|
if (a) {
|
|
spin_lock(&alock);
|
|
afree(m, a);
|
|
release_lock(&alock);
|
|
} else {
|
|
free(m);
|
|
}
|
|
}
|