/* vim: set expandtab ts=4 sw=4: */
/*
* You may redistribute this program and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation,
* either version 3 of the License, or (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "memory/Allocator.h"
#include "memory/Allocator_pvt.h"
#include "util/Bits.h"
#include "util/Defined.h"
#include
/** This provides the padding for each line based on the depth in the stack. */
struct Unroller;
struct Unroller
{
const char* const content;
const struct Unroller* const last;
};
static void writeUnroller(const struct Unroller* unroller)
{
if (unroller) {
writeUnroller(unroller->last);
fprintf(stderr, "%s", unroller->content);
}
}
static void unroll(struct Allocator_pvt* context,
int includeAllocations,
struct Unroller* unroller)
{
writeUnroller(unroller);
const char* ident = (context->pub.fileName) ? context->pub.fileName : "UNKNOWN";
fprintf(stderr, "%s:%d [%lu] bytes%s\n",
ident,
context->pub.lineNum,
context->allocatedHere,
(context->pub.isFreeing) ? " (freeing)" : "");
struct Unroller childUnroller = {
.content = ((context->nextSibling) ? "| " : " "),
.last = unroller
};
if (context->firstChild) {
unroll(context->firstChild, includeAllocations, &childUnroller);
}
struct Allocator_Allocation_pvt* allocation = context->allocations;
while (allocation && includeAllocations) {
writeUnroller(&childUnroller);
fprintf(stderr, "%s:%ld [%lu] bytes at [0x%lx]\n",
allocation->fileName,
(unsigned long)allocation->lineNum,
(unsigned long)allocation->pub.size,
(unsigned long)(uintptr_t)allocation);
allocation = allocation->next;
}
if (context->nextSibling) {
unroll(context->nextSibling, includeAllocations, unroller);
}
}
static inline uint64_t bytesAllocated(struct Allocator_pvt* ctx)
{
uint64_t bytes = ctx->allocatedHere;
for (struct Allocator_pvt* child = ctx->firstChild; child; child = child->nextSibling) {
bytes += bytesAllocated(child);
}
return bytes;
}
static void check(struct Allocator_pvt* alloc)
{
if (!Defined(Allocator_PARANOIA)) { return; }
uint64_t totalAllocated = alloc->rootAlloc->maxSpace - alloc->rootAlloc->spaceAvailable;
uint64_t accounted = bytesAllocated(Identity_check((struct Allocator_pvt*)alloc->rootAlloc));
Assert_true(totalAllocated == accounted);
}
void Allocator_snapshot(struct Allocator* allocator, int includeAllocations)
{
// get the root allocator.
struct Allocator_pvt* alloc = Identity_check((struct Allocator_pvt*)allocator);
struct Allocator_FirstCtx* rootAlloc = Identity_check(alloc->rootAlloc);
alloc = Identity_check((struct Allocator_pvt*)rootAlloc);
fprintf(stderr, "----- %scjdns memory snapshot -----\n", "");
uint64_t totalAllocated = rootAlloc->maxSpace - rootAlloc->spaceAvailable;
uint64_t realAllocated = bytesAllocated(alloc);
unroll(alloc, includeAllocations, NULL);
if (totalAllocated != realAllocated) {
fprintf(stderr, "!!!!!! INTERNAL ERROR totalAllocated = [%lu] realAllocated = [%lu] !!!!!",
(unsigned long)totalAllocated, (unsigned long)realAllocated);
}
fprintf(stderr, "totalBytes [%ld] remaining [%ld]\n",
(long)rootAlloc->maxSpace,
(long)rootAlloc->spaceAvailable);
fprintf(stderr, "----- %scjdns memory snapshot -----\n", "end ");
}
Gcc_NORETURN
static void failure(struct Allocator_pvt* context,
const char* message,
const char* fileName,
int lineNum)
{
Allocator_snapshot(&context->pub, 1);
Assert_failure("%s:%d Fatal error: [%s]", fileName, lineNum, message);
}
static inline unsigned long getRealSize(unsigned long requestedSize)
{
return ((requestedSize + (sizeof(char*) - 1)) & ~(sizeof(char*) - 1)) // align
+ sizeof(struct Allocator_Allocation_pvt)
#ifdef Allocator_USE_CANARIES
+ sizeof(uintptr_t)
#endif
;
}
#define END_CANARY(alloc) ((uintptr_t*) alloc)[ (alloc->pub.size / sizeof(uintptr_t)) - 1 ]
static inline void setCanaries(struct Allocator_Allocation_pvt* alloc,
struct Allocator_pvt* context)
{
#ifdef Allocator_USE_CANARIES
END_CANARY(alloc) = context->canary ^ (uintptr_t)alloc->fileName;
#endif
}
static inline void checkCanaries(struct Allocator_Allocation_pvt* alloc,
struct Allocator_pvt* context)
{
#ifdef Allocator_USE_CANARIES
if (END_CANARY(alloc) == ((uintptr_t)alloc->fileName ^ context->canary)) { return; }
Assert_failure("%s:%d Fatal error: invalid canary\n",
context->pub.fileName, context->pub.lineNum);
#endif
}
Gcc_ALLOC_SIZE(2)
static inline void* newAllocation(struct Allocator_pvt* context,
unsigned long size,
const char* fileName,
int lineNum)
{
check(context);
int64_t realSize = getRealSize(size);
struct Allocator_FirstCtx* rootAlloc = Identity_check(context->rootAlloc);
if (rootAlloc->spaceAvailable <= realSize) {
failure(context, "Out of memory, limit exceeded", fileName, lineNum);
}
rootAlloc->spaceAvailable -= realSize;
context->allocatedHere += realSize;
struct Allocator_Allocation_pvt* alloc =
rootAlloc->provider(rootAlloc->providerContext,
NULL,
realSize,
&context->pub);
if (alloc == NULL) {
failure(context, "Out of memory, malloc() returned NULL", fileName, lineNum);
}
alloc->next = context->allocations;
alloc->pub.size = realSize;
alloc->fileName = fileName;
alloc->lineNum = lineNum;
context->allocations = alloc;
setCanaries(alloc, context);
return (void*) (alloc + 1);
}
struct Allocator_Allocation* Allocator_getAllocation(struct Allocator* alloc, int allocNum)
{
struct Allocator_pvt* ctx = Identity_check((struct Allocator_pvt*)alloc);
if (allocNum < 0) {
return NULL;
}
struct Allocator_Allocation_pvt* allocation = ctx->allocations;
for (;allocation && allocNum > 0; allocNum--) {
allocation = allocation->next;
}
return (allocation) ? &allocation->pub : NULL;
}
struct Allocator* Allocator_getChild(struct Allocator* alloc, int childNumber)
{
struct Allocator_pvt* ctx = Identity_check((struct Allocator_pvt*)alloc);
if (childNumber < 0) {
return NULL;
}
struct Allocator_pvt* child = ctx->firstChild;
for (;child && childNumber > 0; childNumber--) {
child = child->nextSibling;
}
return (child) ? &child->pub : NULL;
}
static int removeJob(struct Allocator_OnFreeJob_pvt* job)
{
struct Allocator_pvt* context = Identity_check(job->alloc);
struct Allocator_OnFreeJob_pvt* j = context->onFree;
struct Allocator_OnFreeJob_pvt** jP = &context->onFree;
while (j && j != job) {
jP = &j->next;
j = j->next;
}
if (j == job) {
*jP = j->next;
return 0;
} else {
return -1;
failure(context, "Allocator_onFreeComplete() called multiple times", job->file, job->line);
}
}
static void releaseAllocation(struct Allocator_pvt* context,
struct Allocator_Allocation_pvt* allocation,
Allocator_Provider provider,
Allocator_Provider_CONTEXT_TYPE* providerCtx)
{
checkCanaries(allocation, context);
// TODO(cjd): make this optional.
Bits_memset(&(&allocation->pub)[1],
0xee,
allocation->pub.size - sizeof(struct Allocator_Allocation));
provider(providerCtx,
&allocation->pub,
0,
((char*)context != (char*)allocation) ? &context->pub : NULL);
}
static void releaseMemory(struct Allocator_pvt* context,
Allocator_Provider provider,
Allocator_Provider_CONTEXT_TYPE* providerCtx)
{
// Free all of the allocations including the one which holds the allocator.
#ifdef PARANOIA
unsigned long allocatedHere = context->allocatedHere;
#endif
Identity_check(context->rootAlloc)->spaceAvailable += context->allocatedHere;
struct Allocator_Allocation_pvt* loc = context->allocations;
while (loc != NULL) {
#ifdef PARANOIA
allocatedHere -= loc->pub.size;
#endif
struct Allocator_Allocation_pvt* nextLoc = loc->next;
releaseAllocation(context, loc, provider, providerCtx);
loc = nextLoc;
}
#ifdef PARANOIA
Assert_true(allocatedHere == 0);
#endif
}
// disconnect an allocator from it's parent.
static void disconnect(struct Allocator_pvt* context)
{
// Remove this allocator from the sibling list.
Assert_true(context->parent);
if (context->lastSibling) {
Assert_ifParanoid(context->lastSibling->nextSibling == context);
Assert_ifParanoid(context->parent->firstChild != context);
context->lastSibling->nextSibling = context->nextSibling;
} else {
// must be first in the list or a root allocator.
Assert_ifParanoid(context->parent->firstChild == context || context->parent == context);
Assert_ifParanoid(context->parent != context || !context->nextSibling);
context->parent->firstChild = context->nextSibling;
}
if (context->nextSibling) {
Assert_ifParanoid(context->nextSibling->lastSibling == context);
context->nextSibling->lastSibling = context->lastSibling;
}
context->lastSibling = NULL;
context->nextSibling = NULL;
context->parent = NULL;
}
// connect an allocator to a new parent.
static void connect(struct Allocator_pvt* parent,
struct Allocator_pvt* child,
const char* file,
int line)
{
Assert_ifParanoid(child->parent == NULL);
Assert_ifParanoid(child->lastSibling == NULL);
Assert_ifParanoid(child->nextSibling == NULL);
Assert_true(parent != child);
if (Defined(PARANOIA)) {
for (struct Allocator_pvt* c = parent->firstChild; c; c = c->nextSibling) {
Assert_true(child != c);
}
}
child->nextSibling = parent->firstChild;
if (parent->firstChild) {
parent->firstChild->lastSibling = child;
}
parent->firstChild = child;
child->parent = parent;
}
static int disconnectAllocator(struct Allocator_pvt* target, struct Allocator_List** cpp)
{
int found = 0;
struct Allocator_List* cp;
while ((cp = *cpp)) {
if (cp->alloc == target) {
*cpp = cp->next;
found = 1;
break;
}
cpp = &cp->next;
}
return found;
}
static void disconnectAdopted(struct Allocator_pvt* parent, struct Allocator_pvt* child)
{
Assert_true(parent->adoptions);
Assert_true(parent->adoptions->children);
Assert_true(child->adoptions);
Assert_true(child->adoptions->parents);
Assert_true(disconnectAllocator(child, &parent->adoptions->children));
Assert_true(disconnectAllocator(parent, &child->adoptions->parents));
}
// Shallow first search to prevent lots of flapping while we tear down the tree.
static int pivotChildrenToAdoptedParents0(struct Allocator_pvt* context,
int depth,
int maxDepth,
const char* file,
int line)
{
int out = 0;
if (depth == maxDepth) {
if (context->pub.isFreeing) { return 0; }
if (context->adoptions) {
// Attempt to pivot around to a parent in order to save this allocator
if (context->adoptions->parents) {
Assert_true(!context->adoptions->parents->alloc->pub.isFreeing);
disconnect(context);
connect(context->adoptions->parents->alloc, context, file, line);
disconnectAdopted(context->adoptions->parents->alloc, context);
return 0;
}
// No saving it, drop it's adoptions.
for (struct Allocator_List* c = context->adoptions->children; c; c = c->next) {
Assert_true(!c->alloc->pub.isFreeing);
disconnectAdopted(context, c->alloc);
}
}
Assert_true(!context->pub.isFreeing);
context->pub.isFreeing = 1;
out++;
} else {
struct Allocator_pvt* child = context->firstChild;
while (child) {
Assert_ifParanoid(child != context);
struct Allocator_pvt* nextChild = child->nextSibling;
out += pivotChildrenToAdoptedParents0(child, depth+1, maxDepth, file, line);
child = nextChild;
}
}
return out;
}
static int pivotChildrenToAdoptedParents(struct Allocator_pvt* context, const char* file, int line)
{
for (int i = 0; i < 10000; i++) {
if (!pivotChildrenToAdoptedParents0(context, 0, i, file, line)) {
// No out on i == 0 -> the allocator pivoted to another parent, cease freeing.
return (i != 0);
}
}
Assert_failure("Didn't free all allocators in 10000 deep iterations");
}
/**
* Collect all of the onFree jobs from all of the child allocators (deep) and attach them all
* to the root of the tree which is being freed. They are not detached from their relevant
* allocators because those allocators will be freed soon anyway.
*/
static void marshalOnFreeJobs(struct Allocator_pvt* context, struct Allocator_pvt* rootToFree)
{
Assert_true(context->pub.isFreeing);
struct Allocator_pvt* child = context->firstChild;
while (child) {
// Theoretically the order of free jobs is not promised but this prevents libuv crashing.
struct Allocator_OnFreeJob_pvt** jobP = &rootToFree->onFree;
while (*jobP != NULL) {
struct Allocator_OnFreeJob_pvt* job = *jobP;
jobP = &job->next;
}
*jobP = child->onFree;
child->onFree = NULL;
while (*jobP != NULL) {
struct Allocator_OnFreeJob_pvt* job = *jobP;
job->alloc = rootToFree;
jobP = &job->next;
}
struct Allocator_pvt* nextChild = child->nextSibling;
marshalOnFreeJobs(child, rootToFree);
child = nextChild;
}
}
static void doOnFreeJobs(struct Allocator_pvt* context)
{
// Do the onFree jobs.
struct Allocator_OnFreeJob_pvt** jobP = &context->onFree;
while (*jobP != NULL) {
struct Allocator_OnFreeJob_pvt* job = *jobP;
if (!job->pub.callback) {
// no callback, remove the job
Assert_true(!removeJob(job));
continue;
} else if (!job->called) {
if (job->pub.callback(&job->pub) != Allocator_ONFREE_ASYNC) {
Assert_true(!removeJob(job));
continue;
} else {
job->called = 1;
}
}
jobP = &job->next;
}
}
static void freeAllocator(struct Allocator_pvt* context)
{
Assert_true(context->pub.isFreeing);
int isTop = !context->parent->pub.isFreeing;
if (isTop) {
check(context);
disconnect(context);
}
struct Allocator_pvt* child = context->firstChild;
while (child) {
struct Allocator_pvt* nextChild = child->nextSibling;
freeAllocator(child);
child = nextChild;
}
// Grab out the provider and provider context in case the root allocator is freed.
struct Allocator_FirstCtx* rootAlloc = Identity_check(context->rootAlloc);
Allocator_Provider provider = rootAlloc->provider;
Allocator_Provider_CONTEXT_TYPE* providerCtx = rootAlloc->providerContext;
releaseMemory(context, provider, providerCtx);
if (isTop) {
check((struct Allocator_pvt*)rootAlloc);
}
}
void Allocator_onFreeComplete(struct Allocator_OnFreeJob* onFreeJob)
{
struct Allocator_OnFreeJob_pvt* job = (struct Allocator_OnFreeJob_pvt*) onFreeJob;
struct Allocator_pvt* context = Identity_check(job->alloc);
if (removeJob(job)) {
failure(context, "OnFreeJob->complete() called multiple times", job->file, job->line);
}
if (!context->onFree) {
// There are no more jobs, release the memory.
freeAllocator(context);
}
}
void Allocator__free(struct Allocator* alloc, const char* file, int line)
{
struct Allocator_pvt* context = Identity_check((struct Allocator_pvt*) alloc);
check(context);
// It's really difficult to know that you didn't get called back inside of a freeing of a
// parent of a parent allocator which causes your allocator to be in isFreeing state so
// lets be forgiving here.
if (context->pub.isFreeing) { return; }
if (context->rootAlloc == (struct Allocator_FirstCtx*)context) {
struct Allocator_FirstCtx* rootAlloc = Identity_check((struct Allocator_FirstCtx*)context);
if (bytesAllocated(context) + rootAlloc->spaceAvailable != (uint64_t)rootAlloc->maxSpace) {
failure(context, "unaccounted for memory", file, line);
}
}
check(context);
if (!pivotChildrenToAdoptedParents(context, file, line)) { return; }
check(context);
marshalOnFreeJobs(context, context);
check(context);
doOnFreeJobs(context);
check(context);
if (!context->onFree) {
freeAllocator(context);
}
}
void* Allocator__malloc(struct Allocator* allocator,
unsigned long length,
const char* fileName,
int lineNum)
{
struct Allocator_pvt* ctx = Identity_check((struct Allocator_pvt*) allocator);
void* out = newAllocation(ctx, length, fileName, lineNum);
check(ctx);
return out;
}
void* Allocator__calloc(struct Allocator* alloc,
unsigned long length,
unsigned long count,
const char* fileName,
int lineNum)
{
void* pointer = Allocator__malloc(alloc, length * count, fileName, lineNum);
Bits_memset(pointer, 0, length * count);
return pointer;
}
void* Allocator__realloc(struct Allocator* allocator,
const void* original,
unsigned long size,
const char* fileName,
int lineNum)
{
if (original == NULL) {
return Allocator__malloc(allocator, size, fileName, lineNum);
}
struct Allocator_pvt* context = Identity_check((struct Allocator_pvt*) allocator);
check(context);
struct Allocator_Allocation_pvt** locPtr = &context->allocations;
struct Allocator_Allocation_pvt* origLoc =
((struct Allocator_Allocation_pvt*) original) - 1;
for (;;) {
struct Allocator_Allocation_pvt* loc = *locPtr;
if (loc == NULL) {
failure(context,
"Reallocation of memory which was not allocated using this allocator.",
fileName,
lineNum);
}
checkCanaries(loc, context);
if (loc == origLoc) {
break;
}
locPtr = &loc->next;
}
struct Allocator_Allocation_pvt* nextLoc = origLoc->next;
if (size == 0) {
// realloc(0) means free()
*locPtr = nextLoc;
Assert_true(origLoc->pub.size <= context->allocatedHere);
context->rootAlloc->spaceAvailable += origLoc->pub.size;
context->allocatedHere -= origLoc->pub.size;
releaseAllocation(context,
origLoc,
context->rootAlloc->provider,
context->rootAlloc->providerContext);
check(context);
return NULL;
}
size_t realSize = getRealSize(size);
if (context->rootAlloc->spaceAvailable + origLoc->pub.size < realSize) {
failure(context, "Out of memory, limit exceeded.", fileName, lineNum);
}
context->rootAlloc->spaceAvailable += origLoc->pub.size;
context->rootAlloc->spaceAvailable -= realSize;
context->allocatedHere -= origLoc->pub.size;
context->allocatedHere += realSize;
struct Allocator_Allocation_pvt* alloc =
context->rootAlloc->provider(context->rootAlloc->providerContext,
&origLoc->pub,
realSize,
allocator);
if (alloc == NULL) {
failure(context, "Out of memory, realloc() returned NULL.", fileName, lineNum);
}
alloc->next = nextLoc;
alloc->pub.size = realSize;
*locPtr = alloc;
setCanaries(alloc, context);
check(context);
return (void*) (alloc + 1);
}
void* Allocator__clone(struct Allocator* allocator,
const void* toClone,
unsigned long length,
const char* fileName,
int lineNum)
{
void* pointer = Allocator__malloc(allocator, length, fileName, lineNum);
Bits_memcpy(pointer, toClone, length);
return pointer;
}
struct Allocator* Allocator__child(struct Allocator* allocator, const char* file, int line)
{
struct Allocator_pvt* parent = Identity_check((struct Allocator_pvt*) allocator);
check(parent);
struct Allocator_pvt stackChild = {
.pub = {
.fileName = file,
.lineNum = line,
.isFreeing = parent->pub.isFreeing
},
.rootAlloc = parent->rootAlloc
};
Identity_set(&stackChild);
#ifdef Allocator_USE_CANARIES
stackChild.nextCanary = stackChild.canary = parent->nextCanary;
#endif
struct Allocator_pvt* child =
newAllocation(&stackChild, sizeof(struct Allocator_pvt), file, line);
Bits_memcpy(child, &stackChild, sizeof(struct Allocator_pvt));
// Link the child into the parent's allocator list
connect(parent, child, file, line);
check(parent);
return &child->pub;
}
int Allocator_cancelOnFree(struct Allocator_OnFreeJob* toRemove)
{
struct Allocator_OnFreeJob_pvt* job = (struct Allocator_OnFreeJob_pvt*) toRemove;
struct Allocator_pvt* context = Identity_check(job->alloc);
struct Allocator_OnFreeJob_pvt** jobPtr = &(context->onFree);
while (*jobPtr != NULL) {
if (*jobPtr == job) {
*jobPtr = (*jobPtr)->next;
return 0;
}
jobPtr = &(*jobPtr)->next;
}
return -1;
}
/** return 1 if true, otherwise zero. */
static int isAncestorOf(struct Allocator_pvt* maybeParent,
struct Allocator_pvt* maybeChild)
{
if (maybeParent == maybeChild) {
return 1;
}
if (maybeParent == NULL || maybeChild == NULL || maybeChild->parent == maybeChild) {
return 0;
}
if (isAncestorOf(maybeParent, maybeChild->parent)) {
return 1;
}
if (maybeChild->adoptions) {
struct Allocator_List* al = maybeChild->adoptions->parents;
while (al) {
if (isAncestorOf(maybeParent, al->alloc)) {
return 1;
}
}
}
return 0;
}
void Allocator__disown(struct Allocator* parentAlloc,
struct Allocator* allocToDisown,
const char* fileName,
int lineNum)
{
struct Allocator_pvt* parent = Identity_check((struct Allocator_pvt*) parentAlloc);
struct Allocator_pvt* child = Identity_check((struct Allocator_pvt*) allocToDisown);
if (parent->pub.isFreeing || child->pub.isFreeing) { return; }
if (child->parent == parent) {
// The child's natural parent has been freed and it has pivoted to the adopted parent
// Do a normal Allocator_free() and it will either pivot once again to another adopter
// or it will drop from the tree and free.
Allocator__free(&child->pub, fileName, lineNum);
return;
}
if (isAncestorOf(child, parent)) {
// Rare but possible way that the child would never have been adopted.
return;
}
disconnectAdopted(parent, child);
}
void Allocator__adopt(struct Allocator* adoptedParent,
struct Allocator* childToAdopt,
const char* file,
int line)
{
struct Allocator_pvt* parent = Identity_check((struct Allocator_pvt*) adoptedParent);
struct Allocator_pvt* child = Identity_check((struct Allocator_pvt*) childToAdopt);
if (parent->pub.isFreeing) { return; }
Assert_true(!child->pub.isFreeing);
if (isAncestorOf(child, parent)) {
// The child is a parent of the parent, this means an adoption would be meaningless
// because if the child is otherwise freed, it will take the parent along with it.
return;
}
if (!parent->adoptions) {
parent->adoptions =
Allocator__calloc(adoptedParent, sizeof(struct Allocator_Adoptions), 1, file, line);
}
if (!child->adoptions) {
child->adoptions =
Allocator__calloc(childToAdopt, sizeof(struct Allocator_Adoptions), 1, file, line);
}
struct Allocator_List* pl =
Allocator__calloc(childToAdopt, sizeof(struct Allocator_List), 1, file, line);
pl->alloc = child;
pl->next = parent->adoptions->children;
parent->adoptions->children = pl;
struct Allocator_List* cl =
Allocator__calloc(childToAdopt, sizeof(struct Allocator_List), 1, file, line);
cl->alloc = parent;
cl->next = child->adoptions->parents;
child->adoptions->parents = cl;
}
struct Allocator_OnFreeJob* Allocator__onFree(struct Allocator* alloc,
Allocator_OnFreeCallback callback,
void* callbackContext,
const char* file,
int line)
{
struct Allocator_pvt* context = Identity_check((struct Allocator_pvt*) alloc);
while (context->pub.isFreeing) {
// Assign new onFree jobs at the top level
if (context->parent == context || !context->parent->pub.isFreeing) {
break;
}
context = context->parent;
}
struct Allocator_OnFreeJob_pvt* newJob =
Allocator_clone(alloc, (&(struct Allocator_OnFreeJob_pvt) {
.pub = {
.callback = callback,
.userData = callbackContext
},
.alloc = context,
.file = file,
.line = line
}));
Identity_set(newJob);
struct Allocator_OnFreeJob_pvt* job = context->onFree;
if (job == NULL) {
context->onFree = newJob;
} else {
while (job->next != NULL) {
job = job->next;
}
job->next = newJob;
}
return &newJob->pub;
}
struct Allocator* Allocator_new(unsigned long sizeLimit,
Allocator_Provider provider,
void* providerContext,
const char* fileName,
int lineNum)
{
if (sizeLimit == 0) {
sizeLimit = INT64_MAX - getRealSize(sizeof(struct Allocator_FirstCtx));
}
// Add in the size of the allocator so that a very small sizeLimit is sane.
sizeLimit += getRealSize(sizeof(struct Allocator_FirstCtx));
struct Allocator_FirstCtx stackContext = {
.spaceAvailable = sizeLimit,
.provider = provider,
.providerContext = providerContext,
.context = {
.pub = {
.fileName = fileName,
.lineNum = lineNum,
},
#ifdef Allocator_USE_CANARIES
.canary = (uintptr_t) Constant_rand64(),
.nextCanary = (uintptr_t) Constant_rand64(),
#endif
}
};
stackContext.maxSpace = stackContext.spaceAvailable;
stackContext.context.rootAlloc = &stackContext;
Identity_set(&stackContext);
Identity_set(&stackContext.context);
struct Allocator_FirstCtx* firstContext =
Allocator__clone(&stackContext.context.pub,
&stackContext,
sizeof(struct Allocator_FirstCtx),
fileName,
lineNum);
struct Allocator_pvt* context = &firstContext->context;
context->rootAlloc = firstContext;
context->parent = context;
check(context);
return &context->pub;
}
unsigned long Allocator_bytesAllocated(struct Allocator* allocator)
{
struct Allocator_pvt* context = Identity_check((struct Allocator_pvt*) allocator);
return bytesAllocated(context);
}
void Allocator_setCanary(struct Allocator* alloc, uintptr_t value)
{
#ifdef Allocator_USE_CANARIES
struct Allocator_pvt* context = Identity_check((struct Allocator_pvt*) alloc);
context->nextCanary ^= value;
#endif
}