void lmm_dump(lmm_t *lmm)
{
struct lmm_region *reg;
printf("lmm_dump(lmm=%p)\n", lmm);
for (reg = lmm->regions; reg; reg = reg->next)
{
struct lmm_node *node;
int free_check;
printf(" region %08x-%08x size=%08x flags=%08x pri=%d free=%08x\n",
reg->min, reg->max, reg->max - reg->min,
reg->flags, reg->pri, reg->free);
CHECKREGPTR(reg);
free_check = 0;
for (node = reg->nodes; node; node = node->next)
{
printf(" node %p-%08x size=%08x next=%p\n",
node, (unsigned int)node + node->size, node->size, node->next);
assert(((unsigned int)node & ALIGN_MASK) == 0);
assert((node->size & ALIGN_MASK) == 0);
assert(node->size >= sizeof(*node));
assert((node->next == 0) || (node->next > node));
assert((unsigned int)node < reg->max);
free_check += node->size;
}
printf(" free_check=%08x\n", free_check);
assert(reg->free == free_check);
}
printf("lmm_dump done\n");
}
void *lmm_alloc_gen(lmm_t *lmm, int size, lmm_flags_t flags,
int align_bits, unsigned int align_ofs,
int in_min, int in_size)
{
unsigned int in_max = in_min + in_size;
struct lmm_region *reg;
#if 0
printf("lmm_alloc_gen %08x\n", size);
lmm_dump(lmm);
#endif
assert(lmm != 0);
assert(size > 0);
for (reg = lmm->regions; reg; reg = reg->next)
{
struct lmm_node **nodep, *node;
CHECKREGPTR(reg);
/* First trivially reject the entire region if possible. */
if ((flags & ~reg->flags)
|| (reg->min >= in_max)
|| (reg->max <= in_min))
continue;
for (nodep = ®->nodes;
(node = *nodep) != 0;
nodep = &node->next)
{
unsigned int addr;
struct lmm_node *anode;
int i;
assert(((unsigned int)node & ALIGN_MASK) == 0);
assert(((unsigned int)node->size & ALIGN_MASK) == 0);
assert((node->next == 0) || (node->next > node));
assert((unsigned int)node < reg->max);
/* Now make a first-cut trivial elimination check
to skip chunks that are _definitely_ too small. */
if (node->size < size)
continue;
/* Now compute the address at which
the allocated chunk would have to start. */
addr = (unsigned int)node;
if (addr < in_min)
addr = in_min;
for (i = 0; i < align_bits; i++)
{
unsigned int bit = (unsigned int)1 << i;
if ((addr ^ align_ofs) & bit)
addr += bit;
}
/* See if the block at the adjusted address
is still entirely within the node. */
if ((addr - (unsigned int)node + size) > node->size)
continue;
/* If the block extends past the range constraint,
then all of the rest of the nodes in this region
will extend past it too, so stop here. */
if (addr + size > in_max)
break;
/* OK, we can allocate the block from this node. */
/* If the allocation leaves at least ALIGN_SIZE
space before it, then split the node. */
anode = (struct lmm_node*)(addr & ~ALIGN_MASK);
assert(anode >= node);
if (anode > node)
{
unsigned int split_size = (unsigned int)anode
- (unsigned int)node;
assert((split_size & ALIGN_MASK) == 0);
anode->next = node->next;
anode->size = node->size - split_size;
node->size = split_size;
nodep = &node->next;
}
/* Now use the first part of the anode
to satisfy the allocation,
splitting off the tail end if necessary. */
size = ((addr & ALIGN_MASK) + size + ALIGN_MASK)
& ~ALIGN_MASK;
if (anode->size > size)
{
struct lmm_node *newnode;
/* Split the node and return its head. */
newnode = (struct lmm_node*)
((void*)anode + size);
newnode->next = anode->next;
newnode->size = anode->size - size;
*nodep = newnode;
}
else
{
/* Remove and return the entire node. */
*nodep = anode->next;
}
/* Adjust the region's free memory counter. */
assert(reg->free >= size);
reg->free -= size;
#if 0
printf("lmm_alloc_gen returning %08x\n", addr);
lmm_dump(lmm);
#endif
return (void*)addr;
}
}
#if 0
printf("lmm_alloc_gen failed\n");
#endif
return 0;
}
