memory/heap.c

   1 /*
   2 static char RCSId[] = "$Id: heap.c,v 1.3 1993/07/04 04:04:21 root Exp root $";
   3 static char Copyright[] = "Copyright  Robert J. Amstadt, 1993";
   4 */
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include "prototypes.h"
  10 #include "segmem.h"
  11 #include "heap.h"
  12 #include "regfunc.h"
  13 #include "dlls.h"
  14 #include "stddebug.h"
  15 /* #define DEBUG_HEAP */
  16 #include "debug.h"
  17
  18
  19 LHEAP *LocalHeaps = NULL;
  20
  21 void
  22 HEAP_CheckHeap(MDESC **free_list)
  23 {
  24     MDESC *m;
  25
  26     for (m = *free_list; m != NULL; m = m->next)
  27     {
  28         if (((int) m & 0xffff0000) != ((int) *free_list & 0xffff0000))
  29         {   dprintf_heap(stddeb,"Invalid block %p\n",m);
  30             *(char *)0 = 0;
  31         }
  32         if (m->prev && (((int) m->prev & 0xffff0000) != ((int) *free_list & 0xffff0000)))
  33         {   dprintf_heap(stddeb,"Invalid prev %p from %p\n", m->prev, m);
  34             *(char *)0 = 0;
  35         }
  36     }
  37 }
  38
  39 /**********************************************************************
  40  *                                      HEAP_Init
  41  */
  42 void
  43 HEAP_Init(MDESC **free_list, void *start, int length)
  44 {
  45     if (length < 2 * sizeof(MDESC))
  46         return;
  47
  48     *free_list = (MDESC *) start;
  49     (*free_list)->prev   = NULL;
  50     (*free_list)->next   = NULL;
  51     (*free_list)->length = length - sizeof(MDESC);
  52 }
  53
  54 /**********************************************************************
  55  *                                      HEAP_Alloc
  56  */
  57 void *
  58 HEAP_Alloc(MDESC **free_list, int flags, int bytes)
  59 {
  60     MDESC *m, *m_new;
  61
  62     dprintf_heap(stddeb,"HeapAlloc: free_list %08x(%08x), flags %x, bytes %d\n",
  63            (unsigned int) free_list, (unsigned int) *free_list, flags, bytes);
  64     if(debugging_heap)HEAP_CheckHeap(free_list);
  65
  66     /*
  67      * Find free block big enough.
  68      */
  69     for (m = *free_list; m != NULL; m = m->next)
  70     {
  71         if (m->length >= bytes && m->length < bytes + 4 * sizeof(MDESC))
  72         {
  73             break;
  74         }
  75         else if (m->length > bytes)
  76         {
  77             m_new = m + (bytes / sizeof(MDESC)) + 2;
  78             if (m->prev == NULL)
  79                 *free_list = m_new;
  80             else
  81                 m->prev->next = m_new;
  82
  83             if (m->next != NULL)
  84                 m->next->prev = m_new;
  85
  86             m_new->next = m->next;
  87             m_new->prev = m->prev;
  88             m_new->length = m->length - ((int) m_new - (int) m);
  89             m->length -= (m_new->length + sizeof(MDESC));
  90
  91             m->prev = m;
  92             m->next = m;
  93             m->lock = 0;
  94             m->flags = 0;
  95             if (flags & GLOBAL_FLAGS_ZEROINIT)
  96                 memset(m + 1, 0, bytes);
  97             dprintf_heap(stddeb,"HeapAlloc: returning %08x\n",
  98                 (unsigned int) (m + 1));
  99             if(debugging_heap)HEAP_CheckHeap(free_list);
 100             return (void *) (m + 1);
 101         }
 102     }
 103
 104     if (m != NULL)
 105     {
 106         if (m->prev == NULL)
 107             *free_list = m->next;
 108         else
 109             m->prev->next = m->next;
 110
 111         if (m->next != NULL)
 112             m->next->prev = m->prev;
 113
 114         m->prev = m;
 115         m->next = m;
 116         m->lock = 0;
 117         m->flags = 0;
 118         if (flags & GLOBAL_FLAGS_ZEROINIT)
 119             memset(m + 1, 0, bytes);
 120         dprintf_heap(stddeb,"HeapAlloc: returning %08x\n",
 121                 (unsigned int)  (m + 1));
 122         if(debugging_heap)HEAP_CheckHeap(free_list);
 123         return (void *) (m + 1);
 124     }
 125
 126     dprintf_heap(stddeb,"HeapAlloc: returning %08x\n", 0);
 127     if(debugging_heap)HEAP_CheckHeap(free_list);
 128     return 0;
 129 }
 130 \f
 131 /**********************************************************************
 132  *                                      HEAP_ReAlloc
 133  */
 134 void *
 135 HEAP_ReAlloc(MDESC **free_list, void *old_block,
 136              int new_size, unsigned int flags)
 137 {
 138     MDESC *m_free;
 139     MDESC *m;
 140
 141
 142     if (!old_block)
 143         return HEAP_Alloc(free_list, flags, new_size);
 144
 145     /*
 146      * Check validity of block
 147      */
 148     m = (MDESC *) old_block - 1;
 149
 150     dprintf_heap(stddeb,"HEAP_ReAlloc new_size=%d !\n",
 151                 (unsigned int) new_size);
 152     dprintf_heap(stddeb,"HEAP_ReAlloc old_block=%08X !\n",
 153                 (unsigned int)  old_block);
 154     dprintf_heap(stddeb,"HEAP_ReAlloc m=%08X free_list=%08X !\n",
 155                 (unsigned int) m, (unsigned int) free_list);
 156     dprintf_heap(stddeb,"HEAP_ReAlloc m->prev=%08X !\n",
 157          (unsigned int)  m->prev);
 158     dprintf_heap(stddeb,"HEAP_ReAlloc m->next=%08X !\n",
 159          (unsigned int)  m->next);
 160     dprintf_heap(stddeb,"HEAP_ReAlloc *free_list=%08X !\n",
 161          (unsigned int)  *free_list);
 162     if(debugging_heap)HEAP_CheckHeap(free_list);
 163
 164     if (m->prev != m || m->next != m ||
 165         ((int) m & 0xffff0000) != ((int) *free_list & 0xffff0000))
 166     {
 167         fprintf(stderr,"Attempt to resize bad pointer, m = %p, *free_list = %p\n",
 168                m, free_list);
 169         HEAP_CheckHeap(free_list);
 170         return NULL;
 171     }
 172
 173     /*
 174      * Check for grow block
 175      */
 176
 177     dprintf_heap(stddeb,"HEAP_ReAlloc Check for grow block !\n");
 178     if (new_size > m->length)
 179     {
 180         m_free = m + 1 + m->length / sizeof(MDESC);
 181         if (m_free->next == m_free ||
 182             m_free->prev == m_free ||
 183             m_free->length + 2*sizeof(MDESC) < new_size - m->length)
 184         {
 185             void *new_p = HEAP_Alloc(free_list, flags, new_size);
 186             if (new_p ==NULL)
 187                 return NULL;
 188             memcpy(new_p, old_block, m->length);
 189             HEAP_Free(free_list, old_block);
 190             if(debugging_heap)HEAP_CheckHeap(free_list);
 191             return new_p;
 192         }
 193
 194         if (m_free->prev == NULL)
 195             *free_list = m_free->next;
 196         else
 197             m_free->prev->next = m_free->next;
 198
 199         if (m_free->next != NULL)
 200             m_free->next->prev = m_free->prev;
 201
 202         m->length += sizeof(MDESC) + m_free->length;
 203
 204         dprintf_heap(stddeb,"HEAP_ReAlloc before GLOBAL_FLAGS_ZEROINIT !\n");
 205         if (flags & GLOBAL_FLAGS_ZEROINIT)
 206             memset(m_free, '\0', sizeof(MDESC) + m_free->length);
 207     }
 208
 209     /*
 210      * Check for shrink block.
 211      */
 212     dprintf_heap(stddeb,"HEAP_ReAlloc Check for shrink block !\n");
 213     if (new_size + 4*sizeof(MDESC) < m->length)
 214     {
 215         m_free = m + new_size / sizeof(MDESC) + 2;
 216         m_free->next = m_free;
 217         m_free->prev = m_free;
 218         m_free->length = m->length - ((int) m_free - (int) m);
 219         m->length = (int) m_free - (int) (m + 1);
 220         HEAP_Free(free_list, m_free + 1);
 221     }
 222
 223     if(debugging_heap)HEAP_CheckHeap(free_list);
 224     return old_block;
 225 }
 226
 227 \f
 228 /**********************************************************************
 229  *                                      HEAP_Free
 230  */
 231 int
 232 HEAP_Free(MDESC **free_list, void *block)
 233 {
 234     MDESC *m_free;
 235     MDESC *m;
 236     MDESC *m_prev;
 237
 238     dprintf_heap(stddeb,"HeapFree: free_list %p, block %p\n",
 239            free_list, block);
 240     if(debugging_heap)HEAP_CheckHeap(free_list);
 241
 242     /*
 243      * Validate pointer.
 244      */
 245     m_free = (MDESC *) block - 1;
 246     if (m_free->prev != m_free || m_free->next != m_free)
 247     {
 248         fprintf(stderr,"Attempt to free bad pointer,"
 249                "m_free = %p, *free_list = %p\n",
 250                m_free, free_list);
 251         return -1;
 252     }
 253
 254     if (*free_list == NULL)
 255     {
 256         *free_list = m_free;
 257         (*free_list)->next = NULL;
 258         (*free_list)->prev = NULL;
 259         return 0;
 260     }
 261     else if (((int) m_free & 0xffff0000) != ((int) *free_list & 0xffff0000))
 262     {
 263         fprintf(stderr,"Attempt to free bad pointer,"
 264                "m_free = %p, *free_list = %p\n",
 265                m_free, free_list);
 266         return -1;
 267     }
 268
 269     /*
 270      * Find location in free list.
 271      */
 272     m_prev = NULL;
 273     for (m = *free_list; m != NULL && m < m_free; m = m->next)
 274         m_prev = m;
 275
 276     if (m_prev != NULL && (int) m_prev + m_prev->length > (int) m_free)
 277     {
 278         fprintf(stderr,"Attempt to free bad pointer,"
 279                "m_free = %p, m_prev = %p (length %x)\n",
 280                m_free, m_prev, m_prev->length);
 281         return -1;
 282     }
 283
 284     if ((m != NULL && (int) m_free + m_free->length > (int) m) ||
 285         (int) m_free + m_free->length > ((int) m_free | 0xffff))
 286     {
 287         fprintf(stderr,"Attempt to free bad pointer,"
 288                "m_free = %p (length %x), m = %p\n",
 289                m_free, m_free->length, m);
 290         return -1;
 291     }
 292
 293     /*
 294      * Put block back in free list.
 295      * Does it merge with the previos block?
 296      */
 297     if (m_prev != NULL)
 298     {
 299         if ((int) m_prev + m_prev->length == (int) m_free)
 300         {
 301             m_prev->length += sizeof(MDESC) + m_free->length;
 302             m_free = m_prev;
 303         }
 304         else
 305         {
 306             m_prev->next = m_free;
 307             m_free->prev = m_prev;
 308         }
 309     }
 310     else
 311     {
 312         *free_list = m_free;
 313         m_free->prev = NULL;
 314     }
 315
 316     /*
 317      * Does it merge with the next block?
 318      */
 319     if (m != NULL)
 320     {
 321         if ((int) m_free + m_free->length == (int) m)
 322         {
 323             m_free->length += sizeof(MDESC) + m->length;
 324             m_free->next = m->next;
 325         }
 326         else
 327         {
 328             m->prev = m_free;
 329             m_free->next = m;
 330         }
 331     }
 332     else
 333     {
 334         m_free->next = NULL;
 335     }
 336
 337     if(debugging_heap)HEAP_CheckHeap(free_list);
 338     return 0;
 339 }
 340
 341 /**********************************************************************
 342  *                                      HEAP_CheckLocalHeaps
 343  */
 344 void
 345 HEAP_CheckLocalHeaps(char *file,int line)
 346 {
 347     LHEAP *lh;
 348     dprintf_heap(stddeb,"CheckLocalHeaps called from %s %d\n",file,line);
 349     for(lh=LocalHeaps; lh!=NULL; lh = lh->next)
 350     {   dprintf_heap(stddeb,"Checking heap %p, free_list %p\n",
 351                 lh,lh->free_list);
 352         HEAP_CheckHeap(&lh->free_list);
 353     }
 354 }
 355
 356
 357 /**********************************************************************
 358  *                                      HEAP_LocalFindHeap
 359  */
 360 LHEAP *
 361 HEAP_LocalFindHeap(unsigned short owner)
 362 {
 363     LHEAP *lh;
 364
 365     dprintf_heap(stddeb,"HEAP_LocalFindHeap: owner %04x\n", owner);
 366
 367     for (lh = LocalHeaps; lh != NULL; lh = lh->next)
 368     {
 369         if (lh->selector == owner)
 370             return lh;
 371     }
 372
 373     dprintf_heap(stddeb,"Warning: Local heap not found\n");
 374     return NULL;
 375 }
 376
 377 /**********************************************************************
 378  *                                      HEAP_LocalInit
 379  */
 380 void
 381 HEAP_LocalInit(unsigned short owner, void *start, int length)
 382 {
 383     LHEAP *lh;
 384
 385     dprintf_heap(stddeb,"HEAP_LocalInit: owner %04x, start %p, length %04x\n"
 386            ,owner, start, length);
 387
 388     if (length < 2 * sizeof(MDESC))
 389         return;
 390
 391     lh = (LHEAP *) malloc(sizeof(*lh));
 392     if (lh == NULL)
 393         return;
 394
 395     lh->next        = LocalHeaps;
 396     lh->selector    = owner;
 397     lh->local_table = NULL;
 398     lh->delta       = 0x20;
 399     HEAP_Init(&lh->free_list, start, length);
 400     dprintf_heap(stddeb,"HEAP_LocalInit: free_list %p, length %04x, prev %p, next %p\n",&lh->free_list,lh->free_list->length, lh->free_list->prev,lh->free_list->next);
 401     LocalHeaps = lh;
 402 }
 403
 404 /**********************************************************************
 405  *                                      HEAP_LocalSize
 406  */
 407 unsigned int
 408 HEAP_LocalSize(MDESC **free_list, unsigned int handle)
 409 {
 410     MDESC *m;
 411
 412     m = (MDESC *) (((int) *free_list & 0xffff0000) |
 413                    (handle & 0xffff)) - 1;
 414     if (m->next != m || m->prev != m)
 415         return 0;
 416
 417     return m->length;
 418 }
 419
 420 /**********************************************************************
 421  *                                      WIN16_LocalAlloc
 422  */
 423 void *
 424 WIN16_LocalAlloc(int flags, int bytes)
 425 {
 426     void *m;
 427
 428     dprintf_heap(stddeb,"WIN16_LocalAlloc: flags %x, bytes %d\n", flags,bytes);
 429     dprintf_heap(stddeb,"    called from segment %04x, ds=%04x\n", Stack16Frame[11],Stack16Frame[6]);
 430
 431     m = HEAP_Alloc(LOCALHEAP(), flags, bytes);
 432
 433     dprintf_heap(stddeb,"WIN16_LocalAlloc: returning %x\n", (int) m);
 434     return m;
 435 }
 436
 437 /**********************************************************************
 438  *                                      WIN16_LocalCompact
 439  */
 440 int
 441 WIN16_LocalCompact(int min_free)
 442 {
 443     MDESC *m;
 444     int max_block;
 445
 446     max_block = 0;
 447     for (m = *LOCALHEAP(); m != NULL; m = m->next)
 448         if (m->length > max_block)
 449             max_block = m->length;
 450
 451     return max_block;
 452 }
 453
 454 /**********************************************************************
 455  *                                      WIN16_LocalFlags
 456  */
 457 unsigned int
 458 WIN16_LocalFlags(unsigned int handle)
 459 {
 460     MDESC *m;
 461
 462     m = (MDESC *) (((int) *LOCALHEAP() & 0xffff0000) |
 463                    (handle & 0xffff)) - 1;
 464     if (m->next != m || m->prev != m)
 465         return 0;
 466
 467     return m->lock;
 468 }
 469
 470 /**********************************************************************
 471  *                                      WIN16_LocalFree
 472  */
 473 unsigned int
 474 WIN16_LocalFree(unsigned int handle)
 475 {
 476     unsigned int addr;
 477
 478     addr = ((int) *LOCALHEAP() & 0xffff0000) | (handle & 0xffff);
 479     if (HEAP_Free(LOCALHEAP(), (void *) addr) < 0)
 480         return handle;
 481     else
 482         return 0;
 483 }
 484
 485 /**********************************************************************
 486  *                                      WIN16_LocalInit
 487  */
 488 unsigned int
 489 WIN16_LocalInit(unsigned int segment, unsigned int start, unsigned int end)
 490 {
 491     unsigned short owner = HEAP_OWNER;
 492     LHEAP *lh = HEAP_LocalFindHeap(owner);
 493
 494     if (segment == 0)
 495     {
 496         /* Get current DS */
 497         segment = Stack16Frame[6];
 498     }
 499
 500     dprintf_heap(stddeb, "WIN16_LocalInit   segment=%04x  start=%04x  end=%04x\n", segment, start, end);
 501
 502     /* start=0 doesn't mean the first byte of the segment if the segment
 503        is an auto data segment. Instead it should start after the actual
 504        data (and the stack if there is one). As we don't know the length
 505        of the data and stack right now, we simply put the local heap at the
 506        end of the segment */
 507     if ((start==0)&&(Segments[segment>>3].owner==segment))
 508     {
 509         return;
 510         start = Segments[segment>>3].length-end-2;
 511         end   = Segments[segment>>3].length-1;
 512         dprintf_heap(stddeb, "Changed to  start=%04x  end=%04x\n",start,end);
 513     }
 514
 515     if (lh == NULL)
 516     {
 517         HEAP_LocalInit(owner,
 518                        (void *) ((segment << 16) | start), end - start + 1);
 519     }
 520     else
 521     {
 522         HEAP_Init(&lh->free_list,
 523                   (void *) ((segment << 16) | start), end - start + 1);
 524     }
 525     dprintf_heap(stddeb,"WIN16_LocalInit // return segment=%04X !\n", segment);
 526     return segment;
 527 }
 528
 529 /**********************************************************************
 530  *                                      WIN16_LocalLock
 531  */
 532 void *
 533 WIN16_LocalLock(unsigned int handle)
 534 {
 535     MDESC *m;
 536
 537     m = (MDESC *) (((int) *LOCALHEAP() & 0xffff0000) |
 538                    (handle & 0xffff)) - 1;
 539     if (m->next != m || m->prev != m)
 540         return 0;
 541
 542     m->lock++;
 543     return (void *) (m + 1);
 544 }
 545
 546 /**********************************************************************
 547  *                                      WIN16_LocalReAlloc
 548  */
 549 void *
 550 WIN16_LocalReAlloc(unsigned int handle, int bytes, int flags)
 551 {
 552     void *m;
 553     dprintf_heap(stddeb,"WIN16_LocalReAlloc(%04X, %d, %04X); !\n",
 554                  handle, bytes, flags);
 555     dprintf_heap(stddeb,"WIN16_LocalReAlloc // LOCALHEAP()=%p !\n",
 556                  LOCALHEAP());
 557     dprintf_heap(stddeb,"WIN16_LocalReAlloc // *LOCALHEAP()=%p !\n",
 558                  *LOCALHEAP());
 559     m = HEAP_ReAlloc(LOCALHEAP(), (void *)
 560                      (((int) *LOCALHEAP() & 0xffff0000) | (handle & 0xffff)),
 561                      bytes, flags);
 562
 563     return m;
 564 }
 565
 566 /**********************************************************************
 567  *                                      WIN16_LocalSize
 568  */
 569 unsigned int
 570 WIN16_LocalSize(unsigned int handle)
 571 {
 572     MDESC *m;
 573
 574     m = (MDESC *) (((int) *LOCALHEAP() & 0xffff0000) |
 575                    (handle & 0xffff)) - 1;
 576     if (m->next != m || m->prev != m)
 577         return 0;
 578
 579     return m->length;
 580 }
 581
 582 /**********************************************************************
 583  *                                      WIN16_LocalUnlock
 584  */
 585 unsigned int
 586 WIN16_LocalUnlock(unsigned int handle)
 587 {
 588     MDESC *m;
 589
 590     m = (MDESC *) (((int) *LOCALHEAP() & 0xffff0000) |
 591                    (handle & 0xffff)) - 1;
 592     if (m->next != m || m->prev != m)
 593         return 1;
 594
 595     if (m->lock > 0)
 596         m->lock--;
 597
 598     return 0;
 599 }
 600
 601 /**********************************************************************
 602  *                                      WIN16_LocalHandleDelta
 603  */
 604 unsigned int
 605 WIN16_LocalHandleDelta(unsigned int new_delta)
 606 {
 607     LHEAP *lh;
 608
 609     lh = HEAP_LocalFindHeap(HEAP_OWNER);
 610     if (lh == NULL)
 611         return 0;
 612
 613     if (new_delta)
 614         lh->delta = new_delta;
 615
 616     return lh->delta;
 617 }
 618
 619 /**********************************************************************
 620  *                      GetFreeSystemResources (user.284)
 621
 622  */
 623 #define USERRESOURCES 2
 624 #define GDIRESOURCES 1
 625 #define SYSTEMRESOURCES 0
 626 #include <user.h>
 627 #include <gdi.h>
 628
 629 WORD GetFreeSystemResources(WORD SystemResourceType)
 630 {
 631   unsigned int GdiFree=0,GdiResult=0;
 632   unsigned int UserFree=0,UserResult=0;
 633   unsigned int result=0;
 634   MDESC *m;
 635   dprintf_heap(stddeb,"GetFreeSystemResources(%u)\n",SystemResourceType);
 636   switch(SystemResourceType) {
 637     case(USERRESOURCES):
 638       for (m = USER_Heap; m != NULL; m = m->next) /* add up free area in heap */
 639          UserFree += m->length;
 640       result=(UserFree*100)/65516;  /* 65516 == 64K */
 641       break;
 642     case(GDIRESOURCES):
 643       for (m = GDI_Heap; m != NULL; m = m->next)
 644          GdiFree += m->length;
 645       result=(GdiFree*100)/65516;
 646       break;
 647     case(SYSTEMRESOURCES):
 648       for (m = USER_Heap; m != NULL; m = m->next)
 649          UserFree += m->length;
 650       UserResult=(UserFree*100)/65516;
 651       for (m = GDI_Heap; m != NULL; m = m->next)
 652          GdiFree += m->length;
 653       GdiResult=(GdiFree*100)/65516;
 654       result=(UserResult < GdiResult) ? UserResult:GdiResult;
 655       break;
 656     default:
 657       result=0;
 658       break;
 659   }
 660   return(result);
 661 }