kernel/core/mm/usermem.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2009  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   4  *  Copyright (C) 2010  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   5  *
   6  *  This program is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20
  21 #include <system.h>
  22 #include <string.h>
  23 #include <build.h>
  24 #include <config.h>
  25 #include <mutex.h>
  26 #include <errno.h>
  27
  28 #define UMEM_HEAP_ADDR          0x800000        // MEMORY HEAP is placed at 8MB address
  29 #define UMEM_MALLOC_MAGIC       0xebc9          // MALLOC STRUCTURE signature
  30
  31 #define UMEM_MALLOC_STATE_FREE  0xaa            // MEMORY is FREE at moment
  32 #define UMEM_MALLOC_STATE_USED  0xcc            // MEMORY is USED at moment
  33
  34 typedef struct {
  35         unsigned short magic;
  36         unsigned char state;
  37         void *next;
  38         proc_t *proc;
  39 } __attribute__ ((__packed__)) malloc_t;
  40
  41 typedef struct {
  42         void *addr;             /* heap structure is covered by own heap structure address */
  43         void *first;            /* first malloc structure */
  44         void *last;             /* last malloc structure - usefully for calculate memory usage */
  45         void *curr;             /* current malloc structure */
  46 } __attribute__ ((__packed__)) heap_t;
  47
  48 static heap_t *heap;                    /* heap structure of memory */
  49 static MUTEX_CREATE (mutex_umalloc);
  50 static MUTEX_CREATE (mutex_ufree);
  51
  52 void *umalloc (proc_t *proc, size_t size)
  53 {
  54         if (!size)
  55                 return 0;
  56
  57         mutex_lock (&mutex_umalloc);
  58
  59         unsigned malloc_len = sizeof (malloc_t);                /* check malloc structure size */
  60         unsigned need_alloc = 0;
  61
  62         /* let's find new or free malloc structure in memory */
  63         malloc_t *malloc = (malloc_t *) heap->first;
  64
  65         while (1) {
  66                 //DPRINT (DBG_MM | DBG_UMEM, "malloc: 0x%x\n", malloc);
  67
  68                 if (!malloc) {
  69                         DPRINT (DBG_MM | DBG_UMEM, "!malloc");
  70                         need_alloc = 1;
  71                         break;
  72                 }
  73
  74                 if (malloc->magic != UMEM_MALLOC_MAGIC) {
  75                         DPRINT (DBG_MM | DBG_UMEM, "malloc->magic != UMEM_MALLOC_MAGIC");
  76                         need_alloc = 1;
  77                         break;
  78                 }
  79
  80                 if (malloc->state == UMEM_MALLOC_STATE_USED) {  /* It's OK */
  81                         DPRINT (DBG_MM | DBG_UMEM, "malloc->state == UMEM_MALLOC_STATE_USED");
  82                         //need_alloc = 1;
  83                         malloc = (malloc_t *) malloc->next;
  84                         continue;
  85                 }
  86
  87                 /* we've found FREE memory block, at moment it is not used */
  88                 if (malloc->state == UMEM_MALLOC_STATE_FREE) {
  89                         /* read next malloc structure, right behind free block */
  90                         malloc_t *next = (malloc_t *) malloc;
  91
  92                         DPRINT (DBG_MM | DBG_UMEM, "malloc->state == UMEM_MALLOC_STATE_FREE");
  93
  94                         for (;;) {
  95                                 next = (malloc_t *) next->next;
  96
  97                                 if (next->magic != UMEM_MALLOC_MAGIC) {
  98                                         DPRINT (DBG_MM | DBG_UMEM, "2: next->magic != UMEM_MALLOC_MAGIC");
  99                                         break;
 100                                 }
 101
 102                                 if ((unsigned) ((void *) malloc + malloc_len + size) <= (unsigned) next) {
 103                                         //kprintf ("Je mensi\n");
 104                                         break;
 105                                 } else {
 106                                         if (next->state == UMEM_MALLOC_STATE_USED)
 107                                                 need_alloc = 1;
 108                                 }
 109                                 if (next->state == UMEM_MALLOC_STATE_USED)
 110                                         break;
 111
 112                                 if (next->state != UMEM_MALLOC_STATE_FREE)
 113                                         break;
 114                         }
 115
 116                         /*if (need_alloc)
 117                                 break;
 118
 119                         unsigned diff = (unsigned) ((void *) next - (void *) malloc);
 120
 121                         DPRINT (DBG_MM | DBG_UMEM, "diff: %d", diff);
 122
 123                         if (diff < size) {
 124                                 malloc = (malloc_t *) malloc->next;
 125                                 continue;
 126                         }*/
 127
 128                         break;
 129                 }
 130
 131                 malloc = (malloc_t *) malloc->next;
 132         }
 133
 134         if (need_alloc) {
 135                 /* when old malloc structures are full, let's grab new block of memory */
 136                 malloc = heap->curr;
 137
 138                 malloc->magic = UMEM_MALLOC_MAGIC;
 139
 140                 malloc->next = (void *) ((void *) malloc + malloc_len + size);
 141
 142                 heap->curr = malloc->next;
 143         }
 144
 145         malloc->state = UMEM_MALLOC_STATE_USED;
 146
 147         malloc->proc = proc;
 148
 149         /* calculate size of process image (binary file) */
 150         unsigned p = (unsigned) palign ((void *) (proc->end - proc->start));
 151
 152         /* save last malloc structure pointer to heap */
 153         if ((unsigned) heap->curr > (unsigned) heap->last)
 154                 heap->last = heap->curr;
 155
 156         unsigned l;
 157         unsigned s = proc->heap;
 158         for (l = s; l < (unsigned) ((char *) malloc + malloc_len + size); l += 0x1000) {
 159 #ifdef ARCH_i386
 160                 page_mmap (proc->task->page_cover, (void *) proc->heap+p, (void *) proc->heap+p + 0x1000, 0, 1);
 161 #endif
 162                 //kprintf ("OD: 0x%x DO: 0x%x | 0x%x | 0x%x\n", (void *) proc->heap + p, (void *) proc->heap + 0x1000 + p, s, size);
 163                 proc->heap += 0x1000;
 164         }
 165
 166         mutex_unlock (&mutex_umalloc);
 167
 168         return (void *) ((void *) malloc + malloc_len + p);
 169 }
 170
 171 void ufree (proc_t *proc, void *ptr)
 172 {
 173         if (!ptr || !proc)
 174                 return;
 175
 176         mutex_lock (&mutex_ufree);
 177
 178         /* calculate size of process image (binary file) */
 179         unsigned p = (unsigned) palign ((void *) (proc->end - proc->start));
 180
 181         /* we need find malloc structure - it could be risk working with lower memory address */
 182         malloc_t *malloc = (void *) ((void *) ptr - sizeof (malloc_t) - p);
 183
 184         /* check malloc signature, when not agree, ptr pointing to wrong memory address */
 185         if (malloc->magic != UMEM_MALLOC_MAGIC) {
 186                 kprintf ("free: malloc->magic != UMEM_MALLOC_MAGIC\n");
 187                 goto end;
 188         }
 189
 190         /* is this memory block our ? */
 191         if (malloc->proc != proc) {
 192                 kprintf ("free: malloc->proc != proc\n");
 193                 goto end;
 194         }
 195
 196         if (malloc->state == UMEM_MALLOC_STATE_FREE) {
 197                 kprintf ("kfree () - memory is FREE - double free !\n");
 198                 goto end;
 199         }
 200
 201         if (malloc->state != UMEM_MALLOC_STATE_USED) {
 202                 kprintf ("malloc->state != UMEM_MALLOC_STATE_USED\n");
 203                 goto end;
 204         }
 205
 206         /* match malloc as FREE */
 207         malloc->state = UMEM_MALLOC_STATE_FREE;
 208
 209 end:
 210         mutex_unlock (&mutex_ufree);
 211 }
 212
 213 void *urealloc (proc_t *proc, void *ptr, size_t size)
 214 {
 215         if (!proc)
 216                 return 0;
 217
 218         if (!ptr)
 219                 return umalloc (proc, size);
 220
 221         if (!size) {
 222                 ufree (proc, ptr);
 223                 return 0;
 224         }
 225
 226         /* calculate size of process image (binary file) */
 227         unsigned p = (unsigned) palign ((void *) (proc->end - proc->start));
 228
 229         /* we need find malloc structure - it could be risk working with lower memory address */
 230         malloc_t *malloc = (void *) ((char *) ptr - sizeof (malloc_t) - p);
 231
 232         /* check malloc signature, when not agree, ptr pointing to wrong memory address */
 233         if (malloc->magic != UMEM_MALLOC_MAGIC) {
 234                 kprintf ("urealloc: malloc->magic != UMEM_MALLOC_MAGIC\n");
 235                 return 0;
 236         }
 237
 238         int s = (int) (malloc->next - ptr) + p;
 239 printf ("s: %d : %d\n", s, size);
 240         if (s >= size)
 241                 return 0;
 242
 243         char *ptr_new = umalloc (proc, size);
 244 printf ("s: ptr_new: 0x%x\n", ptr_new);
 245         if (!ptr_new) {
 246                 ufree (proc, ptr);
 247                 errno_set (ENOMEM);
 248                 return 0;
 249         }
 250
 251         /* copy old memory block to new one (-p because ptr and ptr_new got virtual mapped address) */
 252         memcpy (ptr_new - p, ptr - p, s);
 253
 254         ufree (proc, ptr);
 255
 256         return ptr_new;
 257 }
 258
 259 /* free all memory blocks allocated by process */
 260 unsigned ufree_proc (proc_t *proc)
 261 {
 262 #ifndef ARCH_arm
 263         paging_disable ();
 264 #endif
 265         unsigned used = 0;
 266         malloc_t *malloc;
 267
 268         for (malloc = (malloc_t *) heap->first; malloc->magic == UMEM_MALLOC_MAGIC; malloc = (malloc_t *) malloc->next)
 269                 if (malloc->proc == proc)
 270                         if (malloc->state == UMEM_MALLOC_STATE_USED)
 271                                 malloc->state = UMEM_MALLOC_STATE_FREE;
 272 #ifndef ARCH_arm
 273         paging_enable ();
 274 #endif
 275         return used;
 276 }
 277
 278 /* calculate used memory by process */
 279 unsigned umem_used_proc (proc_t *proc)
 280 {
 281 #ifndef ARCH_arm
 282         paging_disable ();
 283 #endif
 284         unsigned used = 0;
 285         malloc_t *malloc;
 286
 287         for (malloc = (malloc_t *) heap->first; malloc->magic == UMEM_MALLOC_MAGIC; malloc = (malloc_t *) malloc->next)
 288                 if (malloc->proc == proc)
 289                         if (malloc->state == UMEM_MALLOC_STATE_USED)
 290                                 used += (int) ((unsigned) malloc->next - (unsigned) malloc);
 291 #ifndef ARCH_arm
 292         paging_enable ();
 293 #endif
 294         return used;
 295 }
 296
 297 /* calculate used memory from all apps */
 298 unsigned umem_used ()
 299 {
 300 #ifndef ARCH_arm
 301         paging_disable ();
 302 #endif
 303         unsigned used = 0;
 304         malloc_t *malloc;
 305
 306         for (malloc = (malloc_t *) heap->first; malloc->magic == UMEM_MALLOC_MAGIC; malloc = (malloc_t *) malloc->next)
 307                 if (malloc->state == UMEM_MALLOC_STATE_USED)
 308                         used += (int) ((unsigned) malloc->next - (unsigned) malloc);
 309 #ifndef ARCH_arm
 310         paging_enable ();
 311 #endif
 312         return used;
 313 }
 314
 315 unsigned umem_init ()
 316 {
 317         heap = (heap_t *) UMEM_HEAP_ADDR;
 318
 319         /* we rather clear heap structure */
 320         heap->addr = (void *) heap;
 321         heap->first = (void *) ((void *) heap + sizeof (heap_t));       /* first malloc structure should be right behind heap structure */
 322         heap->last = heap->first;                                       /* last malloc structure - it is first at init */
 323         heap->curr = heap->first;                                       /* point to first malloc structure - well, it is clear and not used yet */
 324
 325         return 1;
 326 }