source: trunk/src/kernel32/os2heap.cpp@ 6397

Last change on this file since 6397 was 6397, checked in by sandervl, 24 years ago

updates
File size: 10.8 KB
Line 
1/* $Id: os2heap.cpp,v 1.22 2001-07-28 18:03:38 sandervl Exp $ */
2
3/*
4 * Heap class for OS/2
5 *
6 * Copyright 1998 Sander van Leeuwen
7 *
8 *
9 * NOTE: ReAlloc allocates memory using Alloc if memory pointer == NULL
10 * WINE controls depend on this, even though it apparently
11 * doesn't work like this in Windows.
12 *
13 * Project Odin Software License can be found in LICENSE.TXT
14 *
15 */
16#define INCL_DOSMEMMGR
17#define INCL_DOSSEMAPHORES
18#define INCL_DOSERRORS
19#include <os2wrap.h> //Odin32 OS/2 api wrappers
20#include <stdlib.h>
21#include <string.h>
22#include <umalloc.h>
23
24#include "win32type.h"
25#include "os2heap.h"
26#include "misc.h"
27#include "vmutex.h"
28#include "initterm.h"
29#include <odin32validate.h>
30
31#define DBG_LOCALLOG DBG_os2heap
32#include "dbglocal.h"
33
34#ifndef HEAP_NO_SERIALIZE
35 #define HEAP_NO_SERIALIZE 1
36#endif
37
38#ifndef HEAP_ZERO_MEMORY
39 #define HEAP_ZERO_MEMORY 8
40#endif
41
42VMutex heaplistmutex; //protects linked lists of heaps
43
44void * _LNK_CONV getmoreHeapMem(Heap_t pHeap, size_t *size, int *clean);
45void _LNK_CONV releaseHeapMem(Heap_t pHeap, void *block, size_t size);
46
47//******************************************************************************
48//******************************************************************************
49OS2Heap::OS2Heap(DWORD flOptions, DWORD dwInitialSize, DWORD dwMaximumSize)
50{
51 OS2Heap *curheap = OS2Heap::heap;
52
53 totalAlloc = 0;
54 fInitialized = 0;
55 nrHeaps = 0;
56 heapelem = NULL;
57
58 dwInitialSize = (dwInitialSize >= 0x4000) ? dwInitialSize : 0x4000;
59
60 this->dwMaximumSize = dwMaximumSize;
61 this->dwInitialSize = dwInitialSize;
62 this->flOptions = flOptions;
63
64 dprintf(("KERNEL32: HeapCreate: initial size %d, max size %d (flags %X) returned %X\n", dwInitialSize, dwMaximumSize, flOptions, hPrimaryHeap));
65
66 if(!(flOptions & HEAP_NO_SERIALIZE))
67 {
68 hmutex = new VMutex();
69 dassert(hmutex, ("ERROR: new VMutex\n"));
70 }
71 else hmutex = NULL;
72
73 heaplistmutex.enter();
74 if(curheap != NULL) {
75 while(curheap->next != NULL) {
76 curheap = curheap->next;
77 }
78 curheap->next = this;
79 }
80 else heap = this;
81 next = NULL;
82
83 heaplistmutex.leave();
84
85 APIRET rc;
86
87 rc = DosAllocMem((PPVOID)&pInitialHeapMem, dwInitialSize, PAG_READ|PAG_WRITE|PAG_COMMIT);
88 if(rc != 0) {
89 dprintf(("OS2Heap::OS2Heap: DosAllocSharedMem failed with %d", rc));
90 DebugInt3();
91 }
92 uheap = _ucreate(pInitialHeapMem, dwInitialSize, _BLOCK_CLEAN,
93 _HEAP_REGULAR, getmoreHeapMem, releaseHeapMem);
94 if(uheap == NULL) {
95 DosFreeMem(pInitialHeapMem);
96 pInitialHeapMem = NULL;
97 dprintf(("OS2Heap::OS2Heap: _ucreate failed!"));
98 DebugInt3();
99 }
100 hPrimaryHeap = (HANDLE)uheap;
101}
102//******************************************************************************
103//******************************************************************************
104OS2Heap::~OS2Heap()
105{
106 OS2Heap *curheap = OS2Heap::heap;
107 HEAPELEM *hnext;
108 int i;
109
110 dprintf(("dtr OS2Heap, hPrimaryHeap = %X\n", hPrimaryHeap));
111
112 if(hmutex)
113 hmutex->enter();
114
115 while(heapelem) {
116 hnext = heapelem->next;
117 free(heapelem->lpMem);
118 heapelem = hnext;
119 }
120 if(hmutex)
121 {
122 hmutex->leave();
123 delete(hmutex);
124 }
125
126 heaplistmutex.enter();
127 if(heap == this) {
128 heap = next;
129 }
130 else {
131 while(curheap->next != NULL) {
132 if(curheap->next == this) {
133 curheap->next = next;
134 break;
135 }
136 curheap = curheap->next;
137 }
138 }
139 heaplistmutex.leave();
140
141 if(uheap) {
142 _uclose(uheap);
143 _udestroy(uheap, _FORCE);
144 uheap = NULL;
145 }
146 if(pInitialHeapMem) {
147 DosFreeMem(pInitialHeapMem);
148 pInitialHeapMem = NULL;
149 }
150
151 dprintf(("dtr OS2Heap, hPrimaryHeap = %X done\n", hPrimaryHeap));
152}
153//******************************************************************************
154//******************************************************************************
155LPVOID OS2Heap::Alloc(DWORD dwFlags, DWORD dwBytes)
156{
157 HEAPELEM *lpHeapObj;
158 LPVOID lpMem;
159
160// dprintf(("OS2Heap::Alloc\n"));
161 lpMem = _umalloc(uheap, dwBytes + HEAP_OVERHEAD);
162 if(lpMem == NULL) {
163 dprintf(("OS2Heap::Alloc, lpMem == NULL"));
164 return(NULL);
165 }
166 if(dwFlags & HEAP_ZERO_MEMORY) {
167 memset(lpMem, 0, dwBytes+HEAP_OVERHEAD);
168 }
169 totalAlloc += dwBytes;
170
171 //align at 8 byte boundary
172 lpHeapObj = (HEAPELEM *)(((ULONG)lpMem+7) & ~7);
173 lpHeapObj->lpMem = lpMem;
174
175 if(hmutex)
176 hmutex->enter();
177
178 lpHeapObj->next = heapelem;
179 lpHeapObj->prev = NULL;
180 lpHeapObj->magic = MAGIC_NR_HEAP;
181 if(heapelem) {
182 heapelem->prev = lpHeapObj;
183 }
184 heapelem = lpHeapObj;
185
186 if(hmutex) {
187 hmutex->leave();
188 }
189 return(LPVOID)(lpHeapObj+1);
190}
191//******************************************************************************
192//******************************************************************************
193DWORD OS2Heap::Size(DWORD dwFlags, PVOID lpMem)
194{
195 HEAPELEM *helem = GET_HEAPOBJ(lpMem);
196
197 if(lpMem == NULL) {
198 dprintf(("OS2Heap::Size lpMem == NULL\n"));
199 return -1;
200 }
201 /* verify lpMem address */
202 if (lpMem >= (LPVOID)ulMaxAddr || lpMem < (LPVOID)0x10000)
203 {
204 dprintf(("OS2Heap::Size ERROR BAD HEAP POINTER:%X\n", lpMem));
205 return -1;
206 }
207
208 if(helem->magic != MAGIC_NR_HEAP)
209 {
210 dprintf(("OS2Heap::Size ERROR BAD HEAP POINTER:%X\n", lpMem));
211 return -1;
212 }
213
214 return(_msize(helem->lpMem) - HEAP_OVERHEAD);
215}
216//******************************************************************************
217//******************************************************************************
218LPVOID OS2Heap::ReAlloc(DWORD dwFlags, LPVOID lpMem, DWORD dwBytes)
219{
220 HEAPELEM *helem = GET_HEAPOBJ(lpMem);
221 LPVOID lpNewMem;
222 int i, oldSize;
223
224 if (dwBytes == 0) return NULL; // intercept stupid parameters
225
226 //NOTE: Allocate memory using Alloc -> WINE controls depend on this, even
227 // though it apparently doesn't work in Windows.
228 if (lpMem == 0) return Alloc(dwFlags, dwBytes);
229// if (lpMem == 0) return NULL;
230
231 if (helem->magic != MAGIC_NR_HEAP)
232 {
233 dprintf(("OS2Heap::ReAlloc ERROR BAD HEAP POINTER:%X\n", lpMem));
234 return lpMem;
235 }
236
237 oldSize = Size(0,lpMem);
238 if (oldSize >= dwBytes) {
239 dprintf(("ReAlloc with smaller size than original (%d); return old pointer", oldSize));
240 return lpMem; // if reallocation with same size don't do anything
241 }
242 lpNewMem = Alloc(dwFlags, dwBytes);
243 memcpy(lpNewMem, lpMem, dwBytes < oldSize ? dwBytes : oldSize);
244 Free(0, lpMem);
245
246 if(lpNewMem == NULL)
247 {
248 dprintf(("OS2Heap::ReAlloc, no more memory left\n"));
249 }
250
251 return(lpNewMem);
252}
253//******************************************************************************
254//******************************************************************************
255BOOL OS2Heap::Free(DWORD dwFlags, LPVOID lpMem)
256{
257 HEAPELEM *helem = GET_HEAPOBJ(lpMem);
258
259 if(lpMem == NULL) {
260 dprintf(("OS2Heap::Free lpMem == NULL\n"));
261 return(FALSE);
262 }
263 /* verify lpMem address */
264 if (lpMem >= (LPVOID)ulMaxAddr || lpMem < (LPVOID)0x10000)
265 {
266 dprintf(("OS2Heap::Free ERROR BAD HEAP POINTER:%X\n", lpMem));
267 return FALSE;
268 }
269
270 if(helem->magic != MAGIC_NR_HEAP)
271 {
272 dprintf(("OS2Heap::Free ERROR BAD HEAP POINTER:%X\n", lpMem));
273 return FALSE;
274 }
275
276#ifdef DEBUG1
277 int size = Size(0, lpMem);
278 dprintf(("OS2Heap::Free lpMem = %X, size %d\n", lpMem, size));
279 totalAlloc -= size;
280#endif
281 if(hmutex)
282 hmutex->enter();
283
284 if(helem->prev)
285 helem->prev->next = helem->next;
286 if(helem->next)
287 helem->next->prev = helem->prev;
288 if(heapelem == helem)
289 heapelem = heapelem->next;
290
291 if(hmutex) {
292 hmutex->leave();
293 }
294
295 free(helem->lpMem);
296 return(TRUE);
297}
298//******************************************************************************
299//******************************************************************************
300DWORD OS2Heap::Compact(DWORD dwFlags)
301{
302 dprintf(("OS2Heap::Compact, %X- stub\n", dwFlags));
303 return(0);
304}
305//******************************************************************************
306//******************************************************************************
307BOOL OS2Heap::Validate(DWORD dwFlags, LPCVOID lpMem)
308{
309 HEAPELEM *helem = GET_HEAPOBJ(lpMem);
310
311 dprintf(("OS2Heap::Validate, %X %X", dwFlags, lpMem));
312
313 if(lpMem == NULL) {
314 dprintf(("OS2Heap::Validate lpMem == NULL\n"));
315 return(FALSE);
316 }
317 /* verify lpMem address */
318 if (lpMem >= (LPVOID)ulMaxAddr || lpMem < (LPVOID)0x10000)
319 {
320 dprintf(("OS2Heap::Validate BAD HEAP POINTER:%X\n", lpMem));
321 return FALSE;
322 }
323
324 if(helem->magic != MAGIC_NR_HEAP)
325 {
326 dprintf(("OS2Heap::Validate BAD HEAP POINTER:%X\n", lpMem));
327 return FALSE;
328 }
329 return(TRUE);
330}
331//******************************************************************************
332//******************************************************************************
333BOOL OS2Heap::Walk(void *lpEntry)
334{
335 dprintf(("OS2Heap::Walk, %X - stub? (TRUE)\n", lpEntry));
336 return(TRUE);
337}
338//******************************************************************************
339//******************************************************************************
340OS2Heap *OS2Heap::find(HANDLE hHeap)
341{
342 OS2Heap *curheap = OS2Heap::heap;
343
344 //@@@PH NT programs seem to assume heap 0 is always valid?!
345 if (hHeap == 0)
346 if (curheap != NULL)
347 return curheap;
348
349 while(curheap != NULL) {
350 if(curheap->hPrimaryHeap == hHeap) {
351 return(curheap);
352 }
353 curheap = curheap->next;
354 }
355 dprintf(("Heap %X not found!\n", hHeap));
356 return(NULL);
357}
358//******************************************************************************
359//******************************************************************************
360OS2Heap *OS2Heap::heap = NULL;
361
362//******************************************************************************
363//******************************************************************************
364void * _LNK_CONV getmoreHeapMem(Heap_t pHeap, size_t *size, int *clean)
365{
366 APIRET rc;
367 PVOID newblock;
368
369 dprintf(("KERNEL32: getmoreHeapMem(%08xh, %08xh, %08xh)", pHeap, *size, *clean));
370
371 /* round the size up to a multiple of 4K */
372 *size = (*size / 4096) * 4096 + 4096;
373
374 rc = DosAllocMem(&newblock, *size, PAG_READ|PAG_WRITE|PAG_COMMIT|PAG_EXECUTE);
375 if(rc != 0) {
376 dprintf(("getmoreHeapMem: DosAllocMem failed with %d", rc));
377 return FALSE;
378 }
379 *clean = _BLOCK_CLEAN;
380 dprintf(("KERNEL32: getmoreHeapMem %x %d", newblock, *size));
381 return newblock;
382}
383//******************************************************************************
384//******************************************************************************
385void _LNK_CONV releaseHeapMem(Heap_t pHeap, void *block, size_t size)
386{
387 dprintf(("KERNEL32: releaseHeapMem %x %x %d", pHeap, block, size));
388 DosFreeMem(block);
389}
390//******************************************************************************
391//******************************************************************************
Note: See TracBrowser for help on using the repository browser.