xnu-1228.7.58.tar.gz

[apple/xnu.git] / libsa / malloc.c

/*
 * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
#include <string.h>

#include <mach/mach_types.h>

#include <kern/kern_types.h>
#include <kern/queue.h>
#include <kern/kalloc.h>
#include <kern/lock.h>
#include <kern/assert.h> 
#include <kern/zalloc.h>
#include <kern/debug.h>

#include <vm/vm_kern.h>

#include "libsa/malloc.h"

/*********************************************************************
* Structure for a client memory block. Contains linked-list pointers,
* a size field giving the TOTAL size of the block, including this
* header, and the address of the client's block. The client block
* field is guaranteed to lie on a 16-byte boundary.
*********************************************************************/
typedef struct malloc_block {

	struct malloc_block	*malFwd;
	struct malloc_block	*malBwd;
	void			*malActl;
	unsigned int		malSize;
} malloc_block;

static malloc_block malAnchor = {&malAnchor, &malAnchor, NULL, 0};

static int malInited = 0;
static mutex_t *malloc_lock;

__private_extern__
void * malloc(size_t size) {

    unsigned int nsize;
    unsigned int nmem, rmem;
    malloc_block *amem;
 
    assert(malInited);

 	nsize = size + sizeof(malloc_block) + 15;	/* Make sure we get enough to fit */

	nmem = (unsigned int)kalloc(nsize);			/* Get some */
	if(!nmem) {									/* Got any? */
		panic("malloc: no memory for a %08X sized request\n", nsize);
	}
	
	rmem = (nmem + 15) & -16;					/* Round to 16 byte boundary */
	amem = (malloc_block *)rmem;				/* Point to the block */
	amem->malActl = (void *)nmem;					/* Set the actual address */
	amem->malSize = nsize;						/* Size */
	
	mutex_lock(malloc_lock);
	
	amem->malFwd = malAnchor.malFwd;			/* Move anchor to our forward */
	amem->malBwd = &malAnchor;					/* We point back to anchor */
	malAnchor.malFwd->malBwd = amem;			/* The old forward's back points to us */
	malAnchor.malFwd = amem;					/* Now we point the anchor to us */
	
	mutex_unlock(malloc_lock);				/* Unlock now */
	
	return (void *)(rmem + 16);					/* Return the block */

} /* malloc() */


/*********************************************************************
* free()
*
*********************************************************************/
__private_extern__
void free(void * address) {


    malloc_block *amem, *fore, *aft;
    
    if(!(unsigned int)address) return;			/* Leave if they try to free nothing */
    
    
    amem = (malloc_block *)((unsigned int)address - sizeof(malloc_block));	/* Point to the header */

 	mutex_lock(malloc_lock);

	fore = amem->malFwd;						/* Get the guy in front */
	aft  = amem->malBwd;						/* And the guy behind */
	fore->malBwd = aft;							/* The next guy's previous is now my previous */
	aft->malFwd = fore;							/* The previous guy's forward is now mine */	

	mutex_unlock(malloc_lock);				/* Unlock now */
   
 	kfree(amem->malActl, amem->malSize);		/* Toss it */

	return;	

} /* free() */

/*********************************************************************
* malloc_reset()
*
* Allocate the mutual exclusion lock that protect malloc's data.
*********************************************************************/
__private_extern__ void
malloc_init(void)
{
    malloc_lock = mutex_alloc(0);
    malInited = 1;
}


/*********************************************************************
* malloc_reset()
*
* Walks through the list of VM-allocated regions, destroying them
* all. Any subsequent access by clients to allocated data will cause
* a segmentation fault.
*********************************************************************/
__private_extern__
void malloc_reset(void) {
 
    malloc_block *amem, *bmem;

 	mutex_lock(malloc_lock);
	
	amem = malAnchor.malFwd;				/* Get the first one */
	
	while(amem != &malAnchor) {				/* Go until we hit the anchor */
	
		bmem = amem->malFwd;				/* Next one */
 		kfree(amem->malActl, amem->malSize);		/* Toss it */
 		amem = bmem;					/* Skip to it */
	
	} 

	malAnchor.malFwd = (struct malloc_block	*) 0x666;	/* Cause a fault if we try again */
	malAnchor.malBwd = (struct malloc_block	*) 0x666;	/* Cause a fault if we try again */
	
	mutex_unlock(malloc_lock);				/* Unlock now */

	mutex_free(malloc_lock);
	
#ifdef MALLOC_RESET_GC
	/* Force garbage collection of zones, since we've thrashed through a lot of memory */
	zone_gc();
#endif

    return;

} /* malloc_reset() */


/*********************************************************************
* realloc()
*
* This function simply allocates a new block and copies the existing
* data into it. Nothing too clever here, as cleanup and efficient
* memory usage are not important in this allocator package.
*********************************************************************/
__private_extern__
void * realloc(void * address, size_t new_client_size) {
    void * new_address;
    malloc_block *amem;

	amem = (malloc_block *)((unsigned int)address - sizeof(malloc_block));	/* Point to allocation block */
	
	new_address = malloc(new_client_size);		/* get a new one */
	if(!new_address) {							/* Did we get it? */
		panic("realloc: can not reallocate one of %08X size\n", new_client_size);
	}
	
    memcpy(new_address, address, amem->malSize - sizeof(malloc_block));	/* Copy the old in */
    
    free(address);								/* Toss the old one */
	
    return new_address;

} /* realloc() */

#ifdef MALLOC_KLD_VM_ALLOCATE
#undef vm_allocate
#undef vm_deallocate

/*
 * Wrap vm_allocate calls made by kld in malloc/free so that the memory
 * is all released when we jettison kld.  Make other VM calls used by kld
 * no-op, since we don't need them.
 */
__private_extern__
kern_return_t vm_allocate(vm_map_t target_task, vm_address_t *address, vm_size_t size, int flags)
{
    assert(flags & VM_FLAGS_ANYWHERE);
    assert(target_task == kernel_map);

    *address = (vm_address_t)malloc(size);
    bzero(*address, size);

    return KERN_SUCCESS;
}

__private_extern__
kern_return_t vm_deallocate(vm_map_t target_task, vm_address_t address, vm_size_t size)
{
    free(address);
    return KERN_SUCCESS;
}

__private_extern__
kern_return_t vm_protect(vm_map_t target_task, vm_address_t address, vm_size_t size, boolean_t set_maximum, vm_prot_t new_protection)
{
    return KERN_SUCCESS;
}

__private_extern__
kern_return_t vm_msync(vm_map_t target_task, vm_address_t address, vm_size_t size, vm_sync_t sync_flags)
{
    return KERN_SUCCESS;
}
#endif