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; }