---

umalloc.c File Reference

Virtual Memory Allocator for the User Space. More...

#include <const.h>
#include <arch/paging.h>
#include <kernel/task.h>
#include <kernel/video.h>
#include <kernel/umalloc.h>

Go to the source code of this file.

Functions
void	umalloc_init (size_t heap_start, size_t heap_size)
	Initialize the user virtual memory area. Parameters: heap_start  The start of the user heap. heap_size  The size of the user heap.
void *	umalloc (size_t size)
	Allocate a memory block from the user memory area. This is a best-fit like allocator. Parameters: size  The size of the block you want to allocate. Exceptions: NULL  Out-of-memory. Returns: A pointer to a memory area. Note: The memory area is not initialized when it's just allocated.
void	deallocate (umem_block_t *ptr)
	Try to release physical frames occupied by the freed block. Parameters: ptr  The pointer to deallocate.
void	ufree (void *ptr)
	Frees the memory space pointed by ptr, which must have been returned by a previous call to umalloc(size_t size). Parameters: ptr  The pointer you want to free.

---

Detailed Description

Virtual Memory Allocator for the User Space.

Author:

Andrea Righi <drizzt@inwind.it>

Date:

Last update: 2004-01-01

Note:

Copyright (©) 2003 Andrea Righi

Definition in file umalloc.c.

---

Function Documentation

void deallocate (  umem_block_t *    ptr )  [static]

Try to release physical frames occupied by the freed block. Parameters: ptr  The pointer to deallocate. Definition at line 127 of file umalloc.c. { size_t start = PAGE_ALIGN_UP((uint32_t)((void *)ptr + sizeof(umem_block_t))); size_t end = PAGE_ALIGN((uint32_t)((void *)ptr + sizeof(umem_block_t) + ptr->size)); while( start<end ) { if (*ADDR_TO_PDE(start) != NULL) { delete_page( start ); start += PAGE_SIZE; } else start = PAGE_DIR_ALIGN_UP( start ); } }

void ufree (  void *    ptr )

Frees the memory space pointed by ptr, which must have been returned by a previous call to umalloc(size_t size). Parameters: ptr  The pointer you want to free. Definition at line 150 of file umalloc.c. { task_t *t; umem_block_t *p, *p2; if (ptr == NULL) return; // Point to the header. p = (void *)ptr - sizeof(umem_block_t); if (p->magic != UM_MAGIC) return; // Is the process crazy?! :) if (p->flags != UM_ALLOC) return; // Crazy again?! :) // Get the current task structure. t = get_curr_task(); // Free the block. p->flags = UM_FREE; p->owner = NULL; // Try to combine the block wih the next one... p2 = (void *)p + p->size + sizeof(umem_block_t); if (p2 < (umem_block_t *)(t->heap_start + t->heap_size)) if (p2->flags == UM_FREE) { // Let's merge the two blocks! p->size += p2->size + sizeof(umem_block_t); p2->magic = NULL; } // Try to combine the block with the previous one... if (p != (umem_block_t *)(t->heap_start)) { // Find the previous block. p2 = (void *)(t->heap_start); for(;;) { if (((void *)p2 + p2->size + sizeof(umem_block_t)) == p) { // Block found! // Check if it's a free block. if (p2->flags == UM_FREE) { // Let's merge the two blocks! p2->size += (p->size + sizeof(umem_block_t)); p->magic = NULL; p = p2; } break; } p2 = (void *)p2 + p2->size + sizeof(umem_block_t); } } // Release the physical space occupied by the block. deallocate( p ); }

void* umalloc (  size_t    size )

Allocate a memory block from the user memory area. This is a best-fit like allocator. Parameters: size  The size of the block you want to allocate. Exceptions: NULL  Out-of-memory. Returns: A pointer to a memory area. Note: The memory area is not initialized when it's just allocated. Definition at line 48 of file umalloc.c. { task_t *t; umem_block_t *p, *p_best=NULL; if ( !size ) return( NULL ); // Is the process crazy?! :-) // Get the current task structure. t = get_curr_task(); // Round the size up to sizeof(umem_block_t); this is the unit // of allocation. size = ( size & -(sizeof(umem_block_t)) ) + sizeof(umem_block_t); // Explore the heap for the best-fit hole. p=(umem_block_t *)(t->heap_start); if( !p ) return( NULL ); while(p < (umem_block_t *)(t->heap_start + t->heap_size)) { // Find a free block. if (p->flags == UM_FREE) { // This block is free... let's proceed! if (p->size == size) { // Best fit block found! You're lucky! p_best = p; break; } if (p->size > size) { // The hole is bigger than size... // ...check if it's the best-fit hole! if (p_best==NULL) p_best = p; else if (p_best->size > p->size) p_best = p; } } // Examine the next memory block. p = (void *)p+p->size+sizeof(umem_block_t); } // Have you found a free block?! if (p_best == NULL) { // No free memory :( return( NULL ); } // Found, now allocate it! p_best->magic = UM_MAGIC; p_best->flags = UM_ALLOC; p_best->owner = get_pid(); if (p_best->size == size) { p_best = (void *)p_best + sizeof(umem_block_t); // The block cover the size perfectly. return( (void *)p_best ); } // Otherwise split the hole in two blocks. p = (void *)p_best + sizeof(umem_block_t) + size; p->magic = UM_MAGIC; p->flags = UM_FREE; p->size = p_best->size - size - sizeof(umem_block_t); p->owner = NULL; p_best->size = size; p_best = (void *)p_best + sizeof(umem_block_t); // Return the best-fit pointer. return ( (void *)p_best ); }

void umalloc_init (  size_t    heap_start, size_t    heap_size )

Initialize the user virtual memory area. Parameters: heap_start  The start of the user heap. heap_size  The size of the user heap. Definition at line 20 of file umalloc.c. { task_t *t; umem_block_t *p; t = get_curr_task(); if( t==NULL ) return; // Setup the heap in the task structure. t->heap_start = heap_start; t->heap_size = heap_size; // Create only one hudge block. p = (umem_block_t *)heap_start; p->magic = UM_MAGIC; p->flags = UM_FREE; p->size = heap_size - sizeof(umem_block_t); p->owner = NULL; }

---