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      * Check validity of block
 121      */
 122     m = (MDESC *) old_block - 1;
 123 #ifdef DEBUG_HEAP
 124         printf("HEAP_ReAlloc new_size=%d !\n", new_size);
 125         printf("HEAP_ReAlloc old_block=%08X !\n", old_block);
 126         printf("HEAP_ReAlloc m=%08X free_list=%08X !\n", m, free_list);
 127         printf("HEAP_ReAlloc m->prev=%08X !\n", m->prev);
 128         printf("HEAP_ReAlloc m->next=%08X !\n", m->next);
 129         printf("HEAP_ReAlloc *free_list=%08X !\n", *free_list);
 130 #endif
 131         if (m->prev != m || m->next != m ||
 132         ((int) m & 0xffff0000) != ((int) *free_list & 0xffff0000))
 133     {
 134         printf("Attempt to resize bad pointer, m = %08x, *free_list = %08x\n",
 135                m, free_list);
 136 #ifdef DEBUG_HEAP
 137         printf("Attempt to resize bad pointer, m = %08x, *free_list = %08x\n",
 138                m, free_list);
 139 #endif
 140         return NULL;
 141     }
 142
 143     /*
 144      * Check for grow block
 145      */
 146 #ifdef DEBUG_HEAP
 147         printf("HEAP_ReAlloc Check for grow block !\n");
 148 #endif
 149     if (new_size > m->length)
 150     {
 151         m_free = m + 1 + m->length / sizeof(MDESC);
 152         if (m_free->next == m_free ||
 153             m_free->prev == m_free ||
 154             m_free->length + sizeof(MDESC) < new_size)
 155         {
 156             void *new_p = HEAP_Alloc(free_list, flags, new_size);
 157             if (new_p ==NULL)
 158                 return NULL;
 159             memcpy(new_p, old_block, m->length);
 160             HEAP_Free(free_list, old_block);
 161             return new_p;
 162         }
 163
 164         if (m_free->prev == NULL)
 165             *free_list = m_free->next;
 166         else
 167             m_free->prev->next = m_free->next;
 168
 169         if (m_free->next != NULL)
 170             m_free->next->prev = m_free->prev;
 171
 172         m->length += sizeof(MDESC) + m_free->length;
 173 #ifdef DEBUG_HEAP
 174         printf("HEAP_ReAlloc before GLOBAL_FLAGS_ZEROINIT !\n");
 175 #endif
 176         if (flags & GLOBAL_FLAGS_ZEROINIT)
 177             memset(m_free, '\0', sizeof(MDESC) + m_free->length);
 178     }
 179
 180     /*
 181      * Check for shrink block.
 182      */
 183 #ifdef DEBUG_HEAP
 184         printf("HEAP_ReAlloc Check for shrink block !\n");
 185 #endif
 186     if (new_size < m->length - 4 * sizeof(MDESC))
 187     {
 188         m_free = m + new_size / sizeof(MDESC) + 2;
 189         m_free->next = m_free;
 190         m_free->prev = m_free;
 191         m_free->length = m->length - (int) m_free - (int) m;
 192         m->length = (int) m_free - (int) (m + 1);
 193         HEAP_Free(free_list, m_free + 1);
 194     }
 195
 196     return old_block;
 197 }
 198
 199 \f
 200 /**********************************************************************
 201  *                                      HEAP_Free
 202  */
 203 int
 204 HEAP_Free(MDESC **free_list, void *block)
 205 {
 206     MDESC *m_free;
 207     MDESC *m;
 208     MDESC *m_prev;
 209
 210     /*
 211      * Validate pointer.
 212      */
 213     m_free = (MDESC *) block - 1;
 214     if (m_free->prev != m_free || m_free->next != m_free ||
 215         ((int) m_free & 0xffff0000) != ((int) *free_list & 0xffff0000))
 216     {
 217 #ifdef DEBUG_HEAP
 218         printf("Attempt to free bad pointer,"
 219                "m_free = %08x, *free_list = %08x\n",
 220                m_free, free_list);
 221 #endif
 222         return -1;
 223     }
 224
 225     /*
 226      * Find location in free list.
 227      */
 228     m_prev = NULL;
 229     for (m = *free_list; m != NULL && m < m_free; m = m->next)
 230         m_prev = m;
 231
 232     if (m_prev != NULL && (int) m_prev + m_prev->length > (int) m_free)
 233     {
 234 #ifdef DEBUG_HEAP
 235         printf("Attempt to free bad pointer,"
 236                "m_free = %08x, m_prev = %08x (length %x)\n",
 237                m_free, m_prev, m_prev->length);
 238 #endif
 239         return -1;
 240     }
 241
 242     if ((m != NULL && (int) m_free + m_free->length > (int) m) ||
 243         (int) m_free + m_free->length > ((int) m_free | 0xffff))
 244     {
 245 #ifdef DEBUG_HEAP
 246         printf("Attempt to free bad pointer,"
 247                "m_free = %08x (length %x), m = %08x\n",
 248                m_free, m_free->length, m);
 249 #endif
 250         return -1;
 251     }
 252
 253     /*
 254      * Put block back in free list.
 255      * Does it merge with the previos block?
 256      */
 257     if (m_prev != NULL)
 258     {
 259         if ((int) m_prev + m_prev->length == (int) m_free)
 260         {
 261             m_prev->length += sizeof(MDESC) + m_free->length;
 262             m_free = m_prev;
 263         }
 264         else
 265         {
 266             m_prev->next = m_free;
 267             m_free->prev = m_prev;
 268         }
 269     }
 270     else
 271     {
 272         *free_list = m_free;
 273         m_free->prev = NULL;
 274     }
 275
 276     /*
 277      * Does it merge with the next block?
 278      */
 279     if (m != NULL)
 280     {
 281         if ((int) m_free + m_free->length == (int) m)
 282         {
 283             m_free->length += sizeof(MDESC) + m->length;
 284             m_free->next = m->next;
 285         }
 286         else
 287         {
 288             m->prev = m_free;
 289             m_free->next = m;
 290         }
 291     }
 292     else
 293     {
 294         m_free->next = NULL;
 295     }
 296
 297     return 0;
 298 }
 299
 300 /**********************************************************************
 301  *                                      HEAP_LocalFindHeap
 302  */
 303 LHEAP *
 304 HEAP_LocalFindHeap(unsigned short owner)
 305 {
 306     LHEAP *lh;
 307
 308 #ifdef DEBUG_HEAP
 309     printf("HEAP_LocalFindHeap: owner %04x\n", owner);
 310 #endif
 311
 312     for (lh = LocalHeaps; lh != NULL; lh = lh->next)
 313     {
 314         if (lh->selector == owner)
 315             return lh;
 316     }
 317
 318     return NULL;
 319 }
 320
 321 /**********************************************************************
 322  *                                      HEAP_LocalInit
 323  */
 324 void
 325 HEAP_LocalInit(unsigned short owner, void *start, int length)
 326 {
 327     LHEAP *lh;
 328
 329 #ifdef DEBUG_HEAP
 330     printf("HEAP_LocalInit: owner %04x, start %08x, length %04x\n",
 331            owner, start, length);
 332 #endif
 333
 334     if (length < 2 * sizeof(MDESC))
 335         return;
 336
 337     lh = (LHEAP *) malloc(sizeof(*lh));
 338     if (lh == NULL)
 339         return;
 340
 341     lh->next        = LocalHeaps;
 342     lh->selector    = owner;
 343     lh->local_table = NULL;
 344     HEAP_Init(&lh->free_list, start, length);
 345     LocalHeaps = lh;
 346 }
 347
 348 /**********************************************************************
 349  *                                      WIN16_LocalAlloc
 350  */
 351 void *
 352 WIN16_LocalAlloc(int flags, int bytes)
 353 {
 354     void *m;
 355
 356 #ifdef DEBUG_HEAP
 357     printf("WIN16_LocalAlloc: flags %x, bytes %d\n", flags, bytes);
 358     printf("    called from segment %04x\n", Stack16Frame[11]);
 359 #endif
 360
 361     m = HEAP_Alloc(LOCALHEAP(), flags, bytes);
 362
 363 #ifdef DEBUG_HEAP
 364         printf("WIN16_LocalAlloc: returning %x\n", (int) m);
 365 #endif
 366     return m;
 367 }
 368
 369 /**********************************************************************
 370  *                                      WIN16_LocalCompact
 371  */
 372 int
 373 WIN16_LocalCompact(int min_free)
 374 {
 375     MDESC *m;
 376     int max_block;
 377
 378     max_block = 0;
 379     for (m = *LOCALHEAP(); m != NULL; m = m->next)
 380         if (m->length > max_block)
 381             max_block = m->length;
 382
 383     return max_block;
 384 }
 385
 386 /**********************************************************************
 387  *                                      WIN16_LocalFlags
 388  */
 389 unsigned int
 390 WIN16_LocalFlags(unsigned int handle)
 391 {
 392     MDESC *m;
 393
 394     m = (MDESC *) (((int) *LOCALHEAP() & 0xffff0000) |
 395                    (handle & 0xffff)) - 1;
 396     if (m->next != m || m->prev != m)
 397         return 0;
 398
 399     return m->lock;
 400 }
 401
 402 /**********************************************************************
 403  *                                      WIN16_LocalFree
 404  */
 405 unsigned int
 406 WIN16_LocalFree(unsigned int handle)
 407 {
 408     unsigned int addr;
 409
 410     addr = ((int) *LOCALHEAP() & 0xffff0000) | (handle & 0xffff);
 411     if (HEAP_Free(LOCALHEAP(), (void *) addr) < 0)
 412         return handle;
 413     else
 414         return 0;
 415 }
 416
 417 /**********************************************************************
 418  *                                      WIN16_LocalInit
 419  */
 420 unsigned int
 421 WIN16_LocalInit(unsigned int segment, unsigned int start, unsigned int end)
 422 {
 423     unsigned short owner = HEAP_OWNER;
 424     LHEAP *lh = HEAP_LocalFindHeap(owner);
 425
 426     if (segment == 0)
 427     {
 428         /* Get current DS */
 429         segment = Stack16Frame[6];
 430     }
 431
 432     if (lh == NULL)
 433     {
 434         HEAP_LocalInit(owner,
 435                        (void *) ((segment << 16) | start), end - start + 1);
 436     }
 437     else
 438     {
 439         HEAP_Init(&lh->free_list,
 440                   (void *) ((segment << 16) | start), end - start + 1);
 441     }
 442         printf("WIN16_LocalInit // return segment=%04X !\n", segment);
 443     return segment;
 444 }
 445
 446 /**********************************************************************
 447  *                                      WIN16_LocalLock
 448  */
 449 void *
 450 WIN16_LocalLock(unsigned int handle)
 451 {
 452     MDESC *m;
 453
 454     m = (MDESC *) (((int) *LOCALHEAP() & 0xffff0000) |
 455                    (handle & 0xffff)) - 1;
 456     if (m->next != m || m->prev != m)
 457         return 0;
 458
 459     m->lock++;
 460     return (void *) (m + 1);
 461 }
 462
 463 /**********************************************************************
 464  *                                      WIN16_LocalReAlloc
 465  */
 466 void *
 467 WIN16_LocalReAlloc(unsigned int handle, int bytes, int flags)
 468 {
 469     void *m;
 470 #ifdef DEBUG_HEAP
 471         printf("WIN16_LocalReAlloc(%04X, %d, %04X); !\n",       handle, bytes, flags);
 472         printf("WIN16_LocalReAlloc // LOCALHEAP()=%08X !\n", LOCALHEAP());
 473         printf("WIN16_LocalReAlloc // *LOCALHEAP()=%08X !\n", *LOCALHEAP());
 474 #endif
 475     m = HEAP_ReAlloc(LOCALHEAP(), (void *)
 476                      (((int) *LOCALHEAP() & 0xffff0000) | (handle & 0xffff)),
 477                      bytes, flags);
 478
 479     return m;
 480 }
 481
 482 /**********************************************************************
 483  *                                      WIN16_LocalSize
 484  */
 485 unsigned int
 486 WIN16_LocalSize(unsigned int handle)
 487 {
 488     MDESC *m;
 489
 490     m = (MDESC *) (((int) *LOCALHEAP() & 0xffff0000) |
 491                    (handle & 0xffff)) - 1;
 492     if (m->next != m || m->prev != m)
 493         return 0;
 494
 495     return m->length;
 496 }
 497
 498 /**********************************************************************
 499  *                                      WIN16_LocalUnlock
 500  */
 501 unsigned int
 502 WIN16_LocalUnlock(unsigned int handle)
 503 {
 504     MDESC *m;
 505
 506     m = (MDESC *) (((int) *LOCALHEAP() & 0xffff0000) |
 507                    (handle & 0xffff)) - 1;
 508     if (m->next != m || m->prev != m)
 509         return 1;
 510
 511     if (m->lock > 0)
 512         m->lock--;
 513
 514     return 0;
 515 }
 516
 517 /**********************************************************************
 518  *                      GetFreeSystemResources (user.284)
 519
 520  */
 521 #define USERRESOURCES 2
 522 #define GDIRESOURCES 1
 523 #define SYSTEMRESOURCES 0
 524 #include <user.h>
 525 #include <gdi.h>
 526
 527 WORD GetFreeSystemResources(WORD SystemResourceType)
 528 {
 529   unsigned int GdiFree=0,GdiResult=0;
 530   unsigned int UserFree=0,UserResult=0;
 531   unsigned int result=0;
 532   MDESC *m;
 533
 534   printf("GetFreeSystemResources(%u)\n",SystemResourceType);
 535
 536   switch(SystemResourceType) {
 537     case(USERRESOURCES):
 538       for (m = USER_Heap; m != NULL; m = m->next) /* add up free area in heap */
 539          UserFree += m->length;
 540       result=(UserFree*100)/65516;  /* 65516 == 64K */
 541       break;
 542     case(GDIRESOURCES):
 543       for (m = GDI_Heap; m != NULL; m = m->next)
 544          GdiFree += m->length;
 545       result=(GdiFree*100)/65516;
 546       break;
 547     case(SYSTEMRESOURCES):
 548       for (m = USER_Heap; m != NULL; m = m->next)
 549          UserFree += m->length;
 550       UserResult=(UserFree*100)/65516;
 551       for (m = GDI_Heap; m != NULL; m = m->next)
 552          GdiFree += m->length;
 553       GdiResult=(GdiFree*100)/65516;
 554       result=(UserResult < GdiResult) ? UserResult:GdiResult;
 555       break;
 556     default:
 557       result=0;
 558       break;
 559   }
 560   return(result);
 561 }