Function fm_malloc_init

mem/f_malloc.c:194–257

init malloc and return a fm_block*/

/* init malloc and return a fm_block*/
struct fm_block *fm_malloc_init(char *address, unsigned long size, char *name)

{
	char *start;
	char *end;
	struct fm_block *fm;
	unsigned long init_overhead;

	/* make address and size multiple of 8*/
	start=(char*)ROUNDUP((unsigned long) address);
	LM_DBG("F_OPTIMIZE=%lu, /ROUNDTO=%lu, %lu-bytes aligned\n",
			F_MALLOC_OPTIMIZE, F_MALLOC_OPTIMIZE/ROUNDTO,
			(unsigned long)ROUNDTO);
	LM_DBG("F_HASH_SIZE=%lu, fm_block size=%zu, frag_size=%zu\n",
			F_HASH_SIZE, sizeof(struct fm_block), sizeof(struct fm_frag));
	LM_DBG("params (%p, %lu), start=%p\n", address, size, start);

	if (size<(unsigned long)(start-address)) return 0;
	size-=(start-address);
	if (size <(MIN_FRAG_SIZE+FRAG_OVERHEAD)) return 0;
	size=ROUNDDOWN(size);

	init_overhead=(ROUNDUP(sizeof(struct fm_block))+ 2 * FRAG_OVERHEAD);


	if (size < init_overhead)
	{
		/* not enough mem to create our control structures !!!*/
		return 0;
	}
	end=start+size;
	fm=(struct fm_block *)(void *)start;
	memset(fm, 0, sizeof(struct fm_block));
	fm->name = name;
	fm->size=size;

	#if defined(DBG_MALLOC) || defined(STATISTICS)
	fm->used=size-init_overhead;
	fm->real_used=size;
	fm->max_real_used=init_overhead;
	fm->fragments = 0;
	#endif

	fm->first_frag=(struct fm_frag *)(void *)(start+ROUNDUP(sizeof(struct fm_block)));
	fm->last_frag=(struct fm_frag *)(void *)end - 1;

	/* init initial fragments */
	fm->first_frag->size=size-init_overhead;
	fm->first_frag->pf=NULL;
	fm->last_frag->size=0;
	fm->last_frag->pf=fm->first_frag;

	fm->last_frag->prev=NULL;
	fm->first_frag->prev=NULL;

	assert(((char *)fm->first_frag + sizeof *fm->first_frag + fm->first_frag->size)
				== (char *)fm->last_frag);