---

Kernel Memory Allocator
[Memory Manager]

Data Structures
struct	MEM_BLOCK
	A memory block structure. More...
Defines
#define	M_MAGIC   ((dword)"$MB$")
	Magic number to identify a memory block.
#define	M_FREE   0
	Free block.
#define	M_ALLOC   1
	Allocated block.
Typedefs
typedef MEM_BLOCK	mem_block_t
	A memory block structure.
Functions
void	kmalloc_init ()
	Initialize the kernel virtual memory area.
void *	kmalloc (dword size)
void	kfree (void *ptr)
	Frees the memory space pointed by ptr, which must have been returned by a previous call to kmalloc(size_t size). Parameters: ptr  The pointer you want to free.
int	mem_sizeof (void *ptr)
	Return the size of the pointer ptr passed as argument. Parameters: ptr  The pointer you want to know the size. Exceptions: NULL  Invalid pointer ptr. Returns: The size of the pointer ptr passed as argument.
void *	kmemalign (size_t alignment, size_t size)
	Allocate some memory aligned to a boundary. Parameters: alignment  The boundary. size  The size you want to allocate. Exceptions: NULL  Out-of-memory. Returns: A pointer to a memory area aligned to the boundary. The pointer is a aligned_mem_block_t pointer, so if you want to access to the data area of this pointer you must specify the p->start filed. Note: Use kfree(void *ptr) to free the allocated block.

---

Detailed Description

The memory operators for the kernel.

---

Define Documentation

#define M_ALLOC   1

Allocated block. Definition at line 24 of file kmalloc.h.

#define M_FREE   0

Free block. Definition at line 22 of file kmalloc.h.

#define M_MAGIC   ((dword)"$MB$")

Magic number to identify a memory block. Definition at line 20 of file kmalloc.h.

---

Typedef Documentation

typedef struct MEM_BLOCK mem_block_t

A memory block structure.

---

Function Documentation

void kfree (  void *    ptr )

Frees the memory space pointed by ptr, which must have been returned by a previous call to kmalloc(size_t size). Parameters: ptr  The pointer you want to free. Definition at line 223 of file kmalloc.c. { mem_block_t *p, *p2; dword IF = GET_IF(); if (ptr == NULL) return; disable(); // Point to the header // p = (void *)ptr - sizeof(mem_block_t); if (p->magic != M_MAGIC) return; // Is the process crazy?! :) // if (p->flags != M_ALLOC) return; // Crazy again?! :) // // Free the block // p->flags = M_FREE; p->owner = NULL; // Try to combine the block wih the next one... // p2 = (void *)p + p->size + sizeof(mem_block_t); if (p2 < (mem_block_t *)K_HEAP_END) if (p2->flags == M_FREE) { // Let's merge the two blocks! // p->size += p2->size + sizeof(mem_block_t); p2->magic = NULL; } // Try to combine the block with the previous one... // if (p != (mem_block_t *)K_HEAP_START) { // Find the previous block // p2 = (void *)K_HEAP_START; for(;;) { if (((void *)p2 + p2->size + sizeof(mem_block_t)) == p) { // Block found! // // Check if it's a free block // if (p2->flags == M_FREE) { // Let's merge the two blocks! // p2->size += (p->size + sizeof(mem_block_t)); p->magic = NULL; p = p2; } break; } p2 = (void *)p2 + p2->size + sizeof(mem_block_t); } } // Release the physical space occupied by the block // deallocate(p); SET_IF(IF); }

void* kmalloc (  dword    size )

void kmalloc_init (    )

Initialize the kernel virtual memory area. Definition at line 22 of file kmalloc.c. { mem_block_t *p; // Create only one hudge block // p = (mem_block_t *)K_HEAP_START; p->magic = M_MAGIC; p->flags = M_FREE; p->size = K_HEAP_END - K_HEAP_START - sizeof(mem_block_t); p->owner = NULL; }

void* kmemalign (  size_t    alignment, size_t    size )

Allocate some memory aligned to a boundary. Parameters: alignment  The boundary. size  The size you want to allocate. Exceptions: NULL  Out-of-memory. Returns: A pointer to a memory area aligned to the boundary. The pointer is a aligned_mem_block_t pointer, so if you want to access to the data area of this pointer you must specify the p->start filed. Note: Use kfree(void *ptr) to free the allocated block. Definition at line 308 of file kmalloc.c. { mem_block_t *p, *p2; dword IF = GET_IF(); // Cannot allocate memory with a size of zero // if ( !size ) return(NULL); // Allocate the pointer // p = kmalloc(size + alignment + 2*sizeof(mem_block_t)); if ( p == NULL ) return(NULL); // An alignment of zero is intended as a simple kmalloc(size) // if ( alignment == 0 ) { return(p); } // Check if the pointer is correcly aligned // if ( (size_t)(p) % alignment ) { // Align the pointer p to the boundary. // disable(); // Allocate the new block // p2 = p + 2; p2 = (mem_block_t *)ALIGN_UP((size_t)p2, alignment) - 1; p2->magic = M_MAGIC; p2->flags = (p-1)->flags; p2->owner = (p-1)->owner; p2->size = mem_sizeof(p) - ((size_t)(p2+1) - (size_t)p); // Free the unused space // (p-1)->size = (size_t)p2 - (size_t)p; kfree(p); SET_IF(IF); return(p2+1); } else // The pointer p is already aligned to the boudary // return(p); }

int mem_sizeof (  void *    ptr )

Return the size of the pointer ptr passed as argument. Parameters: ptr  The pointer you want to know the size. Exceptions: NULL  Invalid pointer ptr. Returns: The size of the pointer ptr passed as argument. Definition at line 287 of file kmalloc.c. { // Return the size of the pointer "ptr", or NULL if an error occurs // mem_block_t *p = ((mem_block_t *)ptr-1); if ( (p->magic == M_MAGIC) && (p->flags == M_ALLOC) ) return( p->size ); else return(NULL); }

---