Jerry/bird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
bird/sysdep/unix/alloc.c

130 lines
2.4 KiB
C
Raw Permalink Normal View History

Slab: head now uses bitmask for used/free nodes info instead of lists From now, there are no auxiliary pointers stored in the free slab nodes. This led to strange debugging problems if use-after-free happened in slab-allocated structures, especially if the structure's first member is a next pointer. This also reduces the memory needed by 1 pointer per allocated object. OTOH, we now rely on pages being aligned to their size's multiple, which is quite common anyway.
2020-07-22 06:09:15 +08:00
/*
* BIRD Internet Routing Daemon -- Raw allocation
*
* (c) 2020 Maria Matejka <mq@ucw.cz>
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "nest/bird.h"
#include "lib/resource.h"
Directly mapped pages are kept for future use if temporarily not needed
2021-11-25 00:30:13 +08:00
#include "lib/lists.h"
#include "lib/event.h"
Slab: head now uses bitmask for used/free nodes info instead of lists From now, there are no auxiliary pointers stored in the free slab nodes. This led to strange debugging problems if use-after-free happened in slab-allocated structures, especially if the structure's first member is a next pointer. This also reduces the memory needed by 1 pointer per allocated object. OTOH, we now rely on pages being aligned to their size's multiple, which is quite common anyway.
2020-07-22 06:09:15 +08:00
Fixed a munmap abort bug When BIRD was munmapping too many pages, it sometimes aborted, saying that munmap failed with "Not enough memory" as the address space was getting more and more fragmented. There is a workaround in place, simply keeping that page for future use, yet it has never been compiled in because I somehow forgot to include errno.h. And because I also thought that somebody may have ENOMEM not defined (why?!), there was a check which quietly omitted that workaround. Anyway, ENOMEM is POSIX. It's an utter nonsense to check for its existence. If it doesn't exist, something is broken.
2022-04-13 17:28:15 +08:00
#include <errno.h>
Slab: head now uses bitmask for used/free nodes info instead of lists From now, there are no auxiliary pointers stored in the free slab nodes. This led to strange debugging problems if use-after-free happened in slab-allocated structures, especially if the structure's first member is a next pointer. This also reduces the memory needed by 1 pointer per allocated object. OTOH, we now rely on pages being aligned to their size's multiple, which is quite common anyway.
2020-07-22 06:09:15 +08:00
#include <stdlib.h>
#include <unistd.h>
#ifdef HAVE_MMAP
#include <sys/mman.h>
#endif
#ifdef HAVE_MMAP
Directly mapped pages are kept for future use if temporarily not needed
2021-11-25 00:30:13 +08:00
#define KEEP_PAGES 512
Slab: head now uses bitmask for used/free nodes info instead of lists From now, there are no auxiliary pointers stored in the free slab nodes. This led to strange debugging problems if use-after-free happened in slab-allocated structures, especially if the structure's first member is a next pointer. This also reduces the memory needed by 1 pointer per allocated object. OTOH, we now rely on pages being aligned to their size's multiple, which is quite common anyway.
2020-07-22 06:09:15 +08:00
static u64 page_size = 0;
static _Bool use_fake = 0;
Directly mapped pages are kept for future use if temporarily not needed
2021-11-25 00:30:13 +08:00
uint pages_kept = 0;
static list pages_list;
static void cleanup_pages(void *data);
static event page_cleanup_event = { .hook = cleanup_pages };
Slab: head now uses bitmask for used/free nodes info instead of lists From now, there are no auxiliary pointers stored in the free slab nodes. This led to strange debugging problems if use-after-free happened in slab-allocated structures, especially if the structure's first member is a next pointer. This also reduces the memory needed by 1 pointer per allocated object. OTOH, we now rely on pages being aligned to their size's multiple, which is quite common anyway.
2020-07-22 06:09:15 +08:00
#else
static const u64 page_size = 4096; /* Fake page size */
#endif
u64 get_page_size(void)
{
if (page_size)
return page_size;
#ifdef HAVE_MMAP
if (page_size = sysconf(_SC_PAGESIZE))
{
if ((u64_popcount(page_size) > 1) || (page_size > 16384))
{
/* Too big or strange page, use the aligned allocator instead */
page_size = 4096;
use_fake = 1;
}
return page_size;
}
bug("Page size must be non-zero");
#endif
}
void *
alloc_page(void)
{
#ifdef HAVE_MMAP
Directly mapped pages are kept for future use if temporarily not needed
2021-11-25 00:30:13 +08:00
if (pages_kept)
{
node *page = TAIL(pages_list);
rem_node(page);
pages_kept--;
memset(page, 0, get_page_size());
return page;
}
Slab: head now uses bitmask for used/free nodes info instead of lists From now, there are no auxiliary pointers stored in the free slab nodes. This led to strange debugging problems if use-after-free happened in slab-allocated structures, especially if the structure's first member is a next pointer. This also reduces the memory needed by 1 pointer per allocated object. OTOH, we now rely on pages being aligned to their size's multiple, which is quite common anyway.
2020-07-22 06:09:15 +08:00
if (!use_fake)
{
void *ret = mmap(NULL, get_page_size(), PROT_WRITE | PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (ret == MAP_FAILED)
Alloc: Use posix_memalign() instead of aligned_alloc() For compatibility with older systems use posix_memalign(). We can switch to aligned_alloc() when we commit to C11 for multithreading.
2022-02-09 05:42:00 +08:00
bug("mmap(%lu) failed: %m", (long unsigned int) page_size);
Slab: head now uses bitmask for used/free nodes info instead of lists From now, there are no auxiliary pointers stored in the free slab nodes. This led to strange debugging problems if use-after-free happened in slab-allocated structures, especially if the structure's first member is a next pointer. This also reduces the memory needed by 1 pointer per allocated object. OTOH, we now rely on pages being aligned to their size's multiple, which is quite common anyway.
2020-07-22 06:09:15 +08:00
return ret;
}
else
#endif
{
Alloc: Use posix_memalign() instead of aligned_alloc() For compatibility with older systems use posix_memalign(). We can switch to aligned_alloc() when we commit to C11 for multithreading.
2022-02-09 05:42:00 +08:00
void *ptr = NULL;
int err = posix_memalign(&ptr, page_size, page_size);
if (err || !ptr)
bug("posix_memalign(%lu) failed", (long unsigned int) page_size);
return ptr;
Slab: head now uses bitmask for used/free nodes info instead of lists From now, there are no auxiliary pointers stored in the free slab nodes. This led to strange debugging problems if use-after-free happened in slab-allocated structures, especially if the structure's first member is a next pointer. This also reduces the memory needed by 1 pointer per allocated object. OTOH, we now rely on pages being aligned to their size's multiple, which is quite common anyway.
2020-07-22 06:09:15 +08:00
}
}
void
free_page(void *ptr)
{
#ifdef HAVE_MMAP
if (!use_fake)
{
Directly mapped pages are kept for future use if temporarily not needed
2021-11-25 00:30:13 +08:00
if (!pages_kept)
init_list(&pages_list);
memset(ptr, 0, sizeof(node));
add_tail(&pages_list, ptr);
if (++pages_kept > KEEP_PAGES)
ev_schedule(&page_cleanup_event);
Slab: head now uses bitmask for used/free nodes info instead of lists From now, there are no auxiliary pointers stored in the free slab nodes. This led to strange debugging problems if use-after-free happened in slab-allocated structures, especially if the structure's first member is a next pointer. This also reduces the memory needed by 1 pointer per allocated object. OTOH, we now rely on pages being aligned to their size's multiple, which is quite common anyway.
2020-07-22 06:09:15 +08:00
}
else
#endif
free(ptr);
}
Directly mapped pages are kept for future use if temporarily not needed
2021-11-25 00:30:13 +08:00
#ifdef HAVE_MMAP
static void
cleanup_pages(void *data UNUSED)
{
for (uint seen = 0; (pages_kept > KEEP_PAGES) && (seen < KEEP_PAGES); seen++)
{
void *ptr = HEAD(pages_list);
rem_node(ptr);
if (munmap(ptr, get_page_size()) == 0)
pages_kept--;
else if (errno == ENOMEM)
add_tail(&pages_list, ptr);
else
bug("munmap(%p) failed: %m", ptr);
}
if (pages_kept > KEEP_PAGES)
ev_schedule(&page_cleanup_event);
}
#endif
Reference in a new issue Copy permalink