4 * Copyright 1997 Marcus Meissner
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library 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 GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
35 #include "wine/debug.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(olemalloc
);
39 /******************************************************************************
40 * IMalloc32 implementation
43 * For supporting CoRegisterMallocSpy the IMalloc implementation must know if
44 * a given memory block was allocated with a spy active.
46 *****************************************************************************/
47 /* set the vtable later */
48 static IMallocVtbl VT_IMalloc32
;
52 DWORD dummy
; /* nothing, we are static */
53 IMallocSpy
* pSpy
; /* the spy when active */
54 DWORD SpyedAllocationsLeft
; /* number of spyed allocations left */
55 BOOL SpyReleasePending
; /* CoRevokeMallocSpy called with spyed allocations left*/
56 LPVOID
* SpyedBlocks
; /* root of the table */
57 int SpyedBlockTableLength
; /* size of the table*/
60 /* this is the static object instance */
61 _Malloc32 Malloc32
= {&VT_IMalloc32
, 0, NULL
, 0, 0, NULL
, 0};
63 /* with a spy active all calls from pre to post methods are threadsave */
64 static CRITICAL_SECTION IMalloc32_SpyCS
;
65 static CRITICAL_SECTION_DEBUG critsect_debug
=
67 0, 0, &IMalloc32_SpyCS
,
68 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
69 0, 0, { 0, (DWORD
)(__FILE__
": IMalloc32_SpyCS") }
71 static CRITICAL_SECTION IMalloc32_SpyCS
= { &critsect_debug
, -1, 0, 0, 0, 0 };
73 /* resize the old table */
74 static int SetSpyedBlockTableLength ( int NewLength
)
76 LPVOID
*NewSpyedBlocks
;
78 if (!Malloc32
.SpyedBlocks
) NewSpyedBlocks
= LocalAlloc(GMEM_ZEROINIT
, NewLength
);
79 else NewSpyedBlocks
= LocalReAlloc(Malloc32
.SpyedBlocks
, NewLength
, GMEM_ZEROINIT
);
81 Malloc32
.SpyedBlocks
= NewSpyedBlocks
;
82 Malloc32
.SpyedBlockTableLength
= NewLength
;
85 return NewSpyedBlocks
!= NULL
;
88 /* add a location to the table */
89 static int AddMemoryLocation(LPVOID
* pMem
)
93 /* allocate the table if not already allocated */
94 if (!Malloc32
.SpyedBlockTableLength
) {
95 if (!SetSpyedBlockTableLength(0x1000)) return 0;
98 /* find a free location */
99 Current
= Malloc32
.SpyedBlocks
;
102 if (Current
>= Malloc32
.SpyedBlocks
+ Malloc32
.SpyedBlockTableLength
) {
103 /* no more space in table, grow it */
104 if (!SetSpyedBlockTableLength( Malloc32
.SpyedBlockTableLength
+ 0x1000 )) return 0;
108 /* put the location in our table */
110 Malloc32
.SpyedAllocationsLeft
++;
111 /*TRACE("%lu\n",Malloc32.SpyedAllocationsLeft);*/
115 static int RemoveMemoryLocation(LPVOID
* pMem
)
119 /* allocate the table if not already allocated */
120 if (!Malloc32
.SpyedBlockTableLength
) {
121 if (!SetSpyedBlockTableLength(0x1000)) return 0;
124 Current
= Malloc32
.SpyedBlocks
;
126 /* find the location */
127 while (*Current
!= pMem
) {
129 if (Current
>= Malloc32
.SpyedBlocks
+ Malloc32
.SpyedBlockTableLength
) return 0; /* not found */
133 Malloc32
.SpyedAllocationsLeft
--;
134 /*TRACE("%lu\n",Malloc32.SpyedAllocationsLeft);*/
139 /******************************************************************************
140 * IMalloc32_QueryInterface [VTABLE]
142 static HRESULT WINAPI
IMalloc_fnQueryInterface(LPMALLOC iface
,REFIID refiid
,LPVOID
*obj
) {
144 TRACE("(%s,%p)\n",debugstr_guid(refiid
),obj
);
146 if (IsEqualIID(&IID_IUnknown
,refiid
) || IsEqualIID(&IID_IMalloc
,refiid
)) {
147 *obj
= (LPMALLOC
)&Malloc32
;
150 return E_NOINTERFACE
;
153 /******************************************************************************
154 * IMalloc32_AddRefRelease [VTABLE]
156 static ULONG WINAPI
IMalloc_fnAddRefRelease (LPMALLOC iface
) {
160 /******************************************************************************
161 * IMalloc32_Alloc [VTABLE]
163 static LPVOID WINAPI
IMalloc_fnAlloc(LPMALLOC iface
, DWORD cb
) {
170 DWORD preAllocResult
;
172 EnterCriticalSection(&IMalloc32_SpyCS
);
173 preAllocResult
= IMallocSpy_PreAlloc(Malloc32
.pSpy
, cb
);
174 if ((cb
!= 0) && (preAllocResult
== 0)) {
175 /* PreAlloc can force Alloc to fail, but not if cb == 0 */
176 TRACE("returning null\n");
177 LeaveCriticalSection(&IMalloc32_SpyCS
);
182 addr
= HeapAlloc(GetProcessHeap(),0,cb
);
185 addr
= IMallocSpy_PostAlloc(Malloc32
.pSpy
, addr
);
186 if (addr
) AddMemoryLocation(addr
);
187 LeaveCriticalSection(&IMalloc32_SpyCS
);
190 TRACE("--(%p)\n",addr
);
194 /******************************************************************************
195 * IMalloc32_Realloc [VTABLE]
197 static LPVOID WINAPI
IMalloc_fnRealloc(LPMALLOC iface
,LPVOID pv
,DWORD cb
) {
201 TRACE("(%p,%ld)\n",pv
,cb
);
207 EnterCriticalSection(&IMalloc32_SpyCS
);
208 fSpyed
= RemoveMemoryLocation(pv
);
209 cb
= IMallocSpy_PreRealloc(Malloc32
.pSpy
, pv
, cb
, &pRealMemory
, fSpyed
);
211 /* check if can release the spy */
212 if(Malloc32
.SpyReleasePending
&& !Malloc32
.SpyedAllocationsLeft
) {
213 IMallocSpy_Release(Malloc32
.pSpy
);
214 Malloc32
.SpyReleasePending
= FALSE
;
215 Malloc32
.pSpy
= NULL
;
219 /* PreRealloc can force Realloc to fail */
220 LeaveCriticalSection(&IMalloc32_SpyCS
);
226 if (!pv
) pNewMemory
= HeapAlloc(GetProcessHeap(),0,cb
);
227 else if (cb
) pNewMemory
= HeapReAlloc(GetProcessHeap(),0,pv
,cb
);
229 HeapFree(GetProcessHeap(),0,pv
);
234 pNewMemory
= IMallocSpy_PostRealloc(Malloc32
.pSpy
, pNewMemory
, TRUE
);
235 if (pNewMemory
) AddMemoryLocation(pNewMemory
);
236 LeaveCriticalSection(&IMalloc32_SpyCS
);
239 TRACE("--(%p)\n",pNewMemory
);
243 /******************************************************************************
244 * IMalloc32_Free [VTABLE]
246 static VOID WINAPI
IMalloc_fnFree(LPMALLOC iface
,LPVOID pv
) {
253 EnterCriticalSection(&IMalloc32_SpyCS
);
254 fSpyed
= RemoveMemoryLocation(pv
);
255 pv
= IMallocSpy_PreFree(Malloc32
.pSpy
, pv
, fSpyed
);
258 HeapFree(GetProcessHeap(),0,pv
);
261 IMallocSpy_PostFree(Malloc32
.pSpy
, fSpyed
);
263 /* check if can release the spy */
264 if(Malloc32
.SpyReleasePending
&& !Malloc32
.SpyedAllocationsLeft
) {
265 IMallocSpy_Release(Malloc32
.pSpy
);
266 Malloc32
.SpyReleasePending
= FALSE
;
267 Malloc32
.pSpy
= NULL
;
270 LeaveCriticalSection(&IMalloc32_SpyCS
);
274 /******************************************************************************
275 * IMalloc32_GetSize [VTABLE]
279 * win95: size allocated (4 byte boundarys)
280 * win2k: size originally requested !!! (allocated on 8 byte boundarys)
282 static DWORD WINAPI
IMalloc_fnGetSize(LPMALLOC iface
,LPVOID pv
) {
290 EnterCriticalSection(&IMalloc32_SpyCS
);
291 pv
= IMallocSpy_PreGetSize(Malloc32
.pSpy
, pv
, fSpyed
);
294 cb
= HeapSize(GetProcessHeap(),0,pv
);
297 cb
= IMallocSpy_PostGetSize(Malloc32
.pSpy
, cb
, fSpyed
);
298 LeaveCriticalSection(&IMalloc32_SpyCS
);
304 /******************************************************************************
305 * IMalloc32_DidAlloc [VTABLE]
307 static INT WINAPI
IMalloc_fnDidAlloc(LPMALLOC iface
,LPVOID pv
) {
315 EnterCriticalSection(&IMalloc32_SpyCS
);
316 pv
= IMallocSpy_PreDidAlloc(Malloc32
.pSpy
, pv
, fSpyed
);
322 didAlloc
= IMallocSpy_PostDidAlloc(Malloc32
.pSpy
, pv
, fSpyed
, didAlloc
);
323 LeaveCriticalSection(&IMalloc32_SpyCS
);
328 /******************************************************************************
329 * IMalloc32_HeapMinimize [VTABLE]
331 static VOID WINAPI
IMalloc_fnHeapMinimize(LPMALLOC iface
) {
335 EnterCriticalSection(&IMalloc32_SpyCS
);
336 IMallocSpy_PreHeapMinimize(Malloc32
.pSpy
);
340 IMallocSpy_PostHeapMinimize(Malloc32
.pSpy
);
341 LeaveCriticalSection(&IMalloc32_SpyCS
);
345 static IMallocVtbl VT_IMalloc32
=
347 IMalloc_fnQueryInterface
,
348 IMalloc_fnAddRefRelease
,
349 IMalloc_fnAddRefRelease
,
355 IMalloc_fnHeapMinimize
358 /******************************************************************************
359 * IMallocSpy implementation
360 *****************************************************************************/
362 /* set the vtable later */
363 static IMallocSpyVtbl VT_IMallocSpy
;
366 IMallocSpyVtbl
*lpVtbl
;
370 /* this is the static object instance */
371 _MallocSpy MallocSpy
= {&VT_IMallocSpy
, 0};
373 /******************************************************************************
374 * IMalloc32_QueryInterface [VTABLE]
376 static HRESULT WINAPI
IMallocSpy_fnQueryInterface(LPMALLOCSPY iface
,REFIID refiid
,LPVOID
*obj
)
379 TRACE("(%s,%p)\n",debugstr_guid(refiid
),obj
);
381 if (IsEqualIID(&IID_IUnknown
,refiid
) || IsEqualIID(&IID_IMallocSpy
,refiid
)) {
382 *obj
= (LPMALLOC
)&MallocSpy
;
385 return E_NOINTERFACE
;
388 /******************************************************************************
389 * IMalloc32_AddRef [VTABLE]
391 static ULONG WINAPI
IMallocSpy_fnAddRef (LPMALLOCSPY iface
)
394 _MallocSpy
*This
= (_MallocSpy
*)iface
;
396 TRACE ("(%p)->(count=%lu)\n", This
, This
->ref
);
398 return ++(This
->ref
);
401 /******************************************************************************
402 * IMalloc32_AddRelease [VTABLE]
405 * Our MallocSpy is static. If the count reaches 0 we dump the leaks
407 static ULONG WINAPI
IMallocSpy_fnRelease (LPMALLOCSPY iface
)
410 _MallocSpy
*This
= (_MallocSpy
*)iface
;
412 TRACE ("(%p)->(count=%lu)\n", This
, This
->ref
);
414 if (!--(This
->ref
)) {
415 /* our allocation list MUST be empty here */
420 static ULONG WINAPI
IMallocSpy_fnPreAlloc(LPMALLOCSPY iface
, ULONG cbRequest
)
422 _MallocSpy
*This
= (_MallocSpy
*)iface
;
423 TRACE ("(%p)->(%lu)\n", This
, cbRequest
);
426 static PVOID WINAPI
IMallocSpy_fnPostAlloc(LPMALLOCSPY iface
, void* pActual
)
428 _MallocSpy
*This
= (_MallocSpy
*)iface
;
429 TRACE ("(%p)->(%p)\n", This
, pActual
);
433 static PVOID WINAPI
IMallocSpy_fnPreFree(LPMALLOCSPY iface
, void* pRequest
, BOOL fSpyed
)
435 _MallocSpy
*This
= (_MallocSpy
*)iface
;
436 TRACE ("(%p)->(%p %u)\n", This
, pRequest
, fSpyed
);
439 static void WINAPI
IMallocSpy_fnPostFree(LPMALLOCSPY iface
, BOOL fSpyed
)
441 _MallocSpy
*This
= (_MallocSpy
*)iface
;
442 TRACE ("(%p)->(%u)\n", This
, fSpyed
);
445 static ULONG WINAPI
IMallocSpy_fnPreRealloc(LPMALLOCSPY iface
, void* pRequest
, ULONG cbRequest
, void** ppNewRequest
, BOOL fSpyed
)
447 _MallocSpy
*This
= (_MallocSpy
*)iface
;
448 TRACE ("(%p)->(%p %lu %u)\n", This
, pRequest
, cbRequest
, fSpyed
);
449 *ppNewRequest
= pRequest
;
453 static PVOID WINAPI
IMallocSpy_fnPostRealloc(LPMALLOCSPY iface
, void* pActual
, BOOL fSpyed
)
455 _MallocSpy
*This
= (_MallocSpy
*)iface
;
456 TRACE ("(%p)->(%p %u)\n", This
, pActual
, fSpyed
);
460 static PVOID WINAPI
IMallocSpy_fnPreGetSize(LPMALLOCSPY iface
, void* pRequest
, BOOL fSpyed
)
462 _MallocSpy
*This
= (_MallocSpy
*)iface
;
463 TRACE ("(%p)->(%p %u)\n", This
, pRequest
, fSpyed
);
467 static ULONG WINAPI
IMallocSpy_fnPostGetSize(LPMALLOCSPY iface
, ULONG cbActual
, BOOL fSpyed
)
469 _MallocSpy
*This
= (_MallocSpy
*)iface
;
470 TRACE ("(%p)->(%lu %u)\n", This
, cbActual
, fSpyed
);
474 static PVOID WINAPI
IMallocSpy_fnPreDidAlloc(LPMALLOCSPY iface
, void* pRequest
, BOOL fSpyed
)
476 _MallocSpy
*This
= (_MallocSpy
*)iface
;
477 TRACE ("(%p)->(%p %u)\n", This
, pRequest
, fSpyed
);
481 static int WINAPI
IMallocSpy_fnPostDidAlloc(LPMALLOCSPY iface
, void* pRequest
, BOOL fSpyed
, int fActual
)
483 _MallocSpy
*This
= (_MallocSpy
*)iface
;
484 TRACE ("(%p)->(%p %u %u)\n", This
, pRequest
, fSpyed
, fActual
);
488 static void WINAPI
IMallocSpy_fnPreHeapMinimize(LPMALLOCSPY iface
)
490 _MallocSpy
*This
= (_MallocSpy
*)iface
;
491 TRACE ("(%p)->()\n", This
);
494 static void WINAPI
IMallocSpy_fnPostHeapMinimize(LPMALLOCSPY iface
)
496 _MallocSpy
*This
= (_MallocSpy
*)iface
;
497 TRACE ("(%p)->()\n", This
);
500 static void MallocSpyDumpLeaks() {
501 TRACE("leaks: %lu\n", Malloc32
.SpyedAllocationsLeft
);
504 static IMallocSpyVtbl VT_IMallocSpy
=
506 IMallocSpy_fnQueryInterface
,
508 IMallocSpy_fnRelease
,
509 IMallocSpy_fnPreAlloc
,
510 IMallocSpy_fnPostAlloc
,
511 IMallocSpy_fnPreFree
,
512 IMallocSpy_fnPostFree
,
513 IMallocSpy_fnPreRealloc
,
514 IMallocSpy_fnPostRealloc
,
515 IMallocSpy_fnPreGetSize
,
516 IMallocSpy_fnPostGetSize
,
517 IMallocSpy_fnPreDidAlloc
,
518 IMallocSpy_fnPostDidAlloc
,
519 IMallocSpy_fnPreHeapMinimize
,
520 IMallocSpy_fnPostHeapMinimize
523 /******************************************************************************
524 * CoGetMalloc [OLE32.@]
529 HRESULT WINAPI
CoGetMalloc(DWORD dwMemContext
, LPMALLOC
*lpMalloc
)
531 *lpMalloc
= (LPMALLOC
)&Malloc32
;
535 /***********************************************************************
536 * CoTaskMemAlloc [OLE32.@]
538 * pointer to newly allocated block
540 LPVOID WINAPI
CoTaskMemAlloc(ULONG size
)
542 return IMalloc_Alloc((LPMALLOC
)&Malloc32
,size
);
544 /***********************************************************************
545 * CoTaskMemFree [OLE32.@]
547 VOID WINAPI
CoTaskMemFree(LPVOID ptr
)
549 IMalloc_Free((LPMALLOC
)&Malloc32
, ptr
);
552 /***********************************************************************
553 * CoTaskMemRealloc [OLE32.@]
555 * pointer to newly allocated block
557 LPVOID WINAPI
CoTaskMemRealloc(LPVOID pvOld
, ULONG size
)
559 return IMalloc_Realloc((LPMALLOC
)&Malloc32
, pvOld
, size
);
562 /***********************************************************************
563 * CoRegisterMallocSpy [OLE32.@]
566 * if a mallocspy is already registered, we can't do it again since
567 * only the spy knows, how to free a memory block
569 HRESULT WINAPI
CoRegisterMallocSpy(LPMALLOCSPY pMallocSpy
)
572 HRESULT hres
= E_INVALIDARG
;
576 /* HACK TO ACTIVATE OUT SPY */
577 if (pMallocSpy
== (LPVOID
)-1) pMallocSpy
=(IMallocSpy
*)&MallocSpy
;
579 if(Malloc32
.pSpy
) return CO_E_OBJISREG
;
581 EnterCriticalSection(&IMalloc32_SpyCS
);
583 if (SUCCEEDED(IUnknown_QueryInterface(pMallocSpy
, &IID_IMallocSpy
, (LPVOID
*)&pSpy
))) {
584 Malloc32
.pSpy
= pSpy
;
588 LeaveCriticalSection(&IMalloc32_SpyCS
);
593 /***********************************************************************
594 * CoRevokeMallocSpy [OLE32.@]
597 * we can't revoke a malloc spy as long as memory blocks allocated with
598 * the spy are active since only the spy knows how to free them
600 HRESULT WINAPI
CoRevokeMallocSpy(void)
605 EnterCriticalSection(&IMalloc32_SpyCS
);
607 /* if it's our spy it's time to dump the leaks */
608 if (Malloc32
.pSpy
== (IMallocSpy
*)&MallocSpy
) {
609 MallocSpyDumpLeaks();
612 if (Malloc32
.SpyedAllocationsLeft
) {
613 TRACE("SpyReleasePending with %lu allocations left\n", Malloc32
.SpyedAllocationsLeft
);
614 Malloc32
.SpyReleasePending
= TRUE
;
615 hres
= E_ACCESSDENIED
;
617 IMallocSpy_Release(Malloc32
.pSpy
);
618 Malloc32
.pSpy
= NULL
;
620 LeaveCriticalSection(&IMalloc32_SpyCS
);
625 /******************************************************************************
626 * IsValidInterface [OLE32.@]
629 * True, if the passed pointer is a valid interface
631 BOOL WINAPI
IsValidInterface(
632 LPUNKNOWN punk
/* [in] interface to be tested */
635 IsBadReadPtr(punk
,4) ||
636 IsBadReadPtr(punk
->lpVtbl
,4) ||
637 IsBadReadPtr(punk
->lpVtbl
->QueryInterface
,9) ||
638 IsBadCodePtr((FARPROC
)punk
->lpVtbl
->QueryInterface
)