libdb/uIP/memr.c

   1 #include <stdlib.h>
   2 #include <string.h>
   3
   4 #include "uip.h"
   5 #include "memr.h"
   6
   7 #if UIP_ERRORING == 1
   8 #include <stdio.h>
   9 #define UIP_ERROR(m) uip_log(__FILE__,__LINE__,m)
  10 #else
  11 #define UIP_ERROR(m)
  12 #endif /* UIP_ERRORING == 1 */
  13
  14 #define MIN_SIZE                                12
  15 #define SIZEOF_STRUCT_MEM               (sizeof(struct mem)+(((sizeof(struct mem)%MEM_ALIGNMENT)==0)?0:(4-(sizeof(struct mem)%MEM_ALIGNMENT))))
  16
  17 struct mem {
  18         u32 next,prev;
  19         u32 used;
  20 };
  21
  22 static struct mem *ram_free;
  23 static struct mem *ram_end;
  24 static u8 ram_block[sizeof(struct mem)+UIP_MEM_SIZE+MEM_ALIGNMENT];
  25
  26 static void plug_holes(struct mem *rmem)
  27 {
  28         struct mem *nmem;
  29         struct mem *pmem;
  30
  31         nmem = (struct mem*)&ram_block[rmem->next];
  32         if(rmem!=nmem && nmem->used==0 && (u8_t*)nmem!=(u8_t*)ram_end) {
  33                 if(ram_free==nmem) ram_free = rmem;
  34
  35                 rmem->next = nmem->next;
  36                 ((struct mem*)&ram_block[nmem->next])->prev = (u8_t*)rmem -     ram_block;
  37         }
  38
  39         pmem = (struct mem*)&ram_block[rmem->prev];
  40         if(pmem!=rmem && pmem->used==0) {
  41                 if(ram_free==rmem) ram_free = pmem;
  42                 pmem->next = rmem->next;
  43                 ((struct mem*)&ram_block[rmem->next])->prev = (u8_t*)pmem - ram_block;
  44         }
  45 }
  46
  47 void memr_init()
  48 {
  49         struct mem *rmem;
  50
  51         UIP_MEMSET(ram_block,0,UIP_MEM_SIZE);
  52         rmem = (struct mem*)ram_block;
  53         rmem->next = UIP_MEM_SIZE;
  54         rmem->prev = 0;
  55         rmem->used = 0;
  56
  57         ram_end = (struct mem*)&ram_block[UIP_MEM_SIZE];
  58         ram_end->used = 1;
  59         ram_end->prev = UIP_MEM_SIZE;
  60         ram_end->next = UIP_MEM_SIZE;
  61
  62         ram_free = (struct mem*)ram_block;
  63 }
  64
  65 void* memr_malloc(u32 size)
  66 {
  67         u32 ptr,ptr2;
  68         struct mem *rmem,*rmem2;
  69
  70         if(size==0) return NULL;
  71
  72         if(size%MEM_ALIGNMENT) size += MEM_ALIGNMENT - ((size+SIZEOF_STRUCT_MEM)%SIZEOF_STRUCT_MEM);
  73         if(size>UIP_MEM_SIZE) return NULL;
  74
  75         for(ptr = (u8_t*)ram_free - ram_block;ptr<UIP_MEM_SIZE;ptr=((struct mem*)&ram_block[ptr])->next) {
  76                 rmem = (struct mem*)&ram_block[ptr];
  77                 if(!rmem->used && rmem->next - (ptr + SIZEOF_STRUCT_MEM)>=size + SIZEOF_STRUCT_MEM) {
  78                         ptr2 = ptr + SIZEOF_STRUCT_MEM + size;
  79                         rmem2 = (struct mem*)&ram_block[ptr2];
  80
  81                         rmem2->prev = ptr;
  82                         rmem2->next = rmem->next;
  83                         rmem->next = ptr2;
  84                         if(rmem->next!=UIP_MEM_SIZE) ((struct mem*)&ram_block[rmem2->next])->prev = ptr2;
  85
  86                         rmem2->used = 0;
  87                         rmem->used = 1;
  88
  89                         if(rmem==ram_free) {
  90                                 while(ram_free->used && ram_free!=ram_end) ram_free = (struct mem*)&ram_block[ram_free->next];
  91                         }
  92
  93                         return (u8_t*)rmem+SIZEOF_STRUCT_MEM;
  94                 }
  95         }
  96         return NULL;
  97 }
  98
  99 void memr_free(void *ptr)
 100 {
 101         struct mem *rmem;
 102
 103         if(ptr==NULL) return;
 104         if((u8_t*)ptr<(u8_t*)ram_block || (u8_t*)ptr>=(u8_t*)ram_end) return;
 105
 106         rmem = (struct mem*)((u8_t*)ptr - SIZEOF_STRUCT_MEM);
 107         rmem->used = 0;
 108
 109         if(rmem<ram_free) ram_free = rmem;
 110
 111         plug_holes(rmem);
 112 }
 113
 114 void* memr_realloc(void *ptr,u32 newsize)
 115 {
 116         u32 size,ptr1,ptr2;
 117         struct mem *rmem,*rmem2;
 118
 119         if(newsize%MEM_ALIGNMENT) newsize += MEM_ALIGNMENT - ((newsize + SIZEOF_STRUCT_MEM)%MEM_ALIGNMENT);
 120         if(newsize>UIP_MEM_SIZE) return NULL;
 121         if((u8_t*)ptr<(u8_t*)ram_block || (u8_t*)ptr>=(u8_t*)ram_end) {
 122                 UIP_ERROR("memr_realloc: illegal memory.\n");
 123                 return ptr;
 124         }
 125         rmem = (struct mem*)((u8_t*)ptr - SIZEOF_STRUCT_MEM);
 126         ptr1 = (u8_t*)rmem - ram_block;
 127         size = rmem->next - ptr1 - SIZEOF_STRUCT_MEM;
 128
 129         if(newsize+SIZEOF_STRUCT_MEM+MIN_SIZE<size) {
 130                 ptr2 = ptr1 + SIZEOF_STRUCT_MEM + newsize;
 131                 rmem2 = (struct mem*)&ram_block[ptr2];
 132                 rmem2->used = 0;
 133                 rmem2->next = rmem->next;
 134                 rmem2->prev = ptr1;
 135                 rmem->next = ptr2;
 136                 if(rmem2->next!=UIP_MEM_SIZE) ((struct mem*)&ram_block[rmem2->next])->prev = ptr2;
 137
 138                 plug_holes(rmem2);
 139         }
 140
 141         return ptr;
 142 }
 143
 144 void* memr_reallocm(void *ptr,u32 newsize)
 145 {
 146         void *nmem;
 147
 148         nmem = memr_malloc(newsize);
 149         if(nmem==NULL) return memr_realloc(ptr,newsize);
 150
 151         UIP_MEMCPY(nmem,ptr,newsize);
 152         memr_free(ptr);
 153
 154         return nmem;
 155 }