memory/heap.c

   1 static char RCSId[] = "$Id: heap.c,v 1.3 1993/07/04 04:04:21 root Exp root $";
   2 static char Copyright[] = "Copyright  Robert J. Amstadt, 1993";
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include "prototypes.h"
   8 #include "segmem.h"
   9 #include "heap.h"
  10 #include "regfunc.h"
  11
  12 /* #define DEBUG_HEAP */
  13
  14 LHEAP *LocalHeaps = NULL;
  15
  16 /**********************************************************************
  17  *                                      HEAP_Init
  18  */
  19 void
  20 HEAP_Init(MDESC **free_list, void *start, int length)
  21 {
  22     if (length < 2 * sizeof(MDESC))
  23         return;
  24
  25     *free_list = (MDESC *) start;
  26     (*free_list)->prev = NULL;
  27     (*free_list)->next = NULL;
  28     (*free_list)->length = length - sizeof(MDESC);
  29 }
  30
  31 /**********************************************************************
  32  *                                      HEAP_Alloc
  33  */
  34 void *
  35 HEAP_Alloc(MDESC **free_list, int flags, int bytes)
  36 {
  37     MDESC *m, *m_new;
  38
  39 #ifdef DEBUG_HEAP
  40     printf("HeapAlloc: free_list %08x, flags %x, bytes %d\n",
  41            free_list, flags, bytes);
  42 #endif
  43
  44     /*
  45      * Find free block big enough.
  46      */
  47     for (m = *free_list; m != NULL; m = m->next)
  48     {
  49         if (m->length >= bytes && m->length < bytes + 4 * sizeof(MDESC))
  50         {
  51             break;
  52         }
  53         else if (m->length > bytes)
  54         {
  55             m_new = m + (bytes / sizeof(MDESC)) + 2;
  56             if (m->prev == NULL)
  57                 *free_list = m_new;
  58             else
  59                 m->prev->next = m_new;
  60
  61             if (m->next != NULL)
  62                 m->next->prev = m_new;
  63
  64             m_new->next = m->next;
  65             m_new->prev = m->prev;
  66             m_new->length = m->length - ((int) m_new - (int) m);
  67             m->length -= (m_new->length + sizeof(MDESC));
  68
  69             m->prev = m;
  70             m->next = m;
  71             m->lock = 0;
  72             m->flags = 0;
  73             if (flags & GLOBAL_FLAGS_ZEROINIT)
  74                 memset(m + 1, 0, bytes);
  75 #ifdef DEBUG_HEAP
  76             printf("HeapAlloc: returning %08x\n", (m + 1));
  77 #endif
  78             return (void *) (m + 1);
  79         }
  80     }
  81
  82     if (m != NULL)
  83     {
  84         if (m->prev == NULL)
  85             *free_list = m->next;
  86         else
  87             m->prev->next = m->next;
  88
  89         if (m->next != NULL)
  90             m->next->prev = m->prev;
  91
  92         m->prev = m;
  93         m->next = m;
  94         m->lock = 0;
  95         m->flags = 0;
  96         if (flags & GLOBAL_FLAGS_ZEROINIT)
  97             memset(m + 1, 0, bytes);
  98 #ifdef DEBUG_HEAP
  99         printf("HeapAlloc: returning %08x\n", (m + 1));
 100 #endif
 101         return (void *) (m + 1);
 102     }
 103
 104 #ifdef DEBUG_HEAP
 105     printf("HeapAlloc: returning %08x\n", 0);
 106 #endif
 107     return 0;
 108 }
 109 \f
 110 /**********************************************************************
 111  *                                      HEAP_ReAlloc
 112  */
 113 void *
 114 HEAP_ReAlloc(MDESC **free_list, void *old_block,
 115              int new_size, unsigned int flags)
 116 {
 117     MDESC *m_free;
 118     MDESC *m;
 119
 120     /*
 121      * Check validity of block
 122      */
 123     m = (MDESC *) old_block - 1;
 124     if (m->prev != m || m->next != m ||
 125         ((int) m & 0xffff0000) != ((int) *free_list & 0xffff0000))
 126     {
 127 #ifdef DEBUG_HEAP
 128         printf("Attempt to resize bad pointer, m = %08x, *free_list = %08x\n",
 129                m, free_list);
 130 #endif
 131         return NULL;
 132     }
 133
 134     /*
 135      * Check for grow block
 136      */
 137     if (new_size > m->length)
 138     {
 139         m_free = m + 1 + m->length / sizeof(MDESC);
 140         if (m_free->next == m_free ||
 141             m_free->prev == m_free ||
 142             m_free->length + sizeof(MDESC) < new_size)
 143         {
 144             void *new_p = HEAP_Alloc(free_list, flags, new_size);
 145
 146             if (new_p ==NULL)
 147                 return NULL;
 148             memcpy(new_p, old_block, m->length);
 149             HEAP_Free(free_list, old_block);
 150             return new_p;
 151         }
 152
 153         if (m_free->prev == NULL)
 154             *free_list = m_free->next;
 155         else
 156             m_free->prev->next = m_free->next;
 157
 158         if (m_free->next != NULL)
 159             m_free->next->prev = m_free->prev;
 160
 161         m->length += sizeof(MDESC) + m_free->length;
 162         if (flags & GLOBAL_FLAGS_ZEROINIT)
 163             memset(m_free, '\0', sizeof(MDESC) + m_free->length);
 164     }
 165
 166     /*
 167      * Check for shrink block.
 168      */
 169     if (new_size < m->length - 4 * sizeof(MDESC))
 170     {
 171         m_free = m + new_size / sizeof(MDESC) + 2;
 172         m_free->next = m_free;
 173         m_free->prev = m_free;
 174         m_free->length = m->length - (int) m_free - (int) m;
 175         m->length = (int) m_free - (int) (m + 1);
 176         HEAP_Free(free_list, m_free + 1);
 177     }
 178
 179     return old_block;
 180 }
 181
 182 \f
 183 /**********************************************************************
 184  *                                      HEAP_Free
 185  */
 186 int
 187 HEAP_Free(MDESC **free_list, void *block)
 188 {
 189     MDESC *m_free;
 190     MDESC *m;
 191     MDESC *m_prev;
 192
 193     /*
 194      * Validate pointer.
 195      */
 196     m_free = (MDESC *) block - 1;
 197     if (m_free->prev != m_free || m_free->next != m_free ||
 198         ((int) m_free & 0xffff0000) != ((int) *free_list & 0xffff0000))
 199     {
 200 #ifdef DEBUG_HEAP
 201         printf("Attempt to free bad pointer,"
 202                "m_free = %08x, *free_list = %08x\n",
 203                m_free, free_list);
 204 #endif
 205         return -1;
 206     }
 207
 208     /*
 209      * Find location in free list.
 210      */
 211     m_prev = NULL;
 212     for (m = *free_list; m != NULL && m < m_free; m = m->next)
 213         m_prev = m;
 214
 215     if (m_prev != NULL && (int) m_prev + m_prev->length > (int) m_free)
 216     {
 217 #ifdef DEBUG_HEAP
 218         printf("Attempt to free bad pointer,"
 219                "m_free = %08x, m_prev = %08x (length %x)\n",
 220                m_free, m_prev, m_prev->length);
 221 #endif
 222         return -1;
 223     }
 224
 225     if ((m != NULL && (int) m_free + m_free->length > (int) m) ||
 226         (int) m_free + m_free->length > ((int) m_free | 0xffff))
 227     {
 228 #ifdef DEBUG_HEAP
 229         printf("Attempt to free bad pointer,"
 230                "m_free = %08x (length %x), m = %08x\n",
 231                m_free, m_free->length, m);
 232 #endif
 233         return -1;
 234     }
 235
 236     /*
 237      * Put block back in free list.
 238      * Does it merge with the previos block?
 239      */
 240     if (m_prev != NULL)
 241     {
 242         if ((int) m_prev + m_prev->length == (int) m_free)
 243         {
 244             m_prev->length += sizeof(MDESC) + m_free->length;
 245             m_free = m_prev;
 246         }
 247         else
 248         {
 249             m_prev->next = m_free;
 250             m_free->prev = m_prev;
 251         }
 252     }
 253     else
 254     {
 255         *free_list = m_free;
 256         m_free->prev = NULL;
 257     }
 258
 259     /*
 260      * Does it merge with the next block?
 261      */
 262     if (m != NULL)
 263     {
 264         if ((int) m_free + m_free->length == (int) m)
 265         {
 266             m_free->length += sizeof(MDESC) + m->length;
 267             m_free->next = m->next;
 268         }
 269         else
 270         {
 271             m->prev = m_free;
 272             m_free->next = m;
 273         }
 274     }
 275     else
 276     {
 277         m_free->next = NULL;
 278     }
 279
 280     return 0;
 281 }
 282
 283 /**********************************************************************
 284  *                                      HEAP_LocalFindHeap
 285  */
 286 LHEAP *
 287 HEAP_LocalFindHeap(unsigned short owner)
 288 {
 289     LHEAP *lh;
 290
 291 #ifdef DEBUG_HEAP
 292     printf("HEAP_LocalFindHeap: owner %04x\n", owner);
 293 #endif
 294
 295     for (lh = LocalHeaps; lh != NULL; lh = lh->next)
 296     {
 297         if (lh->selector == owner)
 298             return lh;
 299     }
 300
 301     return NULL;
 302 }
 303
 304 /**********************************************************************
 305  *                                      HEAP_LocalInit
 306  */
 307 void
 308 HEAP_LocalInit(unsigned short owner, void *start, int length)
 309 {
 310     LHEAP *lh;
 311
 312 #ifdef DEBUG_HEAP
 313     printf("HEAP_LocalInit: owner %04x, start %08x, length %04x\n",
 314            owner, start, length);
 315 #endif
 316
 317     if (length < 2 * sizeof(MDESC))
 318         return;
 319
 320     lh = (LHEAP *) malloc(sizeof(*lh));
 321     if (lh == NULL)
 322         return;
 323
 324     lh->next        = LocalHeaps;
 325     lh->selector    = owner;
 326     lh->local_table = NULL;
 327     HEAP_Init(&lh->free_list, start, length);
 328     LocalHeaps = lh;
 329 }
 330
 331 /**********************************************************************
 332  *                                      WIN16_LocalAlloc
 333  */
 334 void *
 335 WIN16_LocalAlloc(int flags, int bytes)
 336 {
 337     void *m;
 338
 339 #ifdef DEBUG_HEAP
 340     printf("WIN16_LocalAlloc: flags %x, bytes %d\n", flags, bytes);
 341     printf("    called from segment %04x\n", Stack16Frame[11]);
 342 #endif
 343
 344     m = HEAP_Alloc(LOCALHEAP(), flags, bytes);
 345
 346 #ifdef DEBUG_HEAP
 347         printf("WIN16_LocalAlloc: returning %x\n", (int) m);
 348 #endif
 349     return m;
 350 }
 351
 352 /**********************************************************************
 353  *                                      WIN16_LocalCompact
 354  */
 355 int
 356 WIN16_LocalCompact(int min_free)
 357 {
 358     MDESC *m;
 359     int max_block;
 360
 361     max_block = 0;
 362     for (m = *LOCALHEAP(); m != NULL; m = m->next)
 363         if (m->length > max_block)
 364             max_block = m->length;
 365
 366     return max_block;
 367 }
 368
 369 /**********************************************************************
 370  *                                      WIN16_LocalFlags
 371  */
 372 unsigned int
 373 WIN16_LocalFlags(unsigned int handle)
 374 {
 375     MDESC *m;
 376
 377     m = (MDESC *) (((int) *LOCALHEAP() & 0xffff0000) |
 378                    (handle & 0xffff)) - 1;
 379     if (m->next != m || m->prev != m)
 380         return 0;
 381
 382     return m->lock;
 383 }
 384
 385 /**********************************************************************
 386  *                                      WIN16_LocalFree
 387  */
 388 unsigned int
 389 WIN16_LocalFree(unsigned int handle)
 390 {
 391     unsigned int addr;
 392
 393     addr = ((int) *LOCALHEAP() & 0xffff0000) | (handle & 0xffff);
 394     if (HEAP_Free(LOCALHEAP(), (void *) addr) < 0)
 395         return handle;
 396     else
 397         return 0;
 398 }
 399
 400 /**********************************************************************
 401  *                                      WIN16_LocalInit
 402  */
 403 unsigned int
 404 WIN16_LocalInit(unsigned int segment, unsigned int start, unsigned int end)
 405 {
 406     unsigned short owner = HEAP_OWNER;
 407     LHEAP *lh = HEAP_LocalFindHeap(owner);
 408
 409     if (segment == 0)
 410     {
 411         /* Get current DS */
 412         segment = Stack16Frame[6];
 413     }
 414
 415     if (lh == NULL)
 416     {
 417         HEAP_LocalInit(owner,
 418                        (void *) ((segment << 16) | start), end - start + 1);
 419     }
 420     else
 421     {
 422         HEAP_Init(&lh->free_list,
 423                   (void *) ((segment << 16) | start), end - start + 1);
 424     }
 425
 426     return segment;
 427 }
 428
 429 /**********************************************************************
 430  *                                      WIN16_LocalLock
 431  */
 432 void *
 433 WIN16_LocalLock(unsigned int handle)
 434 {
 435     MDESC *m;
 436
 437     m = (MDESC *) (((int) *LOCALHEAP() & 0xffff0000) |
 438                    (handle & 0xffff)) - 1;
 439     if (m->next != m || m->prev != m)
 440         return 0;
 441
 442     m->lock++;
 443     return (void *) (m + 1);
 444 }
 445
 446 /**********************************************************************
 447  *                                      WIN16_LocalReAlloc
 448  */
 449 void *
 450 WIN16_LocalReAlloc(unsigned int handle, int flags, int bytes)
 451 {
 452     void *m;
 453
 454     m = HEAP_ReAlloc(LOCALHEAP(), (void *)
 455                      (((int) *LOCALHEAP() & 0xffff0000) | (handle & 0xffff)),
 456                      bytes, flags);
 457
 458     return m;
 459 }
 460
 461 /**********************************************************************
 462  *                                      WIN16_LocalSize
 463  */
 464 unsigned int
 465 WIN16_LocalSize(unsigned int handle)
 466 {
 467     MDESC *m;
 468
 469     m = (MDESC *) (((int) *LOCALHEAP() & 0xffff0000) |
 470                    (handle & 0xffff)) - 1;
 471     if (m->next != m || m->prev != m)
 472         return 0;
 473
 474     return m->length;
 475 }
 476
 477 /**********************************************************************
 478  *                                      WIN16_LocalUnlock
 479  */
 480 unsigned int
 481 WIN16_LocalUnlock(unsigned int handle)
 482 {
 483     MDESC *m;
 484
 485     m = (MDESC *) (((int) *LOCALHEAP() & 0xffff0000) |
 486                    (handle & 0xffff)) - 1;
 487     if (m->next != m || m->prev != m)
 488         return 1;
 489
 490     if (m->lock > 0)
 491         m->lock--;
 492
 493     return 0;
 494 }
 495
 496 /**********************************************************************
 497  *                      GetFreeSystemResources (user.284)
 498
 499  */
 500 #define USERRESOURCES 2
 501 #define GDIRESOURCES 1
 502 #define SYSTEMRESOURCES 0
 503 #include <user.h>
 504 #include <gdi.h>
 505
 506 WORD GetFreeSystemResources(WORD SystemResourceType)
 507 {
 508   unsigned int GdiFree=0,GdiResult=0;
 509   unsigned int UserFree=0,UserResult=0;
 510   unsigned int result=0;
 511   MDESC *m;
 512
 513   printf("GetFreeSystemResources(%u)\n",SystemResourceType);
 514
 515   switch(SystemResourceType) {
 516     case(USERRESOURCES):
 517       for (m = USER_Heap; m != NULL; m = m->next) /* add up free area in heap */
 518          UserFree += m->length;
 519       result=(UserFree*100)/65516;  /* 65516 == 64K */
 520       break;
 521     case(GDIRESOURCES):
 522       for (m = GDI_Heap; m != NULL; m = m->next)
 523          GdiFree += m->length;
 524       result=(GdiFree*100)/65516;
 525       break;
 526     case(SYSTEMRESOURCES):
 527       for (m = USER_Heap; m != NULL; m = m->next)
 528          UserFree += m->length;
 529       UserResult=(UserFree*100)/65516;
 530       for (m = GDI_Heap; m != NULL; m = m->next)
 531          GdiFree += m->length;
 532       GdiResult=(GdiFree*100)/65516;
 533       result=(UserResult < GdiResult) ? UserResult:GdiResult;
 534       break;
 535     default:
 536       result=0;
 537       break;
 538   }
 539   return(result);
 540 }