1 /*
2 * Win32 heap functions
3 *
4 * Copyright 1995, 1996 Alexandre Julliard
5 * Copyright 1996 Huw Davies
6 * Copyright 1998 Ulrich Weigand
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <limits.h>
28 #include <stdlib.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31 #include <string.h>
32 #include <sys/types.h>
33 #include <time.h>
34 #ifdef HAVE_SYS_PARAM_H
35 #include <sys/param.h>
36 #endif
37 #ifdef HAVE_SYS_SYSCTL_H
38 #include <sys/sysctl.h>
39 #endif
40 #ifdef HAVE_UNISTD_H
41 # include <unistd.h>
42 #endif
43
44 #ifdef sun
45 /* FIXME: Unfortunately swapctl can't be used with largefile.... */
46 # undef _FILE_OFFSET_BITS
47 # define _FILE_OFFSET_BITS 32
48 # ifdef HAVE_SYS_RESOURCE_H
49 # include <sys/resource.h>
50 # endif
51 # ifdef HAVE_SYS_STAT_H
52 # include <sys/stat.h>
53 # endif
54 # include <sys/swap.h>
55 #endif
56
57
58 #include "windef.h"
59 #include "winbase.h"
60 #include "winerror.h"
61 #include "winnt.h"
62 #include "winternl.h"
63 #include "wine/exception.h"
64 #include "wine/debug.h"
65
66 WINE_DEFAULT_DEBUG_CHANNEL(heap);
67
68 /* address where we try to map the system heap */
69 #define SYSTEM_HEAP_BASE ((void*)0x80000000)
70 #define SYSTEM_HEAP_SIZE 0x1000000 /* Default heap size = 16Mb */
71
72 static HANDLE systemHeap; /* globally shared heap */
73
74
75 /***********************************************************************
76 * HEAP_CreateSystemHeap
77 *
78 * Create the system heap.
79 */
80 static inline HANDLE HEAP_CreateSystemHeap(void)
81 {
82 int created;
83 void *base;
84 HANDLE map, event;
85
86 /* create the system heap event first */
87 event = CreateEventA( NULL, TRUE, FALSE, "__wine_system_heap_event" );
88
89 if (!(map = CreateFileMappingA( INVALID_HANDLE_VALUE, NULL, SEC_COMMIT | PAGE_READWRITE,
90 0, SYSTEM_HEAP_SIZE, "__wine_system_heap" ))) return 0;
91 created = (GetLastError() != ERROR_ALREADY_EXISTS);
92
93 if (!(base = MapViewOfFileEx( map, FILE_MAP_ALL_ACCESS, 0, 0, 0, SYSTEM_HEAP_BASE )))
94 {
95 /* pre-defined address not available */
96 ERR( "system heap base address %p not available\n", SYSTEM_HEAP_BASE );
97 return 0;
98 }
99
100 if (created) /* newly created heap */
101 {
102 systemHeap = RtlCreateHeap( HEAP_SHARED, base, SYSTEM_HEAP_SIZE,
103 SYSTEM_HEAP_SIZE, NULL, NULL );
104 SetEvent( event );
105 }
106 else
107 {
108 /* wait for the heap to be initialized */
109 WaitForSingleObject( event, INFINITE );
110 systemHeap = base;
111 }
112 CloseHandle( map );
113 return systemHeap;
114 }
115
116
117 /***********************************************************************
118 * HeapCreate (KERNEL32.@)
119 *
120 * Create a heap object.
121 *
122 * RETURNS
123 * Handle of heap: Success
124 * NULL: Failure
125 */
126 HANDLE WINAPI HeapCreate(
127 DWORD flags, /* [in] Heap allocation flag */
128 SIZE_T initialSize, /* [in] Initial heap size */
129 SIZE_T maxSize /* [in] Maximum heap size */
130 ) {
131 HANDLE ret;
132
133 if ( flags & HEAP_SHARED )
134 {
135 if (!systemHeap) HEAP_CreateSystemHeap();
136 else WARN( "Shared Heap requested, returning system heap.\n" );
137 ret = systemHeap;
138 }
139 else
140 {
141 ret = RtlCreateHeap( flags, NULL, maxSize, initialSize, NULL, NULL );
142 if (!ret) SetLastError( ERROR_NOT_ENOUGH_MEMORY );
143 }
144 return ret;
145 }
146
147
148 /***********************************************************************
149 * HeapDestroy (KERNEL32.@)
150 *
151 * Destroy a heap object.
152 *
153 * RETURNS
154 * TRUE: Success
155 * FALSE: Failure
156 */
157 BOOL WINAPI HeapDestroy( HANDLE heap /* [in] Handle of heap */ )
158 {
159 if (heap == systemHeap)
160 {
161 WARN( "attempt to destroy system heap, returning TRUE!\n" );
162 return TRUE;
163 }
164 if (!RtlDestroyHeap( heap )) return TRUE;
165 SetLastError( ERROR_INVALID_HANDLE );
166 return FALSE;
167 }
168
169
170 /***********************************************************************
171 * HeapCompact (KERNEL32.@)
172 */
173 SIZE_T WINAPI HeapCompact( HANDLE heap, DWORD flags )
174 {
175 return RtlCompactHeap( heap, flags );
176 }
177
178
179 /***********************************************************************
180 * HeapValidate (KERNEL32.@)
181 * Validates a specified heap.
182 *
183 * NOTES
184 * Flags is ignored.
185 *
186 * RETURNS
187 * TRUE: Success
188 * FALSE: Failure
189 */
190 BOOL WINAPI HeapValidate(
191 HANDLE heap, /* [in] Handle to the heap */
192 DWORD flags, /* [in] Bit flags that control access during operation */
193 LPCVOID block /* [in] Optional pointer to memory block to validate */
194 ) {
195 return RtlValidateHeap( heap, flags, block );
196 }
197
198
199 /***********************************************************************
200 * HeapWalk (KERNEL32.@)
201 * Enumerates the memory blocks in a specified heap.
202 *
203 * TODO
204 * - handling of PROCESS_HEAP_ENTRY_MOVEABLE and
205 * PROCESS_HEAP_ENTRY_DDESHARE (needs heap.c support)
206 *
207 * RETURNS
208 * TRUE: Success
209 * FALSE: Failure
210 */
211 BOOL WINAPI HeapWalk(
212 HANDLE heap, /* [in] Handle to heap to enumerate */
213 LPPROCESS_HEAP_ENTRY entry /* [out] Pointer to structure of enumeration info */
214 ) {
215 NTSTATUS ret = RtlWalkHeap( heap, entry );
216 if (ret) SetLastError( RtlNtStatusToDosError(ret) );
217 return !ret;
218 }
219
220
221 /***********************************************************************
222 * HeapLock (KERNEL32.@)
223 * Attempts to acquire the critical section object for a specified heap.
224 *
225 * RETURNS
226 * TRUE: Success
227 * FALSE: Failure
228 */
229 BOOL WINAPI HeapLock(
230 HANDLE heap /* [in] Handle of heap to lock for exclusive access */
231 ) {
232 return RtlLockHeap( heap );
233 }
234
235
236 /***********************************************************************
237 * HeapUnlock (KERNEL32.@)
238 * Releases ownership of the critical section object.
239 *
240 * RETURNS
241 * TRUE: Success
242 * FALSE: Failure
243 */
244 BOOL WINAPI HeapUnlock(
245 HANDLE heap /* [in] Handle to the heap to unlock */
246 ) {
247 return RtlUnlockHeap( heap );
248 }
249
250
251 /***********************************************************************
252 * GetProcessHeap (KERNEL32.@)
253 */
254 HANDLE WINAPI GetProcessHeap(void)
255 {
256 return NtCurrentTeb()->Peb->ProcessHeap;
257 }
258
259
260 /***********************************************************************
261 * GetProcessHeaps (KERNEL32.@)
262 */
263 DWORD WINAPI GetProcessHeaps( DWORD count, HANDLE *heaps )
264 {
265 return RtlGetProcessHeaps( count, heaps );
266 }
267
268
269 /* These are needed so that we can call the functions from inside kernel itself */
270
271 /***********************************************************************
272 * HeapAlloc (KERNEL32.@)
273 */
274 LPVOID WINAPI HeapAlloc( HANDLE heap, DWORD flags, SIZE_T size )
275 {
276 return RtlAllocateHeap( heap, flags, size );
277 }
278
279 BOOL WINAPI HeapFree( HANDLE heap, DWORD flags, LPVOID ptr )
280 {
281 return RtlFreeHeap( heap, flags, ptr );
282 }
283
284 LPVOID WINAPI HeapReAlloc( HANDLE heap, DWORD flags, LPVOID ptr, SIZE_T size )
285 {
286 return RtlReAllocateHeap( heap, flags, ptr, size );
287 }
288
289 SIZE_T WINAPI HeapSize( HANDLE heap, DWORD flags, LPCVOID ptr )
290 {
291 return RtlSizeHeap( heap, flags, ptr );
292 }
293
294 BOOL WINAPI HeapSetInformation( HANDLE heap, HEAP_INFORMATION_CLASS infoclass, PVOID info, SIZE_T size)
295 {
296 FIXME("%p %d %p %ld\n", heap, infoclass, info, size );
297 return TRUE;
298 }
299
300 /*
301 * Win32 Global heap functions (GlobalXXX).
302 * These functions included in Win32 for compatibility with 16 bit Windows
303 * Especially the moveable blocks and handles are oldish.
304 * But the ability to directly allocate memory with GPTR and LPTR is widely
305 * used.
306 *
307 * The handle stuff looks horrible, but it's implemented almost like Win95
308 * does it.
309 *
310 */
311
312 #define MAGIC_GLOBAL_USED 0x5342
313 #define HANDLE_TO_INTERN(h) ((PGLOBAL32_INTERN)(((char *)(h))-2))
314 #define INTERN_TO_HANDLE(i) ((HGLOBAL) &((i)->Pointer))
315 #define POINTER_TO_HANDLE(p) (*(((const HGLOBAL *)(p))-2))
316 #define ISHANDLE(h) (((ULONG_PTR)(h)&2)!=0)
317 #define ISPOINTER(h) (((ULONG_PTR)(h)&2)==0)
318 /* align the storage needed for the HGLOBAL on an 8byte boundary thus
319 * GlobalAlloc/GlobalReAlloc'ing with GMEM_MOVEABLE of memory with
320 * size = 8*k, where k=1,2,3,... alloc's exactly the given size.
321 * The Minolta DiMAGE Image Viewer heavily relies on this, corrupting
322 * the output jpeg's > 1 MB if not */
323 #define HGLOBAL_STORAGE 8 /* sizeof(HGLOBAL)*2 */
324
325 #include "pshpack1.h"
326
327 typedef struct __GLOBAL32_INTERN
328 {
329 WORD Magic;
330 LPVOID Pointer;
331 BYTE Flags;
332 BYTE LockCount;
333 } GLOBAL32_INTERN, *PGLOBAL32_INTERN;
334
335 #include "poppack.h"
336
337 /***********************************************************************
338 * GlobalAlloc (KERNEL32.@)
339 *
340 * Allocate a global memory object.
341 *
342 * RETURNS
343 * Handle: Success
344 * NULL: Failure
345 */
346 HGLOBAL WINAPI GlobalAlloc(
347 UINT flags, /* [in] Object allocation attributes */
348 SIZE_T size /* [in] Number of bytes to allocate */
349 ) {
350 PGLOBAL32_INTERN pintern;
351 DWORD hpflags;
352 LPVOID palloc;
353
354 if(flags&GMEM_ZEROINIT)
355 hpflags=HEAP_ZERO_MEMORY;
356 else
357 hpflags=0;
358
359 if((flags & GMEM_MOVEABLE)==0) /* POINTER */
360 {
361 palloc=HeapAlloc(GetProcessHeap(), hpflags, size);
362 TRACE( "(flags=%04x) returning %p\n", flags, palloc );
363 return palloc;
364 }
365 else /* HANDLE */
366 {
367 if (size > INT_MAX-HGLOBAL_STORAGE)
368 {
369 SetLastError(ERROR_OUTOFMEMORY);
370 return 0;
371 }
372
373 RtlLockHeap(GetProcessHeap());
374
375 pintern = HeapAlloc(GetProcessHeap(), 0, sizeof(GLOBAL32_INTERN));
376 if (pintern)
377 {
378 pintern->Magic = MAGIC_GLOBAL_USED;
379 pintern->Flags = flags >> 8;
380 pintern->LockCount = 0;
381
382 if (size)
383 {
384 palloc = HeapAlloc(GetProcessHeap(), hpflags, size+HGLOBAL_STORAGE);
385 if (!palloc)
386 {
387 HeapFree(GetProcessHeap(), 0, pintern);
388 pintern = NULL;
389 }
390 else
391 {
392 *(HGLOBAL *)palloc = INTERN_TO_HANDLE(pintern);
393 pintern->Pointer = (char *)palloc + HGLOBAL_STORAGE;
394 }
395 }
396 else
397 pintern->Pointer = NULL;
398 }
399
400 RtlUnlockHeap(GetProcessHeap());
401 if (!pintern) return 0;
402 TRACE( "(flags=%04x) returning handle %p pointer %p\n",
403 flags, INTERN_TO_HANDLE(pintern), pintern->Pointer );
404 return INTERN_TO_HANDLE(pintern);
405 }
406 }
407
408
409 /***********************************************************************
410 * GlobalLock (KERNEL32.@)
411 *
412 * Lock a global memory object and return a pointer to first byte of the memory
413 *
414 * PARAMS
415 * hmem [I] Handle of the global memory object
416 *
417 * RETURNS
418 * Success: Pointer to first byte of the memory block
419 * Failure: NULL
420 *
421 * NOTES
422 * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
423 *
424 */
425 LPVOID WINAPI GlobalLock(HGLOBAL hmem)
426 {
427 PGLOBAL32_INTERN pintern;
428 LPVOID palloc;
429
430 if (ISPOINTER(hmem))
431 return IsBadReadPtr(hmem, 1) ? NULL : hmem;
432
433 RtlLockHeap(GetProcessHeap());
434 __TRY
435 {
436 pintern = HANDLE_TO_INTERN(hmem);
437 if (pintern->Magic == MAGIC_GLOBAL_USED)
438 {
439 palloc = pintern->Pointer;
440 if (!pintern->Pointer)
441 SetLastError(ERROR_DISCARDED);
442 else if (pintern->LockCount < GMEM_LOCKCOUNT)
443 pintern->LockCount++;
444 }
445 else
446 {
447 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
448 palloc = NULL;
449 SetLastError(ERROR_INVALID_HANDLE);
450 }
451 }
452 __EXCEPT_PAGE_FAULT
453 {
454 WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem);
455 palloc = NULL;
456 SetLastError(ERROR_INVALID_HANDLE);
457 }
458 __ENDTRY
459 RtlUnlockHeap(GetProcessHeap());
460 return palloc;
461 }
462
463
464 /***********************************************************************
465 * GlobalUnlock (KERNEL32.@)
466 *
467 * Unlock a global memory object.
468 *
469 * PARAMS
470 * hmem [I] Handle of the global memory object
471 *
472 * RETURNS
473 * Success: Object is still locked
474 * Failure: FALSE (The Object is unlocked)
475 *
476 * NOTES
477 * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
478 *
479 */
480 BOOL WINAPI GlobalUnlock(HGLOBAL hmem)
481 {
482 PGLOBAL32_INTERN pintern;
483 BOOL locked;
484
485 if (ISPOINTER(hmem)) return TRUE;
486
487 RtlLockHeap(GetProcessHeap());
488 __TRY
489 {
490 pintern=HANDLE_TO_INTERN(hmem);
491 if(pintern->Magic==MAGIC_GLOBAL_USED)
492 {
493 if(pintern->LockCount)
494 {
495 pintern->LockCount--;
496 locked = (pintern->LockCount != 0);
497 if (!locked) SetLastError(NO_ERROR);
498 }
499 else
500 {
501 WARN("%p not locked\n", hmem);
502 SetLastError(ERROR_NOT_LOCKED);
503 locked = FALSE;
504 }
505 }
506 else
507 {
508 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
509 SetLastError(ERROR_INVALID_HANDLE);
510 locked=FALSE;
511 }
512 }
513 __EXCEPT_PAGE_FAULT
514 {
515 WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem);
516 SetLastError( ERROR_INVALID_PARAMETER );
517 locked=FALSE;
518 }
519 __ENDTRY
520 RtlUnlockHeap(GetProcessHeap());
521 return locked;
522 }
523
524
525 /***********************************************************************
526 * GlobalHandle (KERNEL32.@)
527 *
528 * Get the handle associated with the pointer to a global memory block.
529 *
530 * RETURNS
531 * Handle: Success
532 * NULL: Failure
533 */
534 HGLOBAL WINAPI GlobalHandle(
535 LPCVOID pmem /* [in] Pointer to global memory block */
536 ) {
537 HGLOBAL handle;
538 PGLOBAL32_INTERN maybe_intern;
539 LPCVOID test;
540
541 if (!pmem)
542 {
543 SetLastError( ERROR_INVALID_PARAMETER );
544 return 0;
545 }
546
547 RtlLockHeap(GetProcessHeap());
548 __TRY
549 {
550 handle = 0;
551
552 /* note that if pmem is a pointer to a block allocated by */
553 /* GlobalAlloc with GMEM_MOVEABLE then magic test in HeapValidate */
554 /* will fail. */
555 if (ISPOINTER(pmem)) {
556 if (HeapValidate( GetProcessHeap(), 0, pmem )) {
557 handle = (HGLOBAL)pmem; /* valid fixed block */
558 break;
559 }
560 handle = POINTER_TO_HANDLE(pmem);
561 } else
562 handle = (HGLOBAL)pmem;
563
564 /* Now test handle either passed in or retrieved from pointer */
565 maybe_intern = HANDLE_TO_INTERN( handle );
566 if (maybe_intern->Magic == MAGIC_GLOBAL_USED) {
567 test = maybe_intern->Pointer;
568 if (HeapValidate( GetProcessHeap(), 0, (const char *)test - HGLOBAL_STORAGE ) && /* obj(-handle) valid arena? */
569 HeapValidate( GetProcessHeap(), 0, maybe_intern )) /* intern valid arena? */
570 break; /* valid moveable block */
571 }
572 handle = 0;
573 SetLastError( ERROR_INVALID_HANDLE );
574 }
575 __EXCEPT_PAGE_FAULT
576 {
577 SetLastError( ERROR_INVALID_HANDLE );
578 handle = 0;
579 }
580 __ENDTRY
581 RtlUnlockHeap(GetProcessHeap());
582
583 return handle;
584 }
585
586
587 /***********************************************************************
588 * GlobalReAlloc (KERNEL32.@)
589 *
590 * Change the size or attributes of a global memory object.
591 *
592 * RETURNS
593 * Handle: Success
594 * NULL: Failure
595 */
596 HGLOBAL WINAPI GlobalReAlloc(
597 HGLOBAL hmem, /* [in] Handle of global memory object */
598 SIZE_T size, /* [in] New size of block */
599 UINT flags /* [in] How to reallocate object */
600 ) {
601 LPVOID palloc;
602 HGLOBAL hnew;
603 PGLOBAL32_INTERN pintern;
604 DWORD heap_flags = (flags & GMEM_ZEROINIT) ? HEAP_ZERO_MEMORY : 0;
605
606 hnew = 0;
607 RtlLockHeap(GetProcessHeap());
608 if(flags & GMEM_MODIFY) /* modify flags */
609 {
610 if( ISPOINTER(hmem) && (flags & GMEM_MOVEABLE))
611 {
612 /* make a fixed block moveable
613 * actually only NT is able to do this. But it's soo simple
614 */
615 if (hmem == 0)
616 {
617 WARN("GlobalReAlloc with null handle!\n");
618 SetLastError( ERROR_NOACCESS );
619 hnew = 0;
620 }
621 else
622 {
623 size = HeapSize(GetProcessHeap(), 0, hmem);
624 hnew = GlobalAlloc(flags, size);
625 palloc = GlobalLock(hnew);
626 memcpy(palloc, hmem, size);
627 GlobalUnlock(hnew);
628 GlobalFree(hmem);
629 }
630 }
631 else if( ISPOINTER(hmem) &&(flags & GMEM_DISCARDABLE))
632 {
633 /* change the flags to make our block "discardable" */
634 pintern=HANDLE_TO_INTERN(hmem);
635 pintern->Flags = pintern->Flags | (GMEM_DISCARDABLE >> 8);
636 hnew=hmem;
637 }
638 else
639 {
640 SetLastError(ERROR_INVALID_PARAMETER);
641 hnew = 0;
642 }
643 }
644 else
645 {
646 if(ISPOINTER(hmem))
647 {
648 /* reallocate fixed memory */
649 hnew=HeapReAlloc(GetProcessHeap(), heap_flags, hmem, size);
650 }
651 else
652 {
653 /* reallocate a moveable block */
654 pintern=HANDLE_TO_INTERN(hmem);
655
656 #if 0
657 /* Apparently Windows doesn't care whether the handle is locked at this point */
658 /* See also the same comment in GlobalFree() */
659 if(pintern->LockCount>1) {
660 ERR("handle 0x%08lx is still locked, cannot realloc!\n",(DWORD)hmem);
661 SetLastError(ERROR_INVALID_HANDLE);
662 } else
663 #endif
664 if(size!=0)
665 {
666 hnew=hmem;
667 if(pintern->Pointer)
668 {
669 if(size > INT_MAX-HGLOBAL_STORAGE)
670 {
671 SetLastError(ERROR_OUTOFMEMORY);
672 hnew = 0;
673 }
674 else if((palloc = HeapReAlloc(GetProcessHeap(), heap_flags,
675 (char *) pintern->Pointer-HGLOBAL_STORAGE,
676 size+HGLOBAL_STORAGE)) == NULL)
677 hnew = 0; /* Block still valid */
678 else
679 pintern->Pointer = (char *)palloc+HGLOBAL_STORAGE;
680 }
681 else
682 {
683 if(size > INT_MAX-HGLOBAL_STORAGE)
684 {
685 SetLastError(ERROR_OUTOFMEMORY);
686 hnew = 0;
687 }
688 else if((palloc=HeapAlloc(GetProcessHeap(), heap_flags, size+HGLOBAL_STORAGE))
689 == NULL)
690 hnew = 0;
691 else
692 {
693 *(HGLOBAL *)palloc = hmem;
694 pintern->Pointer = (char *)palloc + HGLOBAL_STORAGE;
695 }
696 }
697 }
698 else
699 {
700 if (pintern->LockCount == 0)
701 {
702 if(pintern->Pointer)
703 {
704 HeapFree(GetProcessHeap(), 0, (char *) pintern->Pointer-HGLOBAL_STORAGE);
705 pintern->Pointer = NULL;
706 }
707 hnew = hmem;
708 }
709 else
710 WARN("not freeing memory associated with locked handle\n");
711 }
712 }
713 }
714 RtlUnlockHeap(GetProcessHeap());
715 return hnew;
716 }
717
718
719 /***********************************************************************
720 * GlobalFree (KERNEL32.@)
721 *
722 * Free a global memory object.
723 *
724 * PARAMS
725 * hmem [I] Handle of the global memory object
726 *
727 * RETURNS
728 * Success: NULL
729 * Failure: The provided handle
730 *
731 * NOTES
732 * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
733 *
734 */
735 HGLOBAL WINAPI GlobalFree(HGLOBAL hmem)
736 {
737 PGLOBAL32_INTERN pintern;
738 HGLOBAL hreturned;
739
740 RtlLockHeap(GetProcessHeap());
741 __TRY
742 {
743 hreturned = 0;
744 if(ISPOINTER(hmem)) /* POINTER */
745 {
746 if(!HeapFree(GetProcessHeap(), 0, hmem))
747 {
748 SetLastError(ERROR_INVALID_HANDLE);
749 hreturned = hmem;
750 }
751 }
752 else /* HANDLE */
753 {
754 pintern=HANDLE_TO_INTERN(hmem);
755
756 if(pintern->Magic==MAGIC_GLOBAL_USED)
757 {
758 pintern->Magic = 0xdead;
759
760 /* WIN98 does not make this test. That is you can free a */
761 /* block you have not unlocked. Go figure!! */
762 /* if(pintern->LockCount!=0) */
763 /* SetLastError(ERROR_INVALID_HANDLE); */
764
765 if(pintern->Pointer)
766 if(!HeapFree(GetProcessHeap(), 0, (char *)(pintern->Pointer)-HGLOBAL_STORAGE))
767 hreturned=hmem;
768 if(!HeapFree(GetProcessHeap(), 0, pintern))
769 hreturned=hmem;
770 }
771 else
772 {
773 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
774 SetLastError(ERROR_INVALID_HANDLE);
775 hreturned = hmem;
776 }
777 }
778 }
779 __EXCEPT_PAGE_FAULT
780 {
781 ERR("(%p): Page fault occurred ! Caused by bug ?\n", hmem);
782 SetLastError( ERROR_INVALID_PARAMETER );
783 hreturned = hmem;
784 }
785 __ENDTRY
786 RtlUnlockHeap(GetProcessHeap());
787 return hreturned;
788 }
789
790
791 /***********************************************************************
792 * GlobalSize (KERNEL32.@)
793 *
794 * Get the size of a global memory object.
795 *
796 * PARAMS
797 * hmem [I] Handle of the global memory object
798 *
799 * RETURNS
800 * Failure: 0
801 * Success: Size in Bytes of the global memory object
802 *
803 * NOTES
804 * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
805 *
806 */
807 SIZE_T WINAPI GlobalSize(HGLOBAL hmem)
808 {
809 DWORD retval;
810 PGLOBAL32_INTERN pintern;
811
812 if (!((ULONG_PTR)hmem >> 16))
813 {
814 SetLastError(ERROR_INVALID_HANDLE);
815 return 0;
816 }
817
818 if(ISPOINTER(hmem))
819 {
820 retval=HeapSize(GetProcessHeap(), 0, hmem);
821 }
822 else
823 {
824 RtlLockHeap(GetProcessHeap());
825 pintern=HANDLE_TO_INTERN(hmem);
826
827 if(pintern->Magic==MAGIC_GLOBAL_USED)
828 {
829 if (!pintern->Pointer) /* handle case of GlobalAlloc( ??,0) */
830 retval = 0;
831 else
832 {
833 retval = HeapSize(GetProcessHeap(), 0,
834 (char *)(pintern->Pointer) - HGLOBAL_STORAGE );
835 if (retval != (DWORD)-1) retval -= HGLOBAL_STORAGE;
836 }
837 }
838 else
839 {
840 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
841 SetLastError(ERROR_INVALID_HANDLE);
842 retval=0;
843 }
844 RtlUnlockHeap(GetProcessHeap());
845 }
846 /* HeapSize returns 0xffffffff on failure */
847 if (retval == 0xffffffff) retval = 0;
848 return retval;
849 }
850
851
852 /***********************************************************************
853 * GlobalWire (KERNEL32.@)
854 */
855 LPVOID WINAPI GlobalWire(HGLOBAL hmem)
856 {
857 return GlobalLock( hmem );
858 }
859
860
861 /***********************************************************************
862 * GlobalUnWire (KERNEL32.@)
863 */
864 BOOL WINAPI GlobalUnWire(HGLOBAL hmem)
865 {
866 return GlobalUnlock( hmem);
867 }
868
869
870 /***********************************************************************
871 * GlobalFix (KERNEL32.@)
872 */
873 VOID WINAPI GlobalFix(HGLOBAL hmem)
874 {
875 GlobalLock( hmem );
876 }
877
878
879 /***********************************************************************
880 * GlobalUnfix (KERNEL32.@)
881 */
882 VOID WINAPI GlobalUnfix(HGLOBAL hmem)
883 {
884 GlobalUnlock( hmem);
885 }
886
887
888 /***********************************************************************
889 * GlobalFlags (KERNEL32.@)
890 *
891 * Get information about a global memory object.
892 *
893 * PARAMS
894 * hmem [I] Handle of the global memory object
895 *
896 * RETURNS
897 * Failure: GMEM_INVALID_HANDLE, when the provided handle is invalid
898 * Success: Value specifying allocation flags and lock count
899 *
900 */
901 UINT WINAPI GlobalFlags(HGLOBAL hmem)
902 {
903 DWORD retval;
904 PGLOBAL32_INTERN pintern;
905
906 if(ISPOINTER(hmem))
907 {
908 retval=0;
909 }
910 else
911 {
912 RtlLockHeap(GetProcessHeap());
913 pintern=HANDLE_TO_INTERN(hmem);
914 if(pintern->Magic==MAGIC_GLOBAL_USED)
915 {
916 retval=pintern->LockCount + (pintern->Flags<<8);
917 if(pintern->Pointer==0)
918 retval|= GMEM_DISCARDED;
919 }
920 else
921 {
922 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
923 SetLastError(ERROR_INVALID_HANDLE);
924 retval = GMEM_INVALID_HANDLE;
925 }
926 RtlUnlockHeap(GetProcessHeap());
927 }
928 return retval;
929 }
930
931
932 /***********************************************************************
933 * GlobalCompact (KERNEL32.@)
934 */
935 SIZE_T WINAPI GlobalCompact( DWORD minfree )
936 {
937 return 0; /* GlobalCompact does nothing in Win32 */
938 }
939
940
941 /***********************************************************************
942 * LocalAlloc (KERNEL32.@)
943 *
944 * Allocate a local memory object.
945 *
946 * RETURNS
947 * Handle: Success
948 * NULL: Failure
949 *
950 * NOTES
951 * Windows memory management does not provide a separate local heap
952 * and global heap.
953 */
954 HLOCAL WINAPI LocalAlloc(
955 UINT flags, /* [in] Allocation attributes */
956 SIZE_T size /* [in] Number of bytes to allocate */
957 ) {
958 return GlobalAlloc( flags, size );
959 }
960
961
962 /***********************************************************************
963 * LocalCompact (KERNEL32.@)
964 */
965 SIZE_T WINAPI LocalCompact( UINT minfree )
966 {
967 return 0; /* LocalCompact does nothing in Win32 */
968 }
969
970
971 /***********************************************************************
972 * LocalFlags (KERNEL32.@)
973 *
974 * Get information about a local memory object.
975 *
976 * RETURNS
977 * Value specifying allocation flags and lock count.
978 * LMEM_INVALID_HANDLE: Failure
979 *
980 * NOTES
981 * Windows memory management does not provide a separate local heap
982 * and global heap.
983 */
984 UINT WINAPI LocalFlags(
985 HLOCAL handle /* [in] Handle of memory object */
986 ) {
987 return GlobalFlags( handle );
988 }
989
990
991 /***********************************************************************
992 * LocalFree (KERNEL32.@)
993 *
994 * Free a local memory object.
995 *
996 * RETURNS
997 * NULL: Success
998 * Handle: Failure
999 *
1000 * NOTES
1001 * Windows memory management does not provide a separate local heap
1002 * and global heap.
1003 */
1004 HLOCAL WINAPI LocalFree(
1005 HLOCAL handle /* [in] Handle of memory object */
1006 ) {
1007 return GlobalFree( handle );
1008 }
1009
1010
1011 /***********************************************************************
1012 * LocalHandle (KERNEL32.@)
1013 *
1014 * Get the handle associated with the pointer to a local memory block.
1015 *
1016 * RETURNS
1017 * Handle: Success
1018 * NULL: Failure
1019 *
1020 * NOTES
1021 * Windows memory management does not provide a separate local heap
1022 * and global heap.
1023 */
1024 HLOCAL WINAPI LocalHandle(
1025 LPCVOID ptr /* [in] Address of local memory block */
1026 ) {
1027 return GlobalHandle( ptr );
1028 }
1029
1030
1031 /***********************************************************************
1032 * LocalLock (KERNEL32.@)
1033 * Locks a local memory object and returns pointer to the first byte
1034 * of the memory block.
1035 *
1036 * RETURNS
1037 * Pointer: Success
1038 * NULL: Failure
1039 *
1040 * NOTES
1041 * Windows memory management does not provide a separate local heap
1042 * and global heap.
1043 */
1044 LPVOID WINAPI LocalLock(
1045 HLOCAL handle /* [in] Address of local memory object */
1046 ) {
1047 return GlobalLock( handle );
1048 }
1049
1050
1051 /***********************************************************************
1052 * LocalReAlloc (KERNEL32.@)
1053 *
1054 * Change the size or attributes of a local memory object.
1055 *
1056 * RETURNS
1057 * Handle: Success
1058 * NULL: Failure
1059 *
1060 * NOTES
1061 * Windows memory management does not provide a separate local heap
1062 * and global heap.
1063 */
1064 HLOCAL WINAPI LocalReAlloc(
1065 HLOCAL handle, /* [in] Handle of memory object */
1066 SIZE_T size, /* [in] New size of block */
1067 UINT flags /* [in] How to reallocate object */
1068 ) {
1069 return GlobalReAlloc( handle, size, flags );
1070 }
1071
1072
1073 /***********************************************************************
1074 * LocalShrink (KERNEL32.@)
1075 */
1076 SIZE_T WINAPI LocalShrink( HGLOBAL handle, UINT newsize )
1077 {
1078 return 0; /* LocalShrink does nothing in Win32 */
1079 }
1080
1081
1082 /***********************************************************************
1083 * LocalSize (KERNEL32.@)
1084 *
1085 * Get the size of a local memory object.
1086 *
1087 * RETURNS
1088 * Size: Success
1089 * 0: Failure
1090 *
1091 * NOTES
1092 * Windows memory management does not provide a separate local heap
1093 * and global heap.
1094 */
1095 SIZE_T WINAPI LocalSize(
1096 HLOCAL handle /* [in] Handle of memory object */
1097 ) {
1098 return GlobalSize( handle );
1099 }
1100
1101
1102 /***********************************************************************
1103 * LocalUnlock (KERNEL32.@)
1104 *
1105 * Unlock a local memory object.
1106 *
1107 * RETURNS
1108 * TRUE: Object is still locked
1109 * FALSE: Object is unlocked
1110 *
1111 * NOTES
1112 * Windows memory management does not provide a separate local heap
1113 * and global heap.
1114 */
1115 BOOL WINAPI LocalUnlock(
1116 HLOCAL handle /* [in] Handle of memory object */
1117 ) {
1118 return GlobalUnlock( handle );
1119 }
1120
1121
1122 /**********************************************************************
1123 * AllocMappedBuffer (KERNEL32.38)
1124 *
1125 * This is an undocumented KERNEL32 function that
1126 * SMapLS's a GlobalAlloc'ed buffer.
1127 *
1128 * RETURNS
1129 * EDI register: pointer to buffer
1130 *
1131 * NOTES
1132 * The buffer is preceded by 8 bytes:
1133 * ...
1134 * edi+0 buffer
1135 * edi-4 SEGPTR to buffer
1136 * edi-8 some magic Win95 needs for SUnMapLS
1137 * (we use it for the memory handle)
1138 *
1139 * The SEGPTR is used by the caller!
1140 */
1141 void WINAPI __regs_AllocMappedBuffer(
1142 CONTEXT86 *context /* [in] EDI register: size of buffer to allocate */
1143 ) {
1144 HGLOBAL handle = GlobalAlloc(0, context->Edi + 8);
1145 DWORD *buffer = (DWORD *)GlobalLock(handle);
1146 DWORD ptr = 0;
1147
1148 if (buffer)
1149 if (!(ptr = MapLS(buffer + 2)))
1150 {
1151 GlobalUnlock(handle);
1152 GlobalFree(handle);
1153 }
1154
1155 if (!ptr)
1156 context->Eax = context->Edi = 0;
1157 else
1158 {
1159 buffer[0] = (DWORD)handle;
1160 buffer[1] = ptr;
1161
1162 context->Eax = ptr;
1163 context->Edi = (DWORD)(buffer + 2);
1164 }
1165 }
1166 #ifdef DEFINE_REGS_ENTRYPOINT
1167 DEFINE_REGS_ENTRYPOINT( AllocMappedBuffer, 0, 0 )
1168 #endif
1169
1170 /**********************************************************************
1171 * FreeMappedBuffer (KERNEL32.39)
1172 *
1173 * Free a buffer allocated by AllocMappedBuffer
1174 *
1175 * RETURNS
1176 * Nothing.
1177 */
1178 void WINAPI __regs_FreeMappedBuffer(
1179 CONTEXT86 *context /* [in] EDI register: pointer to buffer */
1180 ) {
1181 if (context->Edi)
1182 {
1183 DWORD *buffer = (DWORD *)context->Edi - 2;
1184
1185 UnMapLS(buffer[1]);
1186
1187 GlobalUnlock((HGLOBAL)buffer[0]);
1188 GlobalFree((HGLOBAL)buffer[0]);
1189 }
1190 }
1191 #ifdef DEFINE_REGS_ENTRYPOINT
1192 DEFINE_REGS_ENTRYPOINT( FreeMappedBuffer, 0, 0 )
1193 #endif
1194
1195 /***********************************************************************
1196 * GlobalMemoryStatusEx (KERNEL32.@)
1197 * A version of GlobalMemoryStatus that can deal with memory over 4GB
1198 *
1199 * RETURNS
1200 * TRUE
1201 */
1202 BOOL WINAPI GlobalMemoryStatusEx( LPMEMORYSTATUSEX lpmemex )
1203 {
1204 static MEMORYSTATUSEX cached_memstatus;
1205 static int cache_lastchecked = 0;
1206 SYSTEM_INFO si;
1207 #ifdef linux
1208 FILE *f;
1209 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__)
1210 unsigned long val;
1211 int mib[2];
1212 size_t size_sys;
1213 #elif defined(__APPLE__)
1214 unsigned int val;
1215 int mib[2];
1216 size_t size_sys;
1217 #elif defined(sun)
1218 unsigned long pagesize,maxpages,freepages,swapspace,swapfree;
1219 struct anoninfo swapinf;
1220 int rval;
1221 #endif
1222
1223 if (lpmemex->dwLength != sizeof(*lpmemex))
1224 {
1225 SetLastError( ERROR_INVALID_PARAMETER );
1226 return FALSE;
1227 }
1228
1229 if (time(NULL)==cache_lastchecked) {
1230 *lpmemex = cached_memstatus;
1231 return TRUE;
1232 }
1233 cache_lastchecked = time(NULL);
1234
1235 lpmemex->dwMemoryLoad = 0;
1236 lpmemex->ullTotalPhys = 16*1024*1024;
1237 lpmemex->ullAvailPhys = 16*1024*1024;
1238 lpmemex->ullTotalPageFile = 16*1024*1024;
1239 lpmemex->ullAvailPageFile = 16*1024*1024;
1240
1241 #ifdef linux
1242 f = fopen( "/proc/meminfo", "r" );
1243 if (f)
1244 {
1245 char buffer[256];
1246 unsigned long total, used, free, shared, buffers, cached;
1247
1248 lpmemex->ullTotalPhys = lpmemex->ullAvailPhys = 0;
1249 lpmemex->ullTotalPageFile = lpmemex->ullAvailPageFile = 0;
1250 while (fgets( buffer, sizeof(buffer), f ))
1251 {
1252 /* old style /proc/meminfo ... */
1253 if (sscanf( buffer, "Mem: %lu %lu %lu %lu %lu %lu",
1254 &total, &used, &free, &shared, &buffers, &cached ))
1255 {
1256 lpmemex->ullTotalPhys += total;
1257 lpmemex->ullAvailPhys += free + buffers + cached;
1258 }
1259 if (sscanf( buffer, "Swap: %lu %lu %lu", &total, &used, &free ))
1260 {
1261 lpmemex->ullTotalPageFile += total;
1262 lpmemex->ullAvailPageFile += free;
1263 }
1264
1265 /* new style /proc/meminfo ... */
1266 if (sscanf(buffer, "MemTotal: %lu", &total))
1267 lpmemex->ullTotalPhys = total*1024;
1268 if (sscanf(buffer, "MemFree: %lu", &free))
1269 lpmemex->ullAvailPhys = free*1024;
1270 if (sscanf(buffer, "SwapTotal: %lu", &total))
1271 lpmemex->ullTotalPageFile = total*1024;
1272 if (sscanf(buffer, "SwapFree: %lu", &free))
1273 lpmemex->ullAvailPageFile = free*1024;
1274 if (sscanf(buffer, "Buffers: %lu", &buffers))
1275 lpmemex->ullAvailPhys += buffers*1024;
1276 if (sscanf(buffer, "Cached: %lu", &cached))
1277 lpmemex->ullAvailPhys += cached*1024;
1278 }
1279 fclose( f );
1280 }
1281 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__APPLE__)
1282 mib[0] = CTL_HW;
1283 mib[1] = HW_PHYSMEM;
1284 size_sys = sizeof(val);
1285 sysctl(mib, 2, &val, &size_sys, NULL, 0);
1286 if (val) lpmemex->ullTotalPhys = val;
1287 mib[1] = HW_USERMEM;
1288 size_sys = sizeof(val);
1289 sysctl(mib, 2, &val, &size_sys, NULL, 0);
1290 if (!val) val = lpmemex->ullTotalPhys;
1291 lpmemex->ullAvailPhys = val;
1292 lpmemex->ullTotalPageFile = val;
1293 lpmemex->ullAvailPageFile = val;
1294 #elif defined ( sun )
1295 pagesize=sysconf(_SC_PAGESIZE);
1296 maxpages=sysconf(_SC_PHYS_PAGES);
1297 freepages=sysconf(_SC_AVPHYS_PAGES);
1298 rval=swapctl(SC_AINFO, &swapinf);
1299 if(rval >-1)
1300 {
1301 swapspace=swapinf.ani_max*pagesize;
1302 swapfree=swapinf.ani_free*pagesize;
1303 }else
1304 {
1305
1306 WARN("Swap size cannot be determined , assuming equal to physical memory\n");
1307 swapspace=maxpages*pagesize;
1308 swapfree=maxpages*pagesize;
1309 }
1310 lpmemex->ullTotalPhys=pagesize*maxpages;
1311 lpmemex->ullAvailPhys = pagesize*freepages;
1312 lpmemex->ullTotalPageFile = swapspace;
1313 lpmemex->ullAvailPageFile = swapfree;
1314 #endif
1315
1316 if (lpmemex->ullTotalPhys)
1317 {
1318 lpmemex->dwMemoryLoad = (lpmemex->ullTotalPhys-lpmemex->ullAvailPhys)
1319 / (lpmemex->ullTotalPhys / 100);
1320 }
1321
1322 /* Win98 returns only the swapsize in ullTotalPageFile/ullAvailPageFile,
1323 WinXP returns the size of physical memory + swapsize;
1324 mimic the behavior of XP.
1325 Note: Project2k refuses to start if it sees less than 1Mb of free swap.
1326 */
1327 lpmemex->ullTotalPageFile += lpmemex->ullTotalPhys;
1328 lpmemex->ullAvailPageFile += lpmemex->ullAvailPhys;
1329
1330 /* Titan Quest refuses to run if TotalPageFile <= ullTotalPhys */
1331 if(lpmemex->ullTotalPageFile == lpmemex->ullTotalPhys)
1332 {
1333 lpmemex->ullTotalPhys -= 1;
1334 lpmemex->ullAvailPhys -= 1;
1335 }
1336
1337 /* FIXME: should do something for other systems */
1338 GetSystemInfo(&si);
1339 lpmemex->ullTotalVirtual = (char*)si.lpMaximumApplicationAddress-(char*)si.lpMinimumApplicationAddress;
1340 /* FIXME: we should track down all the already allocated VM pages and substract them, for now arbitrarily remove 64KB so that it matches NT */
1341 lpmemex->ullAvailVirtual = lpmemex->ullTotalVirtual-64*1024;
1342
1343 /* MSDN says about AvailExtendedVirtual: Size of unreserved and uncommitted
1344 memory in the extended portion of the virtual address space of the calling
1345 process, in bytes.
1346 However, I don't know what this means, so set it to zero :(
1347 */
1348 lpmemex->ullAvailExtendedVirtual = 0;
1349
1350 cached_memstatus = *lpmemex;
1351
1352 TRACE("<-- LPMEMORYSTATUSEX: dwLength %d, dwMemoryLoad %d, ullTotalPhys %s, ullAvailPhys %s,"
1353 " ullTotalPageFile %s, ullAvailPageFile %s, ullTotalVirtual %s, ullAvailVirtual %s\n",
1354 lpmemex->dwLength, lpmemex->dwMemoryLoad, wine_dbgstr_longlong(lpmemex->ullTotalPhys),
1355 wine_dbgstr_longlong(lpmemex->ullAvailPhys), wine_dbgstr_longlong(lpmemex->ullTotalPageFile),
1356 wine_dbgstr_longlong(lpmemex->ullAvailPageFile), wine_dbgstr_longlong(lpmemex->ullTotalVirtual),
1357 wine_dbgstr_longlong(lpmemex->ullAvailVirtual) );
1358
1359 return TRUE;
1360 }
1361
1362 /***********************************************************************
1363 * GlobalMemoryStatus (KERNEL32.@)
1364 * Provides information about the status of the memory, so apps can tell
1365 * roughly how much they are able to allocate
1366 *
1367 * RETURNS
1368 * None
1369 */
1370 VOID WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer )
1371 {
1372 MEMORYSTATUSEX memstatus;
1373 OSVERSIONINFOW osver;
1374 IMAGE_NT_HEADERS *nt = RtlImageNtHeader( GetModuleHandleW(0) );
1375
1376 /* Because GlobalMemoryStatus is identical to GlobalMemoryStatusEX save
1377 for one extra field in the struct, and the lack of a bug, we simply
1378 call GlobalMemoryStatusEx and copy the values across. */
1379 memstatus.dwLength = sizeof(memstatus);
1380 GlobalMemoryStatusEx(&memstatus);
1381
1382 lpBuffer->dwLength = sizeof(*lpBuffer);
1383 lpBuffer->dwMemoryLoad = memstatus.dwMemoryLoad;
1384
1385 /* Windows 2000 and later report -1 when values are greater than 4 Gb.
1386 * NT reports values modulo 4 Gb.
1387 */
1388
1389 osver.dwOSVersionInfoSize = sizeof(osver);
1390 GetVersionExW(&osver);
1391
1392 if ( osver.dwMajorVersion >= 5 )
1393 {
1394 lpBuffer->dwTotalPhys = min( memstatus.ullTotalPhys, MAXDWORD );
1395 lpBuffer->dwAvailPhys = min( memstatus.ullAvailPhys, MAXDWORD );
1396 lpBuffer->dwTotalPageFile = min( memstatus.ullTotalPageFile, MAXDWORD );
1397 lpBuffer->dwAvailPageFile = min( memstatus.ullAvailPageFile, MAXDWORD );
1398 lpBuffer->dwTotalVirtual = min( memstatus.ullTotalVirtual, MAXDWORD );
1399 lpBuffer->dwAvailVirtual = min( memstatus.ullAvailVirtual, MAXDWORD );
1400
1401 }
1402 else /* duplicate NT bug */
1403 {
1404 lpBuffer->dwTotalPhys = memstatus.ullTotalPhys;
1405 lpBuffer->dwAvailPhys = memstatus.ullAvailPhys;
1406 lpBuffer->dwTotalPageFile = memstatus.ullTotalPageFile;
1407 lpBuffer->dwAvailPageFile = memstatus.ullAvailPageFile;
1408 lpBuffer->dwTotalVirtual = memstatus.ullTotalVirtual;
1409 lpBuffer->dwAvailVirtual = memstatus.ullAvailVirtual;
1410 }
1411
1412 /* values are limited to 2Gb unless the app has the IMAGE_FILE_LARGE_ADDRESS_AWARE flag */
1413 /* page file sizes are not limited (Adobe Illustrator 8 depends on this) */
1414 if (!(nt->FileHeader.Characteristics & IMAGE_FILE_LARGE_ADDRESS_AWARE))
1415 {
1416 if (lpBuffer->dwTotalPhys > MAXLONG) lpBuffer->dwTotalPhys = MAXLONG;
1417 if (lpBuffer->dwAvailPhys > MAXLONG) lpBuffer->dwAvailPhys = MAXLONG;
1418 if (lpBuffer->dwTotalVirtual > MAXLONG) lpBuffer->dwTotalVirtual = MAXLONG;
1419 if (lpBuffer->dwAvailVirtual > MAXLONG) lpBuffer->dwAvailVirtual = MAXLONG;
1420 }
1421
1422 /* work around for broken photoshop 4 installer */
1423 if ( lpBuffer->dwAvailPhys + lpBuffer->dwAvailPageFile >= 2U*1024*1024*1024)
1424 lpBuffer->dwAvailPageFile = 2U*1024*1024*1024 - lpBuffer->dwAvailPhys - 1;
1425
1426 /* limit page file size for really old binaries */
1427 if (nt->OptionalHeader.MajorSubsystemVersion < 4)
1428 {
1429 if (lpBuffer->dwTotalPageFile > MAXLONG) lpBuffer->dwTotalPageFile = MAXLONG;
1430 if (lpBuffer->dwAvailPageFile > MAXLONG) lpBuffer->dwAvailPageFile = MAXLONG;
1431 }
1432
1433 TRACE("Length %u, MemoryLoad %u, TotalPhys %lx, AvailPhys %lx,"
1434 " TotalPageFile %lx, AvailPageFile %lx, TotalVirtual %lx, AvailVirtual %lx\n",
1435 lpBuffer->dwLength, lpBuffer->dwMemoryLoad, lpBuffer->dwTotalPhys,
1436 lpBuffer->dwAvailPhys, lpBuffer->dwTotalPageFile, lpBuffer->dwAvailPageFile,
1437 lpBuffer->dwTotalVirtual, lpBuffer->dwAvailVirtual );
1438 }
1439
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.