kernel32/tests: Delete some temporary files.
[wine] / dlls / kernel32 / heap.c
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  *           GetProcessHeaps    (KERNEL32.@)
253  */
254 DWORD WINAPI GetProcessHeaps( DWORD count, HANDLE *heaps )
255 {
256     return RtlGetProcessHeaps( count, heaps );
257 }
258
259
260 /* These are needed so that we can call the functions from inside kernel itself */
261
262 /***********************************************************************
263  *           HeapAlloc    (KERNEL32.@)
264  */
265 LPVOID WINAPI HeapAlloc( HANDLE heap, DWORD flags, SIZE_T size )
266 {
267     return RtlAllocateHeap( heap, flags, size );
268 }
269
270 BOOL WINAPI HeapFree( HANDLE heap, DWORD flags, LPVOID ptr )
271 {
272     return RtlFreeHeap( heap, flags, ptr );
273 }
274
275 LPVOID WINAPI HeapReAlloc( HANDLE heap, DWORD flags, LPVOID ptr, SIZE_T size )
276 {
277     return RtlReAllocateHeap( heap, flags, ptr, size );
278 }
279
280 SIZE_T WINAPI HeapSize( HANDLE heap, DWORD flags, LPCVOID ptr )
281 {
282     return RtlSizeHeap( heap, flags, ptr );
283 }
284
285 BOOL WINAPI HeapQueryInformation( HANDLE heap, HEAP_INFORMATION_CLASS info_class,
286                                   PVOID info, SIZE_T size_in, PSIZE_T size_out)
287 {
288     NTSTATUS ret = RtlQueryHeapInformation( heap, info_class, info, size_in, size_out );
289     if (ret) SetLastError( RtlNtStatusToDosError(ret) );
290     return !ret;
291 }
292
293 BOOL WINAPI HeapSetInformation( HANDLE heap, HEAP_INFORMATION_CLASS infoclass, PVOID info, SIZE_T size)
294 {
295     FIXME("%p %d %p %ld\n", heap, infoclass, info, size );
296     return TRUE;
297 }
298
299 /*
300  * Win32 Global heap functions (GlobalXXX).
301  * These functions included in Win32 for compatibility with 16 bit Windows
302  * Especially the moveable blocks and handles are oldish.
303  * But the ability to directly allocate memory with GPTR and LPTR is widely
304  * used.
305  *
306  * The handle stuff looks horrible, but it's implemented almost like Win95
307  * does it.
308  *
309  */
310
311 #define MAGIC_GLOBAL_USED 0x5342
312 #define HANDLE_TO_INTERN(h)  ((PGLOBAL32_INTERN)(((char *)(h))-2))
313 #define INTERN_TO_HANDLE(i)  (&((i)->Pointer))
314 #define POINTER_TO_HANDLE(p) (*(((const HGLOBAL *)(p))-2))
315 #define ISHANDLE(h)          (((ULONG_PTR)(h)&2)!=0)
316 #define ISPOINTER(h)         (((ULONG_PTR)(h)&2)==0)
317 /* align the storage needed for the HGLOBAL on an 8byte boundary thus
318  * GlobalAlloc/GlobalReAlloc'ing with GMEM_MOVEABLE of memory with
319  * size = 8*k, where k=1,2,3,... alloc's exactly the given size.
320  * The Minolta DiMAGE Image Viewer heavily relies on this, corrupting
321  * the output jpeg's > 1 MB if not */
322 #define HGLOBAL_STORAGE      (sizeof(HGLOBAL)*2)
323
324 #include "pshpack1.h"
325
326 typedef struct __GLOBAL32_INTERN
327 {
328    WORD         Magic;
329    LPVOID       Pointer;
330    BYTE         Flags;
331    BYTE         LockCount;
332 } GLOBAL32_INTERN, *PGLOBAL32_INTERN;
333
334 #include "poppack.h"
335
336 /***********************************************************************
337  *           GlobalAlloc   (KERNEL32.@)
338  *
339  * Allocate a global memory object.
340  *
341  * RETURNS
342  *      Handle: Success
343  *      NULL: Failure
344  */
345 HGLOBAL WINAPI GlobalAlloc(
346                  UINT flags, /* [in] Object allocation attributes */
347                  SIZE_T size /* [in] Number of bytes to allocate */
348 ) {
349    PGLOBAL32_INTERN     pintern;
350    DWORD                hpflags;
351    LPVOID               palloc;
352
353    if(flags&GMEM_ZEROINIT)
354       hpflags=HEAP_ZERO_MEMORY;
355    else
356       hpflags=0;
357
358    if((flags & GMEM_MOVEABLE)==0) /* POINTER */
359    {
360       palloc=HeapAlloc(GetProcessHeap(), hpflags, size);
361       TRACE( "(flags=%04x) returning %p\n",  flags, palloc );
362       return palloc;
363    }
364    else  /* HANDLE */
365    {
366       if (size > INT_MAX-HGLOBAL_STORAGE)
367       {
368           SetLastError(ERROR_OUTOFMEMORY);
369           return 0;
370       }
371
372       RtlLockHeap(GetProcessHeap());
373
374       pintern = HeapAlloc(GetProcessHeap(), 0, sizeof(GLOBAL32_INTERN));
375       if (pintern)
376       {
377           /* Mask out obsolete flags */
378           flags &= ~(GMEM_LOWER | GMEM_NOCOMPACT | GMEM_NOT_BANKED | GMEM_NOTIFY);
379
380           pintern->Magic = MAGIC_GLOBAL_USED;
381           pintern->Flags = flags >> 8;
382           pintern->LockCount = 0;
383
384           if (size)
385           {
386               palloc = HeapAlloc(GetProcessHeap(), hpflags, size+HGLOBAL_STORAGE);
387               if (!palloc)
388               {
389                   HeapFree(GetProcessHeap(), 0, pintern);
390                   pintern = NULL;
391               }
392               else
393               {
394                   *(HGLOBAL *)palloc = INTERN_TO_HANDLE(pintern);
395                   pintern->Pointer = (char *)palloc + HGLOBAL_STORAGE;
396               }
397           }
398           else
399               pintern->Pointer = NULL;
400       }
401
402       RtlUnlockHeap(GetProcessHeap());
403       if (!pintern) return 0;
404       TRACE( "(flags=%04x) returning handle %p pointer %p\n",
405              flags, INTERN_TO_HANDLE(pintern), pintern->Pointer );
406       return INTERN_TO_HANDLE(pintern);
407    }
408 }
409
410
411 /***********************************************************************
412  *           GlobalLock   (KERNEL32.@)
413  *
414  * Lock a global memory object and return a pointer to first byte of the memory
415  *
416  * PARAMS
417  *  hmem [I] Handle of the global memory object
418  *
419  * RETURNS
420  *  Success: Pointer to first byte of the memory block
421  *  Failure: NULL
422  *
423  * NOTES
424  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
425  *
426  */
427 LPVOID WINAPI GlobalLock(HGLOBAL hmem)
428 {
429     PGLOBAL32_INTERN pintern;
430     LPVOID           palloc;
431
432     if (ISPOINTER(hmem))
433         return IsBadReadPtr(hmem, 1) ? NULL : hmem;
434
435     RtlLockHeap(GetProcessHeap());
436     __TRY
437     {
438         pintern = HANDLE_TO_INTERN(hmem);
439         if (pintern->Magic == MAGIC_GLOBAL_USED)
440         {
441             palloc = pintern->Pointer;
442             if (!pintern->Pointer)
443                 SetLastError(ERROR_DISCARDED);
444             else if (pintern->LockCount < GMEM_LOCKCOUNT)
445                 pintern->LockCount++;
446         }
447         else
448         {
449             WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
450             palloc = NULL;
451             SetLastError(ERROR_INVALID_HANDLE);
452         }
453     }
454     __EXCEPT_PAGE_FAULT
455     {
456         WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem);
457         palloc = NULL;
458         SetLastError(ERROR_INVALID_HANDLE);
459     }
460     __ENDTRY
461     RtlUnlockHeap(GetProcessHeap());
462     return palloc;
463 }
464
465
466 /***********************************************************************
467  *           GlobalUnlock   (KERNEL32.@)
468  *
469  * Unlock a global memory object.
470  *
471  * PARAMS
472  *  hmem [I] Handle of the global memory object
473  *
474  * RETURNS
475  *  Success: Object is still locked
476  *  Failure: FALSE (The Object is unlocked)
477  *
478  * NOTES
479  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
480  *
481  */
482 BOOL WINAPI GlobalUnlock(HGLOBAL hmem)
483 {
484     PGLOBAL32_INTERN pintern;
485     BOOL locked;
486
487     if (ISPOINTER(hmem)) return TRUE;
488
489     RtlLockHeap(GetProcessHeap());
490     __TRY
491     {
492         pintern=HANDLE_TO_INTERN(hmem);
493         if(pintern->Magic==MAGIC_GLOBAL_USED)
494         {
495             if(pintern->LockCount)
496             {
497                 pintern->LockCount--;
498                 locked = (pintern->LockCount != 0);
499                 if (!locked) SetLastError(NO_ERROR);
500             }
501             else
502             {
503                 WARN("%p not locked\n", hmem);
504                 SetLastError(ERROR_NOT_LOCKED);
505                 locked = FALSE;
506             }
507         }
508         else
509         {
510             WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
511             SetLastError(ERROR_INVALID_HANDLE);
512             locked=FALSE;
513         }
514     }
515     __EXCEPT_PAGE_FAULT
516     {
517         WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem);
518         SetLastError( ERROR_INVALID_PARAMETER );
519         locked=FALSE;
520     }
521     __ENDTRY
522     RtlUnlockHeap(GetProcessHeap());
523     return locked;
524 }
525
526
527 /***********************************************************************
528  *           GlobalHandle   (KERNEL32.@)
529  *
530  * Get the handle associated with the pointer to a global memory block.
531  *
532  * RETURNS
533  *      Handle: Success
534  *      NULL: Failure
535  */
536 HGLOBAL WINAPI GlobalHandle(
537                  LPCVOID pmem /* [in] Pointer to global memory block */
538 ) {
539     HGLOBAL handle;
540     PGLOBAL32_INTERN  maybe_intern;
541     LPCVOID test;
542
543     if (!pmem)
544     {
545         SetLastError( ERROR_INVALID_PARAMETER );
546         return 0;
547     }
548
549     RtlLockHeap(GetProcessHeap());
550     __TRY
551     {
552         handle = 0;
553
554         /* note that if pmem is a pointer to a block allocated by        */
555         /* GlobalAlloc with GMEM_MOVEABLE then magic test in HeapValidate  */
556         /* will fail.                                                      */
557         if (ISPOINTER(pmem)) {
558             if (HeapValidate( GetProcessHeap(), 0, pmem )) {
559                 handle = (HGLOBAL)pmem;  /* valid fixed block */
560                 break;
561             }
562             handle = POINTER_TO_HANDLE(pmem);
563         } else
564             handle = (HGLOBAL)pmem;
565
566         /* Now test handle either passed in or retrieved from pointer */
567         maybe_intern = HANDLE_TO_INTERN( handle );
568         if (maybe_intern->Magic == MAGIC_GLOBAL_USED) {
569             test = maybe_intern->Pointer;
570             if (HeapValidate( GetProcessHeap(), 0, (const char *)test - HGLOBAL_STORAGE ) && /* obj(-handle) valid arena? */
571                 HeapValidate( GetProcessHeap(), 0, maybe_intern ))  /* intern valid arena? */
572                 break;  /* valid moveable block */
573         }
574         handle = 0;
575         SetLastError( ERROR_INVALID_HANDLE );
576     }
577     __EXCEPT_PAGE_FAULT
578     {
579         SetLastError( ERROR_INVALID_HANDLE );
580         handle = 0;
581     }
582     __ENDTRY
583     RtlUnlockHeap(GetProcessHeap());
584
585     return handle;
586 }
587
588
589 /***********************************************************************
590  *           GlobalReAlloc   (KERNEL32.@)
591  *
592  * Change the size or attributes of a global memory object.
593  *
594  * RETURNS
595  *      Handle: Success
596  *      NULL: Failure
597  */
598 HGLOBAL WINAPI GlobalReAlloc(
599                  HGLOBAL hmem, /* [in] Handle of global memory object */
600                  SIZE_T size,  /* [in] New size of block */
601                  UINT flags    /* [in] How to reallocate object */
602 ) {
603    LPVOID               palloc;
604    HGLOBAL            hnew;
605    PGLOBAL32_INTERN     pintern;
606    DWORD heap_flags = (flags & GMEM_ZEROINIT) ? HEAP_ZERO_MEMORY : 0;
607
608    hnew = 0;
609    RtlLockHeap(GetProcessHeap());
610    if(flags & GMEM_MODIFY) /* modify flags */
611    {
612       if( ISPOINTER(hmem) && (flags & GMEM_MOVEABLE))
613       {
614          /* make a fixed block moveable
615           * actually only NT is able to do this. But it's soo simple
616           */
617          if (hmem == 0)
618          {
619              WARN("GlobalReAlloc with null handle!\n");
620              SetLastError( ERROR_NOACCESS );
621              hnew = 0;
622          }
623          else
624          {
625              size = HeapSize(GetProcessHeap(), 0, hmem);
626              hnew = GlobalAlloc(flags, size);
627              palloc = GlobalLock(hnew);
628              memcpy(palloc, hmem, size);
629              GlobalUnlock(hnew);
630              GlobalFree(hmem);
631          }
632       }
633       else if( ISPOINTER(hmem) &&(flags & GMEM_DISCARDABLE))
634       {
635          /* change the flags to make our block "discardable" */
636          pintern=HANDLE_TO_INTERN(hmem);
637          pintern->Flags = pintern->Flags | (GMEM_DISCARDABLE >> 8);
638          hnew=hmem;
639       }
640       else
641       {
642          SetLastError(ERROR_INVALID_PARAMETER);
643          hnew = 0;
644       }
645    }
646    else
647    {
648       if(ISPOINTER(hmem))
649       {
650          /* reallocate fixed memory */
651          hnew=HeapReAlloc(GetProcessHeap(), heap_flags, hmem, size);
652       }
653       else
654       {
655          /* reallocate a moveable block */
656          pintern=HANDLE_TO_INTERN(hmem);
657
658 #if 0
659 /* Apparently Windows doesn't care whether the handle is locked at this point */
660 /* See also the same comment in GlobalFree() */
661          if(pintern->LockCount>1) {
662             ERR("handle 0x%08lx is still locked, cannot realloc!\n",(DWORD)hmem);
663             SetLastError(ERROR_INVALID_HANDLE);
664          } else
665 #endif
666          if(size!=0)
667          {
668             hnew=hmem;
669             if(pintern->Pointer)
670             {
671                if(size > INT_MAX-HGLOBAL_STORAGE)
672                {
673                    SetLastError(ERROR_OUTOFMEMORY);
674                    hnew = 0;
675                }
676                else if((palloc = HeapReAlloc(GetProcessHeap(), heap_flags,
677                                    (char *) pintern->Pointer-HGLOBAL_STORAGE,
678                                    size+HGLOBAL_STORAGE)) == NULL)
679                    hnew = 0; /* Block still valid */
680                else
681                    pintern->Pointer = (char *)palloc+HGLOBAL_STORAGE;
682             }
683             else
684             {
685                 if(size > INT_MAX-HGLOBAL_STORAGE)
686                 {
687                     SetLastError(ERROR_OUTOFMEMORY);
688                     hnew = 0;
689                 }
690                 else if((palloc=HeapAlloc(GetProcessHeap(), heap_flags, size+HGLOBAL_STORAGE))
691                    == NULL)
692                     hnew = 0;
693                 else
694                 {
695                     *(HGLOBAL *)palloc = hmem;
696                     pintern->Pointer = (char *)palloc + HGLOBAL_STORAGE;
697                 }
698             }
699          }
700          else
701          {
702             if (pintern->LockCount == 0)
703             {
704                 if(pintern->Pointer)
705                 {
706                     HeapFree(GetProcessHeap(), 0, (char *) pintern->Pointer-HGLOBAL_STORAGE);
707                     pintern->Pointer = NULL;
708                 }
709                 hnew = hmem;
710             }
711             else
712                 WARN("not freeing memory associated with locked handle\n");
713          }
714       }
715    }
716    RtlUnlockHeap(GetProcessHeap());
717    return hnew;
718 }
719
720
721 /***********************************************************************
722  *           GlobalFree   (KERNEL32.@)
723  *
724  * Free a global memory object.
725  *
726  * PARAMS
727  *  hmem [I] Handle of the global memory object
728  *
729  * RETURNS
730  *  Success: NULL
731  *  Failure: The provided handle
732  *
733  * NOTES
734  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
735  *
736  */
737 HGLOBAL WINAPI GlobalFree(HGLOBAL hmem)
738 {
739     PGLOBAL32_INTERN pintern;
740     HGLOBAL hreturned;
741
742     RtlLockHeap(GetProcessHeap());
743     __TRY
744     {
745         hreturned = 0;
746         if(ISPOINTER(hmem)) /* POINTER */
747         {
748             if(!HeapFree(GetProcessHeap(), 0, hmem))
749             {
750                 SetLastError(ERROR_INVALID_HANDLE);
751                 hreturned = hmem;
752             }
753         }
754         else  /* HANDLE */
755         {
756             pintern=HANDLE_TO_INTERN(hmem);
757
758             if(pintern->Magic==MAGIC_GLOBAL_USED)
759             {
760                 pintern->Magic = 0xdead;
761
762                 /* WIN98 does not make this test. That is you can free a */
763                 /* block you have not unlocked. Go figure!!              */
764                 /* if(pintern->LockCount!=0)  */
765                 /*    SetLastError(ERROR_INVALID_HANDLE);  */
766
767                 if(pintern->Pointer)
768                     if(!HeapFree(GetProcessHeap(), 0, (char *)(pintern->Pointer)-HGLOBAL_STORAGE))
769                         hreturned=hmem;
770                 if(!HeapFree(GetProcessHeap(), 0, pintern))
771                     hreturned=hmem;
772             }
773             else
774             {
775                 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
776                 SetLastError(ERROR_INVALID_HANDLE);
777                 hreturned = hmem;
778             }
779         }
780     }
781     __EXCEPT_PAGE_FAULT
782     {
783         ERR("(%p): Page fault occurred ! Caused by bug ?\n", hmem);
784         SetLastError( ERROR_INVALID_PARAMETER );
785         hreturned = hmem;
786     }
787     __ENDTRY
788     RtlUnlockHeap(GetProcessHeap());
789     return hreturned;
790 }
791
792
793 /***********************************************************************
794  *           GlobalSize   (KERNEL32.@)
795  *
796  * Get the size of a global memory object.
797  *
798  * PARAMS
799  *  hmem [I] Handle of the global memory object
800  *
801  * RETURNS
802  *  Failure: 0
803  *  Success: Size in Bytes of the global memory object
804  *
805  * NOTES
806  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
807  *
808  */
809 SIZE_T WINAPI GlobalSize(HGLOBAL hmem)
810 {
811    DWORD                retval;
812    PGLOBAL32_INTERN     pintern;
813
814    if (!((ULONG_PTR)hmem >> 16))
815    {
816        SetLastError(ERROR_INVALID_HANDLE);
817        return 0;
818    }
819
820    if(ISPOINTER(hmem))
821    {
822       retval=HeapSize(GetProcessHeap(), 0, hmem);
823    }
824    else
825    {
826       RtlLockHeap(GetProcessHeap());
827       pintern=HANDLE_TO_INTERN(hmem);
828
829       if(pintern->Magic==MAGIC_GLOBAL_USED)
830       {
831          if (!pintern->Pointer) /* handle case of GlobalAlloc( ??,0) */
832              retval = 0;
833          else
834          {
835              retval = HeapSize(GetProcessHeap(), 0,
836                          (char *)(pintern->Pointer) - HGLOBAL_STORAGE );
837              if (retval != (DWORD)-1) retval -= HGLOBAL_STORAGE;
838          }
839       }
840       else
841       {
842          WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
843          SetLastError(ERROR_INVALID_HANDLE);
844          retval=0;
845       }
846       RtlUnlockHeap(GetProcessHeap());
847    }
848    /* HeapSize returns 0xffffffff on failure */
849    if (retval == 0xffffffff) retval = 0;
850    return retval;
851 }
852
853
854 /***********************************************************************
855  *           GlobalWire   (KERNEL32.@)
856  */
857 LPVOID WINAPI GlobalWire(HGLOBAL hmem)
858 {
859    return GlobalLock( hmem );
860 }
861
862
863 /***********************************************************************
864  *           GlobalUnWire   (KERNEL32.@)
865  */
866 BOOL WINAPI GlobalUnWire(HGLOBAL hmem)
867 {
868    return GlobalUnlock( hmem);
869 }
870
871
872 /***********************************************************************
873  *           GlobalFix   (KERNEL32.@)
874  */
875 VOID WINAPI GlobalFix(HGLOBAL hmem)
876 {
877     GlobalLock( hmem );
878 }
879
880
881 /***********************************************************************
882  *           GlobalUnfix   (KERNEL32.@)
883  */
884 VOID WINAPI GlobalUnfix(HGLOBAL hmem)
885 {
886    GlobalUnlock( hmem);
887 }
888
889
890 /***********************************************************************
891  *           GlobalFlags   (KERNEL32.@)
892  *
893  * Get information about a global memory object.
894  *
895  * PARAMS
896  *  hmem [I] Handle of the global memory object 
897  *
898  * RETURNS
899  *  Failure: GMEM_INVALID_HANDLE, when the provided handle is invalid 
900  *  Success: Value specifying allocation flags and lock count
901  *
902  */
903 UINT WINAPI GlobalFlags(HGLOBAL hmem)
904 {
905    DWORD                retval;
906    PGLOBAL32_INTERN     pintern;
907
908    if(ISPOINTER(hmem))
909    {
910       retval=0;
911    }
912    else
913    {
914       RtlLockHeap(GetProcessHeap());
915       pintern=HANDLE_TO_INTERN(hmem);
916       if(pintern->Magic==MAGIC_GLOBAL_USED)
917       {
918          retval=pintern->LockCount + (pintern->Flags<<8);
919          if(pintern->Pointer==0)
920             retval|= GMEM_DISCARDED;
921       }
922       else
923       {
924          WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
925          SetLastError(ERROR_INVALID_HANDLE);
926          retval = GMEM_INVALID_HANDLE;
927       }
928       RtlUnlockHeap(GetProcessHeap());
929    }
930    return retval;
931 }
932
933
934 /***********************************************************************
935  *           GlobalCompact   (KERNEL32.@)
936  */
937 SIZE_T WINAPI GlobalCompact( DWORD minfree )
938 {
939     return 0;  /* GlobalCompact does nothing in Win32 */
940 }
941
942
943 /***********************************************************************
944  *           LocalAlloc   (KERNEL32.@)
945  *
946  * Allocate a local memory object.
947  *
948  * RETURNS
949  *      Handle: Success
950  *      NULL: Failure
951  *
952  * NOTES
953  *  Windows memory management does not provide a separate local heap
954  *  and global heap.
955  */
956 HLOCAL WINAPI LocalAlloc(
957                 UINT flags, /* [in] Allocation attributes */
958                 SIZE_T size /* [in] Number of bytes to allocate */
959 ) {
960     return GlobalAlloc( flags, size );
961 }
962
963
964 /***********************************************************************
965  *           LocalCompact   (KERNEL32.@)
966  */
967 SIZE_T WINAPI LocalCompact( UINT minfree )
968 {
969     return 0;  /* LocalCompact does nothing in Win32 */
970 }
971
972
973 /***********************************************************************
974  *           LocalFlags   (KERNEL32.@)
975  *
976  * Get information about a local memory object.
977  *
978  * RETURNS
979  *      Value specifying allocation flags and lock count.
980  *      LMEM_INVALID_HANDLE: Failure
981  *
982  * NOTES
983  *  Windows memory management does not provide a separate local heap
984  *  and global heap.
985  */
986 UINT WINAPI LocalFlags(
987               HLOCAL handle /* [in] Handle of memory object */
988 ) {
989     return GlobalFlags( handle );
990 }
991
992
993 /***********************************************************************
994  *           LocalFree   (KERNEL32.@)
995  *
996  * Free a local memory object.
997  *
998  * RETURNS
999  *      NULL: Success
1000  *      Handle: Failure
1001  *
1002  * NOTES
1003  *  Windows memory management does not provide a separate local heap
1004  *  and global heap.
1005  */
1006 HLOCAL WINAPI LocalFree(
1007                 HLOCAL handle /* [in] Handle of memory object */
1008 ) {
1009     return GlobalFree( handle );
1010 }
1011
1012
1013 /***********************************************************************
1014  *           LocalHandle   (KERNEL32.@)
1015  *
1016  * Get the handle associated with the pointer to a local memory block.
1017  *
1018  * RETURNS
1019  *      Handle: Success
1020  *      NULL: Failure
1021  *
1022  * NOTES
1023  *  Windows memory management does not provide a separate local heap
1024  *  and global heap.
1025  */
1026 HLOCAL WINAPI LocalHandle(
1027                 LPCVOID ptr /* [in] Address of local memory block */
1028 ) {
1029     return GlobalHandle( ptr );
1030 }
1031
1032
1033 /***********************************************************************
1034  *           LocalLock   (KERNEL32.@)
1035  * Locks a local memory object and returns pointer to the first byte
1036  * of the memory block.
1037  *
1038  * RETURNS
1039  *      Pointer: Success
1040  *      NULL: Failure
1041  *
1042  * NOTES
1043  *  Windows memory management does not provide a separate local heap
1044  *  and global heap.
1045  */
1046 LPVOID WINAPI LocalLock(
1047               HLOCAL handle /* [in] Address of local memory object */
1048 ) {
1049     return GlobalLock( handle );
1050 }
1051
1052
1053 /***********************************************************************
1054  *           LocalReAlloc   (KERNEL32.@)
1055  *
1056  * Change the size or attributes of a local memory object.
1057  *
1058  * RETURNS
1059  *      Handle: Success
1060  *      NULL: Failure
1061  *
1062  * NOTES
1063  *  Windows memory management does not provide a separate local heap
1064  *  and global heap.
1065  */
1066 HLOCAL WINAPI LocalReAlloc(
1067                 HLOCAL handle, /* [in] Handle of memory object */
1068                 SIZE_T size,   /* [in] New size of block */
1069                 UINT flags     /* [in] How to reallocate object */
1070 ) {
1071     return GlobalReAlloc( handle, size, flags );
1072 }
1073
1074
1075 /***********************************************************************
1076  *           LocalShrink   (KERNEL32.@)
1077  */
1078 SIZE_T WINAPI LocalShrink( HGLOBAL handle, UINT newsize )
1079 {
1080     return 0;  /* LocalShrink does nothing in Win32 */
1081 }
1082
1083
1084 /***********************************************************************
1085  *           LocalSize   (KERNEL32.@)
1086  *
1087  * Get the size of a local memory object.
1088  *
1089  * RETURNS
1090  *      Size: Success
1091  *      0: Failure
1092  *
1093  * NOTES
1094  *  Windows memory management does not provide a separate local heap
1095  *  and global heap.
1096  */
1097 SIZE_T WINAPI LocalSize(
1098               HLOCAL handle /* [in] Handle of memory object */
1099 ) {
1100     return GlobalSize( handle );
1101 }
1102
1103
1104 /***********************************************************************
1105  *           LocalUnlock   (KERNEL32.@)
1106  *
1107  * Unlock a local memory object.
1108  *
1109  * RETURNS
1110  *      TRUE: Object is still locked
1111  *      FALSE: Object is unlocked
1112  *
1113  * NOTES
1114  *  Windows memory management does not provide a separate local heap
1115  *  and global heap.
1116  */
1117 BOOL WINAPI LocalUnlock(
1118               HLOCAL handle /* [in] Handle of memory object */
1119 )
1120 {
1121     if (ISPOINTER( handle ))
1122     {
1123         SetLastError( ERROR_NOT_LOCKED );
1124         return FALSE;
1125     }
1126
1127     return GlobalUnlock( handle );
1128 }
1129
1130
1131 /***********************************************************************
1132  *           GlobalMemoryStatusEx   (KERNEL32.@)
1133  * A version of GlobalMemoryStatus that can deal with memory over 4GB
1134  *
1135  * RETURNS
1136  *      TRUE
1137  */
1138 BOOL WINAPI GlobalMemoryStatusEx( LPMEMORYSTATUSEX lpmemex )
1139 {
1140     static MEMORYSTATUSEX       cached_memstatus;
1141     static int cache_lastchecked = 0;
1142     SYSTEM_INFO si;
1143 #ifdef linux
1144     FILE *f;
1145 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__)
1146     unsigned long val;
1147     int mib[2];
1148     size_t size_sys;
1149 #elif defined(__APPLE__)
1150     unsigned int val;
1151     int mib[2];
1152     size_t size_sys;
1153 #elif defined(sun)
1154     unsigned long pagesize,maxpages,freepages,swapspace,swapfree;
1155     struct anoninfo swapinf;
1156     int rval;
1157 #endif
1158
1159     if (lpmemex->dwLength != sizeof(*lpmemex))
1160     {
1161         SetLastError( ERROR_INVALID_PARAMETER );
1162         return FALSE;
1163     }
1164
1165     if (time(NULL)==cache_lastchecked) {
1166         *lpmemex = cached_memstatus;
1167         return TRUE;
1168     }
1169     cache_lastchecked = time(NULL);
1170
1171     lpmemex->dwMemoryLoad     = 0;
1172     lpmemex->ullTotalPhys     = 16*1024*1024;
1173     lpmemex->ullAvailPhys     = 16*1024*1024;
1174     lpmemex->ullTotalPageFile = 16*1024*1024;
1175     lpmemex->ullAvailPageFile = 16*1024*1024;
1176
1177 #ifdef linux
1178     f = fopen( "/proc/meminfo", "r" );
1179     if (f)
1180     {
1181         char buffer[256];
1182         unsigned long total, used, free, shared, buffers, cached;
1183
1184         lpmemex->ullTotalPhys = lpmemex->ullAvailPhys = 0;
1185         lpmemex->ullTotalPageFile = lpmemex->ullAvailPageFile = 0;
1186         while (fgets( buffer, sizeof(buffer), f ))
1187         {
1188             /* old style /proc/meminfo ... */
1189             if (sscanf( buffer, "Mem: %lu %lu %lu %lu %lu %lu",
1190                         &total, &used, &free, &shared, &buffers, &cached ))
1191             {
1192                 lpmemex->ullTotalPhys += total;
1193                 lpmemex->ullAvailPhys += free + buffers + cached;
1194             }
1195             if (sscanf( buffer, "Swap: %lu %lu %lu", &total, &used, &free ))
1196             {
1197                 lpmemex->ullTotalPageFile += total;
1198                 lpmemex->ullAvailPageFile += free;
1199             }
1200
1201             /* new style /proc/meminfo ... */
1202             if (sscanf(buffer, "MemTotal: %lu", &total))
1203                 lpmemex->ullTotalPhys = total*1024;
1204             if (sscanf(buffer, "MemFree: %lu", &free))
1205                 lpmemex->ullAvailPhys = free*1024;
1206             if (sscanf(buffer, "SwapTotal: %lu", &total))
1207                 lpmemex->ullTotalPageFile = total*1024;
1208             if (sscanf(buffer, "SwapFree: %lu", &free))
1209                 lpmemex->ullAvailPageFile = free*1024;
1210             if (sscanf(buffer, "Buffers: %lu", &buffers))
1211                 lpmemex->ullAvailPhys += buffers*1024;
1212             if (sscanf(buffer, "Cached: %lu", &cached))
1213                 lpmemex->ullAvailPhys += cached*1024;
1214         }
1215         fclose( f );
1216     }
1217 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
1218     mib[0] = CTL_HW;
1219     mib[1] = HW_PHYSMEM;
1220     size_sys = sizeof(val);
1221     sysctl(mib, 2, &val, &size_sys, NULL, 0);
1222     if (val) lpmemex->ullTotalPhys = val;
1223     mib[1] = HW_USERMEM;
1224     size_sys = sizeof(val);
1225     sysctl(mib, 2, &val, &size_sys, NULL, 0);
1226     if (!val) val = lpmemex->ullTotalPhys;
1227     lpmemex->ullAvailPhys = val;
1228     lpmemex->ullTotalPageFile = val;
1229     lpmemex->ullAvailPageFile = val;
1230 #elif defined ( sun )
1231     pagesize=sysconf(_SC_PAGESIZE);
1232     maxpages=sysconf(_SC_PHYS_PAGES);
1233     freepages=sysconf(_SC_AVPHYS_PAGES);
1234     rval=swapctl(SC_AINFO, &swapinf);
1235     if(rval >-1)
1236     {
1237         swapspace=swapinf.ani_max*pagesize;
1238         swapfree=swapinf.ani_free*pagesize;
1239     }else
1240     {
1241
1242         WARN("Swap size cannot be determined , assuming equal to physical memory\n");
1243         swapspace=maxpages*pagesize;
1244         swapfree=maxpages*pagesize;
1245     }
1246     lpmemex->ullTotalPhys=pagesize*maxpages;
1247     lpmemex->ullAvailPhys = pagesize*freepages;
1248     lpmemex->ullTotalPageFile = swapspace;
1249     lpmemex->ullAvailPageFile = swapfree;
1250 #endif
1251
1252     if (lpmemex->ullTotalPhys)
1253     {
1254         lpmemex->dwMemoryLoad = (lpmemex->ullTotalPhys-lpmemex->ullAvailPhys)
1255                                   / (lpmemex->ullTotalPhys / 100);
1256     }
1257
1258     /* Win98 returns only the swapsize in ullTotalPageFile/ullAvailPageFile,
1259        WinXP returns the size of physical memory + swapsize;
1260        mimic the behavior of XP.
1261        Note: Project2k refuses to start if it sees less than 1Mb of free swap.
1262     */
1263     lpmemex->ullTotalPageFile += lpmemex->ullTotalPhys;
1264     lpmemex->ullAvailPageFile += lpmemex->ullAvailPhys;
1265
1266     /* Titan Quest refuses to run if TotalPageFile <= ullTotalPhys */
1267     if(lpmemex->ullTotalPageFile == lpmemex->ullTotalPhys)
1268     {
1269         lpmemex->ullTotalPhys -= 1;
1270         lpmemex->ullAvailPhys -= 1;
1271     }
1272
1273     /* FIXME: should do something for other systems */
1274     GetSystemInfo(&si);
1275     lpmemex->ullTotalVirtual  = (ULONG_PTR)si.lpMaximumApplicationAddress-(ULONG_PTR)si.lpMinimumApplicationAddress;
1276     /* FIXME: we should track down all the already allocated VM pages and subtract them, for now arbitrarily remove 64KB so that it matches NT */
1277     lpmemex->ullAvailVirtual  = lpmemex->ullTotalVirtual-64*1024;
1278
1279     /* MSDN says about AvailExtendedVirtual: Size of unreserved and uncommitted
1280        memory in the extended portion of the virtual address space of the calling
1281        process, in bytes.
1282        However, I don't know what this means, so set it to zero :(
1283     */
1284     lpmemex->ullAvailExtendedVirtual = 0;
1285
1286     cached_memstatus = *lpmemex;
1287
1288     TRACE("<-- LPMEMORYSTATUSEX: dwLength %d, dwMemoryLoad %d, ullTotalPhys %s, ullAvailPhys %s,"
1289           " ullTotalPageFile %s, ullAvailPageFile %s, ullTotalVirtual %s, ullAvailVirtual %s\n",
1290           lpmemex->dwLength, lpmemex->dwMemoryLoad, wine_dbgstr_longlong(lpmemex->ullTotalPhys),
1291           wine_dbgstr_longlong(lpmemex->ullAvailPhys), wine_dbgstr_longlong(lpmemex->ullTotalPageFile),
1292           wine_dbgstr_longlong(lpmemex->ullAvailPageFile), wine_dbgstr_longlong(lpmemex->ullTotalVirtual),
1293           wine_dbgstr_longlong(lpmemex->ullAvailVirtual) );
1294
1295     return TRUE;
1296 }
1297
1298 /***********************************************************************
1299  *           GlobalMemoryStatus   (KERNEL32.@)
1300  * Provides information about the status of the memory, so apps can tell
1301  * roughly how much they are able to allocate
1302  *
1303  * RETURNS
1304  *      None
1305  */
1306 VOID WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer )
1307 {
1308     MEMORYSTATUSEX memstatus;
1309     OSVERSIONINFOW osver;
1310     IMAGE_NT_HEADERS *nt = RtlImageNtHeader( GetModuleHandleW(0) );
1311
1312     /* Because GlobalMemoryStatus is identical to GlobalMemoryStatusEX save
1313        for one extra field in the struct, and the lack of a bug, we simply
1314        call GlobalMemoryStatusEx and copy the values across. */
1315     memstatus.dwLength = sizeof(memstatus);
1316     GlobalMemoryStatusEx(&memstatus);
1317
1318     lpBuffer->dwLength = sizeof(*lpBuffer);
1319     lpBuffer->dwMemoryLoad = memstatus.dwMemoryLoad;
1320
1321     /* Windows 2000 and later report -1 when values are greater than 4 Gb.
1322      * NT reports values modulo 4 Gb.
1323      */
1324
1325     osver.dwOSVersionInfoSize = sizeof(osver);
1326     GetVersionExW(&osver);
1327
1328     if ( osver.dwMajorVersion >= 5 || osver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
1329     {
1330         lpBuffer->dwTotalPhys = min( memstatus.ullTotalPhys, MAXDWORD );
1331         lpBuffer->dwAvailPhys = min( memstatus.ullAvailPhys, MAXDWORD );
1332         lpBuffer->dwTotalPageFile = min( memstatus.ullTotalPageFile, MAXDWORD );
1333         lpBuffer->dwAvailPageFile = min( memstatus.ullAvailPageFile, MAXDWORD );
1334         lpBuffer->dwTotalVirtual = min( memstatus.ullTotalVirtual, MAXDWORD );
1335         lpBuffer->dwAvailVirtual = min( memstatus.ullAvailVirtual, MAXDWORD );
1336
1337     }
1338     else        /* duplicate NT bug */
1339     {
1340         lpBuffer->dwTotalPhys = memstatus.ullTotalPhys;
1341         lpBuffer->dwAvailPhys = memstatus.ullAvailPhys;
1342         lpBuffer->dwTotalPageFile = memstatus.ullTotalPageFile;
1343         lpBuffer->dwAvailPageFile = memstatus.ullAvailPageFile;
1344         lpBuffer->dwTotalVirtual = memstatus.ullTotalVirtual;
1345         lpBuffer->dwAvailVirtual = memstatus.ullAvailVirtual;
1346     }
1347
1348     /* values are limited to 2Gb unless the app has the IMAGE_FILE_LARGE_ADDRESS_AWARE flag */
1349     /* page file sizes are not limited (Adobe Illustrator 8 depends on this) */
1350     if (!(nt->FileHeader.Characteristics & IMAGE_FILE_LARGE_ADDRESS_AWARE))
1351     {
1352         if (lpBuffer->dwTotalPhys > MAXLONG) lpBuffer->dwTotalPhys = MAXLONG;
1353         if (lpBuffer->dwAvailPhys > MAXLONG) lpBuffer->dwAvailPhys = MAXLONG;
1354         if (lpBuffer->dwTotalVirtual > MAXLONG) lpBuffer->dwTotalVirtual = MAXLONG;
1355         if (lpBuffer->dwAvailVirtual > MAXLONG) lpBuffer->dwAvailVirtual = MAXLONG;
1356     }
1357
1358     /* work around for broken photoshop 4 installer */
1359     if ( lpBuffer->dwAvailPhys +  lpBuffer->dwAvailPageFile >= 2U*1024*1024*1024)
1360          lpBuffer->dwAvailPageFile = 2U*1024*1024*1024 -  lpBuffer->dwAvailPhys - 1;
1361
1362     /* limit page file size for really old binaries */
1363     if (nt->OptionalHeader.MajorSubsystemVersion < 4)
1364     {
1365         if (lpBuffer->dwTotalPageFile > MAXLONG) lpBuffer->dwTotalPageFile = MAXLONG;
1366         if (lpBuffer->dwAvailPageFile > MAXLONG) lpBuffer->dwAvailPageFile = MAXLONG;
1367     }
1368
1369     TRACE("Length %u, MemoryLoad %u, TotalPhys %lx, AvailPhys %lx,"
1370           " TotalPageFile %lx, AvailPageFile %lx, TotalVirtual %lx, AvailVirtual %lx\n",
1371           lpBuffer->dwLength, lpBuffer->dwMemoryLoad, lpBuffer->dwTotalPhys,
1372           lpBuffer->dwAvailPhys, lpBuffer->dwTotalPageFile, lpBuffer->dwAvailPageFile,
1373           lpBuffer->dwTotalVirtual, lpBuffer->dwAvailVirtual );
1374 }