Fixed small ==, != mixup.
[wine] / memory / global.c
1 /*
2  * Global heap functions
3  *
4  * Copyright 1995 Alexandre Julliard
5  */
6 /* 0xffff sometimes seems to mean: CURRENT_DS */
7
8 #include <sys/types.h>
9 #include <stdlib.h>
10 #include <unistd.h>
11 #include <string.h>
12
13 #include "wine/winbase16.h"
14 #include "global.h"
15 #include "heap.h"
16 #include "toolhelp.h"
17 #include "selectors.h"
18 #include "miscemu.h"
19 #include "dde_mem.h"
20 #include "stackframe.h"
21 #include "module.h"
22 #include "debug.h"
23 #include "winerror.h"
24
25   /* Global arena block */
26 typedef struct
27 {
28     DWORD     base;          /* Base address (0 if discarded) */
29     DWORD     size;          /* Size in bytes (0 indicates a free block) */
30     HGLOBAL16 handle;        /* Handle for this block */
31     HGLOBAL16 hOwner;        /* Owner of this block */
32     BYTE      lockCount;     /* Count of GlobalFix() calls */
33     BYTE      pageLockCount; /* Count of GlobalPageLock() calls */
34     BYTE      flags;         /* Allocation flags */
35     BYTE      selCount;      /* Number of selectors allocated for this block */
36 #ifdef CONFIG_IPC
37     int       shmid;
38 #endif
39 } GLOBALARENA;
40
41   /* Flags definitions */
42 #define GA_MOVEABLE     0x02  /* same as GMEM_MOVEABLE */
43 #define GA_DGROUP       0x04
44 #define GA_DISCARDABLE  0x08
45 #define GA_IPCSHARE     0x10  /* same as GMEM_DDESHARE */
46
47   /* Arena array */
48 static GLOBALARENA *pGlobalArena = NULL;
49 static int globalArenaSize = 0;
50
51 #define GLOBAL_MAX_ALLOC_SIZE 0x00ff0000  /* Largest allocation is 16M - 64K */
52
53 #define VALID_HANDLE(handle) (((handle)>>__AHSHIFT)<globalArenaSize)
54 #define GET_ARENA_PTR(handle)  (pGlobalArena + ((handle) >> __AHSHIFT))
55
56 /***********************************************************************
57  *           GLOBAL_GetArena
58  *
59  * Return the arena for a given selector, growing the arena array if needed.
60  */
61 static GLOBALARENA *GLOBAL_GetArena( WORD sel, WORD selcount )
62 {
63     if (((sel >> __AHSHIFT) + selcount) > globalArenaSize)
64     {
65         int newsize = ((sel >> __AHSHIFT) + selcount + 0xff) & ~0xff;
66         GLOBALARENA *pNewArena = realloc( pGlobalArena,
67                                           newsize * sizeof(GLOBALARENA) );
68         if (!pNewArena) return 0;
69         pGlobalArena = pNewArena;
70         memset( pGlobalArena + globalArenaSize, 0,
71                 (newsize - globalArenaSize) * sizeof(GLOBALARENA) );
72         globalArenaSize = newsize;
73     }
74     return pGlobalArena + (sel >> __AHSHIFT);
75 }
76
77
78 void debug_handles(void)
79 {
80     int printed=0;
81     int i;
82     for (i = globalArenaSize-1 ; i>=0 ; i--) {
83         if (pGlobalArena[i].size!=0 && (pGlobalArena[i].handle & 0x8000)){
84             printed=1;
85             DUMP("0x%08x, ",pGlobalArena[i].handle);
86         }
87     }
88     if (printed)
89         DUMP("\n");
90 }
91
92
93 /***********************************************************************
94  *           GLOBAL_CreateBlock
95  *
96  * Create a global heap block for a fixed range of linear memory.
97  */
98 HGLOBAL16 GLOBAL_CreateBlock( WORD flags, const void *ptr, DWORD size,
99                               HGLOBAL16 hOwner, BOOL16 isCode,
100                               BOOL16 is32Bit, BOOL16 isReadOnly,
101                               SHMDATA *shmdata  )
102 {
103     WORD sel, selcount;
104     GLOBALARENA *pArena;
105
106       /* Allocate the selector(s) */
107
108     sel = SELECTOR_AllocBlock( ptr, size,
109                               isCode ? SEGMENT_CODE : SEGMENT_DATA,
110                               is32Bit, isReadOnly );
111     
112     if (!sel) return 0;
113     selcount = (size + 0xffff) / 0x10000;
114
115     if (!(pArena = GLOBAL_GetArena( sel, selcount )))
116     {
117         SELECTOR_FreeBlock( sel, selcount );
118         return 0;
119     }
120
121       /* Fill the arena block */
122
123     pArena->base = (DWORD)ptr;
124     pArena->size = GET_SEL_LIMIT(sel) + 1;
125
126 #ifdef CONFIG_IPC
127     if (flags & GMEM_DDESHARE)
128     {
129         pArena->handle = shmdata->handle;
130         pArena->shmid  = shmdata->shmid;
131         shmdata->sel   = sel;
132     }
133     else
134     {
135         pArena->handle = (flags & GMEM_MOVEABLE) ? sel - 1 : sel;
136         pArena->shmid  = 0;
137     }
138 #else
139     pArena->handle = (flags & GMEM_MOVEABLE) ? sel - 1 : sel;
140 #endif
141     pArena->hOwner = hOwner;
142     pArena->lockCount = 0;
143     pArena->pageLockCount = 0;
144     pArena->flags = flags & GA_MOVEABLE;
145     if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
146     if (flags & GMEM_DDESHARE) pArena->flags |= GA_IPCSHARE;
147     if (!isCode) pArena->flags |= GA_DGROUP;
148     pArena->selCount = selcount;
149     if (selcount > 1)  /* clear the next arena blocks */
150         memset( pArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
151
152     return pArena->handle;
153 }
154
155
156 /***********************************************************************
157  *           GLOBAL_FreeBlock
158  *
159  * Free a block allocated by GLOBAL_CreateBlock, without touching
160  * the associated linear memory range.
161  */
162 BOOL16 GLOBAL_FreeBlock( HGLOBAL16 handle )
163 {
164     WORD sel;
165     GLOBALARENA *pArena;
166
167     if (!handle) return TRUE;
168     sel = GlobalHandleToSel16( handle ); 
169     if (!VALID_HANDLE(sel))
170         return FALSE;
171     pArena = GET_ARENA_PTR(sel);
172     SELECTOR_FreeBlock( sel, (pArena->size + 0xffff) / 0x10000 );
173     memset( pArena, 0, sizeof(GLOBALARENA) );
174     return TRUE;
175 }
176
177 /***********************************************************************
178  *           GLOBAL_MoveBlock
179  */
180 BOOL16 GLOBAL_MoveBlock( HGLOBAL16 handle, const void *ptr, DWORD size )
181 {
182     WORD sel;
183     GLOBALARENA *pArena;
184
185     if (!handle) return TRUE;
186     sel = GlobalHandleToSel16( handle ); 
187     if (!VALID_HANDLE(sel))
188         return FALSE;
189     pArena = GET_ARENA_PTR(sel);
190     if (pArena->selCount != 1)
191         return FALSE;
192
193     pArena->base = (DWORD)ptr;
194     pArena->size = size;
195
196     SELECTOR_MoveBlock( sel, ptr );
197     SetSelectorLimit16( sel, size-1 );
198
199     return TRUE;
200 }
201
202 /***********************************************************************
203  *           GLOBAL_Alloc
204  *
205  * Implementation of GlobalAlloc16()
206  */
207 HGLOBAL16 GLOBAL_Alloc( UINT16 flags, DWORD size, HGLOBAL16 hOwner,
208                         BOOL16 isCode, BOOL16 is32Bit, BOOL16 isReadOnly )
209 {
210     void *ptr;
211     HGLOBAL16 handle;
212     SHMDATA shmdata;
213
214     TRACE(global, "%ld flags=%04x\n", size, flags );
215
216     /* If size is 0, create a discarded block */
217
218     if (size == 0) return GLOBAL_CreateBlock( flags, NULL, 1, hOwner, isCode,
219                                               is32Bit, isReadOnly, NULL );
220
221     /* Fixup the size */
222
223     if (size >= GLOBAL_MAX_ALLOC_SIZE - 0x1f) return 0;
224     size = (size + 0x1f) & ~0x1f;
225
226       /* Allocate the linear memory */
227
228 #ifdef CONFIG_IPC
229     if (flags & GMEM_DDESHARE)
230         ptr = DDE_malloc(flags, size, &shmdata);
231     else 
232 #endif  /* CONFIG_IPC */
233     {
234         ptr = HeapAlloc( SystemHeap, 0, size );
235     }
236       /* FIXME: free discardable blocks and try again? */
237     if (!ptr) return 0;
238
239       /* Allocate the selector(s) */
240
241     handle = GLOBAL_CreateBlock( flags, ptr, size, hOwner,
242                                 isCode, is32Bit, isReadOnly, &shmdata);
243     if (!handle)
244     {
245         HeapFree( SystemHeap, 0, ptr );
246         return 0;
247     }
248
249     if (flags & GMEM_ZEROINIT) memset( ptr, 0, size );
250     return handle;
251 }
252
253
254 #ifdef CONFIG_IPC
255 /***********************************************************************
256  *           GLOBAL_FindArena
257  *
258  * Find the arena  for a given handle
259  * (when handle is not serial - e.g. DDE)
260  */
261 static GLOBALARENA *GLOBAL_FindArena( HGLOBAL16 handle)
262 {
263     int i;
264     for (i = globalArenaSize-1 ; i>=0 ; i--) {
265         if (pGlobalArena[i].size!=0 && pGlobalArena[i].handle == handle)
266             return ( &pGlobalArena[i] );
267     }
268     return NULL;
269 }
270
271
272 /***********************************************************************
273  *           DDE_GlobalHandleToSel
274  */
275
276 WORD DDE_GlobalHandleToSel( HGLOBAL16 handle )
277 {
278     GLOBALARENA *pArena;
279     SEGPTR segptr;
280     
281     pArena= GLOBAL_FindArena(handle);
282     if (pArena) {
283         int ArenaIdx = pArena - pGlobalArena;
284
285         /* See if synchronized to the shared memory  */
286         return DDE_SyncHandle(handle, ( ArenaIdx << __AHSHIFT) | 7);
287     }
288
289     /* attach the block */
290     DDE_AttachHandle(handle, &segptr);
291
292     return SELECTOROF( segptr );
293 }
294 #endif  /* CONFIG_IPC */
295
296
297 /***********************************************************************
298  *           GlobalAlloc16   (KERNEL.15)
299  * RETURNS
300  *      Handle: Success
301  *      NULL: Failure
302  */
303 HGLOBAL16 WINAPI GlobalAlloc16(
304                  UINT16 flags, /* [in] Object allocation attributes */
305                  DWORD size    /* [in] Number of bytes to allocate */
306 ) {
307     HANDLE16 owner = GetCurrentPDB16();
308
309     if (flags & GMEM_DDESHARE)
310         owner = GetExePtr(owner);  /* Make it a module handle */
311     return GLOBAL_Alloc( flags, size, owner, FALSE, FALSE, FALSE );
312 }
313
314
315 /***********************************************************************
316  *           GlobalReAlloc16   (KERNEL.16)
317  * RETURNS
318  *      Handle: Success
319  *      NULL: Failure
320  */
321 HGLOBAL16 WINAPI GlobalReAlloc16(
322                  HGLOBAL16 handle, /* [in] Handle of global memory object */
323                  DWORD size,       /* [in] New size of block */
324                  UINT16 flags      /* [in] How to reallocate object */
325 ) {
326     WORD selcount;
327     DWORD oldsize;
328     void *ptr;
329     GLOBALARENA *pArena, *pNewArena;
330     WORD sel = GlobalHandleToSel16( handle );
331
332     TRACE(global, "%04x %ld flags=%04x\n",
333                     handle, size, flags );
334     if (!handle) return 0;
335     
336 #ifdef CONFIG_IPC
337     if (flags & GMEM_DDESHARE || is_dde_handle(handle))
338     {
339         FIXME(global, "shared memory reallocating unimplemented\n"); 
340         return 0;
341     }
342 #endif  /* CONFIG_IPC */
343
344     if (!VALID_HANDLE(handle)) {
345         WARN(global, "Invalid handle 0x%04x!\n", handle);
346         return 0;
347     }
348     pArena = GET_ARENA_PTR( handle );
349
350       /* Discard the block if requested */
351
352     if ((size == 0) && (flags & GMEM_MOVEABLE) && !(flags & GMEM_MODIFY))
353     {
354         if (!(pArena->flags & GA_MOVEABLE) ||
355             !(pArena->flags & GA_DISCARDABLE) ||
356             (pArena->lockCount > 0) || (pArena->pageLockCount > 0)) return 0;
357         HeapFree( SystemHeap, 0, (void *)pArena->base );
358         pArena->base = 0;
359
360         /* Note: we rely on the fact that SELECTOR_ReallocBlock won't 
361          * change the selector if we are shrinking the block.
362          * FIXME: shouldn't we keep selectors until the block is deleted?
363          */
364         SELECTOR_ReallocBlock( sel, 0, 1, SEGMENT_DATA, 0, 0 );
365         return handle;
366     }
367
368       /* Fixup the size */
369
370     if (size > GLOBAL_MAX_ALLOC_SIZE - 0x20) return 0;
371     if (size == 0) size = 0x20;
372     else size = (size + 0x1f) & ~0x1f;
373
374       /* Change the flags */
375
376     if (flags & GMEM_MODIFY)
377     {
378           /* Change the flags, leaving GA_DGROUP alone */
379         pArena->flags = (pArena->flags & GA_DGROUP) | (flags & GA_MOVEABLE);
380         if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
381         return handle;
382     }
383
384       /* Reallocate the linear memory */
385
386     ptr = (void *)pArena->base;
387     oldsize = pArena->size;
388     TRACE(global,"oldsize %08lx\n",oldsize);
389     if (ptr && (size == oldsize)) return handle;  /* Nothing to do */
390
391     ptr = HeapReAlloc( SystemHeap, 0, ptr, size );
392     if (!ptr)
393     {
394         SELECTOR_FreeBlock( sel, (oldsize + 0xffff) / 0x10000 );
395         memset( pArena, 0, sizeof(GLOBALARENA) );
396         return 0;
397     }
398
399       /* Reallocate the selector(s) */
400
401     sel = SELECTOR_ReallocBlock( sel, ptr, size, SEGMENT_DATA, 0, 0 );
402     if (!sel)
403     {
404         HeapFree( SystemHeap, 0, ptr );
405         memset( pArena, 0, sizeof(GLOBALARENA) );
406         return 0;
407     }
408     selcount = (size + 0xffff) / 0x10000;
409
410     if (!(pNewArena = GLOBAL_GetArena( sel, selcount )))
411     {
412         HeapFree( SystemHeap, 0, ptr );
413         SELECTOR_FreeBlock( sel, selcount );
414         return 0;
415     }
416
417       /* Fill the new arena block */
418
419     if (pNewArena != pArena) memcpy( pNewArena, pArena, sizeof(GLOBALARENA) );
420     pNewArena->base = (DWORD)ptr;
421     pNewArena->size = GET_SEL_LIMIT(sel) + 1;
422     pNewArena->selCount = selcount;
423     pNewArena->handle = (pNewArena->flags & GA_MOVEABLE) ? sel - 1 : sel;
424
425     if (selcount > 1)  /* clear the next arena blocks */
426         memset( pNewArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
427
428     if ((oldsize < size) && (flags & GMEM_ZEROINIT))
429         memset( (char *)ptr + oldsize, 0, size - oldsize );
430     return pNewArena->handle;
431 }
432
433
434 /***********************************************************************
435  *           GlobalFree16   (KERNEL.17)
436  * RETURNS
437  *      NULL: Success
438  *      Handle: Failure
439  */
440 HGLOBAL16 WINAPI GlobalFree16(
441                  HGLOBAL16 handle /* [in] Handle of global memory object */
442 ) {
443     void *ptr;
444
445     if (!VALID_HANDLE(handle)) {
446         WARN(global,"Invalid handle 0x%04x passed to GlobalFree16!\n",handle);
447         return 0;
448     }
449     ptr = (void *)GET_ARENA_PTR(handle)->base;
450
451     TRACE(global, "%04x\n", handle );
452     if (!GLOBAL_FreeBlock( handle )) return handle;  /* failed */
453 #ifdef CONFIG_IPC
454     if (is_dde_handle(handle)) return DDE_GlobalFree(handle);
455 #endif  /* CONFIG_IPC */
456     if (ptr) HeapFree( SystemHeap, 0, ptr );
457     return 0;
458 }
459
460
461 /***********************************************************************
462  *           WIN16_GlobalLock16   (KERNEL.18)
463  *
464  * This is the GlobalLock16() function used by 16-bit code.
465  */
466 SEGPTR WINAPI WIN16_GlobalLock16( HGLOBAL16 handle )
467 {
468     TRACE(global, "(%04x) -> %08lx\n",
469                     handle, MAKELONG( 0, GlobalHandleToSel16(handle)) );
470     if (handle)
471     {
472         if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
473
474 #ifdef CONFIG_IPC
475         if (is_dde_handle(handle))
476             return PTR_SEG_OFF_TO_SEGPTR( DDE_GlobalHandleToSel(handle), 0 );
477 #endif  /* CONFIG_IPC */
478
479         if (!VALID_HANDLE(handle)) {
480             WARN(global,"Invalid handle 0x%04x passed to WIN16_GlobalLock16!\n",handle);
481             return (SEGPTR)0;
482         }
483         if (!GET_ARENA_PTR(handle)->base) return (SEGPTR)0;
484         GET_ARENA_PTR(handle)->lockCount++;
485         return PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel16(handle), 0 );
486         /* FIXME: put segment value in CX as well */
487     }
488     return (SEGPTR)0;
489 }
490
491
492 /***********************************************************************
493  *           GlobalLock16   (KERNEL.18)
494  *
495  * This is the GlobalLock16() function used by 32-bit code.
496  * 
497  * RETURNS
498  *      Pointer to first byte of memory block
499  *      NULL: Failure
500  */
501 LPVOID WINAPI GlobalLock16(
502               HGLOBAL16 handle /* [in] Handle of global memory object */
503 ) {
504     if (!handle) return 0;
505     if (!VALID_HANDLE(handle))
506         return (LPVOID)0;
507     GET_ARENA_PTR(handle)->lockCount++;
508 #ifdef CONFIG_IPC
509     if (is_dde_handle(handle)) return DDE_AttachHandle(handle, NULL);
510 #endif
511     return (LPVOID)GET_ARENA_PTR(handle)->base;
512 }
513
514
515 /***********************************************************************
516  *           GlobalUnlock16   (KERNEL.19)
517  * NOTES
518  *      Should the return values be cast to booleans?
519  *
520  * RETURNS
521  *      TRUE: Object is still locked
522  *      FALSE: Object is unlocked
523  */
524 BOOL16 WINAPI GlobalUnlock16(
525               HGLOBAL16 handle /* [in] Handle of global memory object */
526 ) {
527     GLOBALARENA *pArena = GET_ARENA_PTR(handle);
528     if (!VALID_HANDLE(handle)) {
529         WARN(global,"Invalid handle 0x%04x passed to GlobalUnlock16!\n",handle);
530         return 0;
531     }
532     TRACE(global, "%04x\n", handle );
533     if (pArena->lockCount) pArena->lockCount--;
534     return pArena->lockCount;
535 }
536
537 /***********************************************************************
538  *     GlobalChangeLockCount               (KERNEL.365)
539  *
540  * This is declared as a register function as it has to preserve
541  * *all* registers, even AX/DX !
542  *
543  */
544 void WINAPI GlobalChangeLockCount16( CONTEXT *context )
545 {
546     LPWORD args = PTR_SEG_OFF_TO_LIN( SS_reg( context ), SP_reg( context ) );
547     HGLOBAL16 handle = (HGLOBAL16)args[3];
548     INT16     delta  = (INT16)    args[2];
549
550     if ( delta == 1 )
551         GlobalLock16( handle );
552     else if ( delta == -1 )
553         GlobalUnlock16( handle );
554     else
555         ERR( global, "(%04X, %d): strange delta value\n", handle, delta );
556 }
557
558 /***********************************************************************
559  *           GlobalSize16   (KERNEL.20)
560  * RETURNS
561  *      Size in bytes of object
562  *      0: Failure
563  */
564 DWORD WINAPI GlobalSize16(
565              HGLOBAL16 handle /* [in] Handle of global memory object */
566 ) {
567     TRACE(global, "%04x\n", handle );
568     if (!handle) return 0;
569     if (!VALID_HANDLE(handle))
570         return 0;
571     return GET_ARENA_PTR(handle)->size;
572 }
573
574
575 /***********************************************************************
576  *           GlobalHandle16   (KERNEL.21)
577  * NOTES
578  *      Why is GlobalHandleToSel used here with the sel as input?
579  *
580  * RETURNS
581  *      Handle: Success
582  *      NULL: Failure
583  */
584 DWORD WINAPI GlobalHandle16(
585              WORD sel /* [in] Address of global memory block */
586 ) {
587     TRACE(global, "%04x\n", sel );
588     if (!VALID_HANDLE(sel)) {
589         WARN(global,"Invalid handle 0x%04x passed to GlobalHandle16!\n",sel);
590         return 0;
591     }
592     return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel16(sel) );
593 }
594
595 /***********************************************************************
596  *           GlobalHandleNoRIP   (KERNEL.159)
597  */
598 DWORD WINAPI GlobalHandleNoRIP16( WORD sel )
599 {
600     int i;
601     for (i = globalArenaSize-1 ; i>=0 ; i--) {
602         if (pGlobalArena[i].size!=0 && pGlobalArena[i].handle == sel)
603                 return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel16(sel) );
604     }
605     return 0;
606 }
607
608
609 /***********************************************************************
610  *           GlobalFlags16   (KERNEL.22)
611  * NOTES
612  *      Should this return GMEM_INVALID_HANDLE instead of 0 on invalid
613  *      handle?
614  *
615  * RETURNS
616  *      Value specifying flags and lock count
617  *      GMEM_INVALID_HANDLE: Invalid handle
618  */
619 UINT16 WINAPI GlobalFlags16(
620               HGLOBAL16 handle /* [in] Handle of global memory object */
621 ) {
622     GLOBALARENA *pArena;
623
624     TRACE(global, "%04x\n", handle );
625     if (!VALID_HANDLE(handle)) {
626         WARN(global,"Invalid handle 0x%04x passed to GlobalFlags16!\n",handle);
627         return 0;
628     }
629     pArena = GET_ARENA_PTR(handle);
630     return pArena->lockCount |
631            ((pArena->flags & GA_DISCARDABLE) ? GMEM_DISCARDABLE : 0) |
632            ((pArena->base == 0) ? GMEM_DISCARDED : 0);
633 }
634
635
636 /***********************************************************************
637  *           LockSegment16   (KERNEL.23)
638  */
639 HGLOBAL16 WINAPI LockSegment16( HGLOBAL16 handle )
640 {
641     TRACE(global, "%04x\n", handle );
642     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
643     if (!VALID_HANDLE(handle)) {
644         WARN(global,"Invalid handle 0x%04x passed to LockSegment16!\n",handle);
645         return 0;
646     }
647     GET_ARENA_PTR(handle)->lockCount++;
648     return handle;
649 }
650
651
652 /***********************************************************************
653  *           UnlockSegment16   (KERNEL.24)
654  */
655 void WINAPI UnlockSegment16( HGLOBAL16 handle )
656 {
657     TRACE(global, "%04x\n", handle );
658     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
659     if (!VALID_HANDLE(handle)) {
660         WARN(global,"Invalid handle 0x%04x passed to UnlockSegment16!\n",handle);
661         return;
662     }
663     GET_ARENA_PTR(handle)->lockCount--;
664     /* FIXME: this ought to return the lock count in CX (go figure...) */
665 }
666
667
668 /***********************************************************************
669  *           GlobalCompact16   (KERNEL.25)
670  */
671 DWORD WINAPI GlobalCompact16( DWORD desired )
672 {
673     return GLOBAL_MAX_ALLOC_SIZE;
674 }
675
676
677 /***********************************************************************
678  *           GlobalFreeAll   (KERNEL.26)
679  */
680 void WINAPI GlobalFreeAll16( HGLOBAL16 owner )
681 {
682     DWORD i;
683     GLOBALARENA *pArena;
684
685     pArena = pGlobalArena;
686     for (i = 0; i < globalArenaSize; i++, pArena++)
687     {
688         if ((pArena->size != 0) && (pArena->hOwner == owner))
689             GlobalFree16( pArena->handle );
690     }
691 }
692
693
694 /***********************************************************************
695  *           GlobalWire16   (KERNEL.111)
696  */
697 SEGPTR WINAPI GlobalWire16( HGLOBAL16 handle )
698 {
699     return WIN16_GlobalLock16( handle );
700 }
701
702
703 /***********************************************************************
704  *           GlobalUnWire16   (KERNEL.112)
705  */
706 BOOL16 WINAPI GlobalUnWire16( HGLOBAL16 handle )
707 {
708     return !GlobalUnlock16( handle );
709 }
710
711
712 /***********************************************************************
713  *           SetSwapAreaSize16   (KERNEL.106)
714  */
715 LONG WINAPI SetSwapAreaSize16( WORD size )
716 {
717     FIXME(global, "(%d) - stub!\n", size );
718     return MAKELONG( size, 0xffff );
719 }
720
721
722 /***********************************************************************
723  *           GlobalLRUOldest   (KERNEL.163)
724  */
725 HGLOBAL16 WINAPI GlobalLRUOldest16( HGLOBAL16 handle )
726 {
727     TRACE(global, "%04x\n", handle );
728     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
729     return handle;
730 }
731
732
733 /***********************************************************************
734  *           GlobalLRUNewest   (KERNEL.164)
735  */
736 HGLOBAL16 WINAPI GlobalLRUNewest16( HGLOBAL16 handle )
737 {
738     TRACE(global, "%04x\n", handle );
739     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
740     return handle;
741 }
742
743
744 /***********************************************************************
745  *           GetFreeSpace16   (KERNEL.169)
746  */
747 DWORD WINAPI GetFreeSpace16( UINT16 wFlags )
748 {
749     MEMORYSTATUS ms;
750     GlobalMemoryStatus( &ms );
751     return ms.dwAvailVirtual;
752 }
753
754 /***********************************************************************
755  *           GlobalDOSAlloc   (KERNEL.184)
756  * RETURNS
757  *      Address (HW=Paragraph segment; LW=Selector)
758  */
759 DWORD WINAPI GlobalDOSAlloc16(
760              DWORD size /* [in] Number of bytes to be allocated */
761 ) {
762    UINT16    uParagraph;
763    LPVOID    lpBlock = DOSMEM_GetBlock( 0, size, &uParagraph );
764
765    if( lpBlock )
766    {
767        HMODULE16 hModule = GetModuleHandle16("KERNEL");
768        WORD      wSelector;
769    
770        wSelector = GLOBAL_CreateBlock(GMEM_FIXED, lpBlock, size, 
771                                       hModule, 0, 0, 0, NULL );
772        return MAKELONG(wSelector,uParagraph);
773    }
774    return 0;
775 }
776
777
778 /***********************************************************************
779  *           GlobalDOSFree      (KERNEL.185)
780  * RETURNS
781  *      NULL: Success
782  *      sel: Failure
783  */
784 WORD WINAPI GlobalDOSFree16(
785             WORD sel /* [in] Selector */
786 ) {
787    DWORD   block = GetSelectorBase(sel);
788
789    if( block && block < 0x100000 ) 
790    {
791        LPVOID lpBlock = DOSMEM_MapDosToLinear( block );
792        if( DOSMEM_FreeBlock( 0, lpBlock ) )
793            GLOBAL_FreeBlock( sel );
794        sel = 0;
795    }
796    return sel;
797 }
798
799
800 /***********************************************************************
801  *           GlobalPageLock   (KERNEL.191)
802  */
803 WORD WINAPI GlobalPageLock16( HGLOBAL16 handle )
804 {
805     TRACE(global, "%04x\n", handle );
806     if (!VALID_HANDLE(handle)) {
807         WARN(global,"Invalid handle 0x%04x passed to GlobalPageLock!\n",handle);
808         return 0;
809     }
810     return ++(GET_ARENA_PTR(handle)->pageLockCount);
811 }
812
813
814 /***********************************************************************
815  *           GlobalPageUnlock   (KERNEL.192)
816  */
817 WORD WINAPI GlobalPageUnlock16( HGLOBAL16 handle )
818 {
819     TRACE(global, "%04x\n", handle );
820     if (!VALID_HANDLE(handle)) {
821         WARN(global,"Invalid handle 0x%04x passed to GlobalPageUnlock!\n",handle);
822         return 0;
823     }
824     return --(GET_ARENA_PTR(handle)->pageLockCount);
825 }
826
827
828 /***********************************************************************
829  *           GlobalFix16   (KERNEL.197)
830  */
831 WORD WINAPI GlobalFix16( HGLOBAL16 handle )
832 {
833     TRACE(global, "%04x\n", handle );
834     if (!VALID_HANDLE(handle)) {
835         WARN(global,"Invalid handle 0x%04x passed to GlobalFix16!\n",handle);
836         return 0;
837     }
838     GET_ARENA_PTR(handle)->lockCount++;
839
840     return GlobalHandleToSel16(handle);
841 }
842
843
844 /***********************************************************************
845  *           GlobalUnfix16   (KERNEL.198)
846  */
847 void WINAPI GlobalUnfix16( HGLOBAL16 handle )
848 {
849     TRACE(global, "%04x\n", handle );
850     if (!VALID_HANDLE(handle)) {
851         WARN(global,"Invalid handle 0x%04x passed to GlobalUnfix16!\n",handle);
852         return;
853     }
854     GET_ARENA_PTR(handle)->lockCount--;
855 }
856
857
858 /***********************************************************************
859  *           FarSetOwner   (KERNEL.403)
860  */
861 void WINAPI FarSetOwner16( HGLOBAL16 handle, HANDLE16 hOwner )
862 {
863     if (!VALID_HANDLE(handle)) {
864         WARN(global,"Invalid handle 0x%04x passed to FarSetOwner!\n",handle);
865         return;
866     }
867     GET_ARENA_PTR(handle)->hOwner = hOwner;
868 }
869
870
871 /***********************************************************************
872  *           FarGetOwner   (KERNEL.404)
873  */
874 HANDLE16 WINAPI FarGetOwner16( HGLOBAL16 handle )
875 {
876     if (!VALID_HANDLE(handle)) {
877         WARN(global,"Invalid handle 0x%04x passed to FarGetOwner!\n",handle);
878         return 0;
879     }
880     return GET_ARENA_PTR(handle)->hOwner;
881 }
882
883
884 /***********************************************************************
885  *           GlobalHandleToSel   (TOOLHELP.50)
886  */
887 WORD WINAPI GlobalHandleToSel16( HGLOBAL16 handle )
888 {
889     if (!handle) return 0;
890 #ifdef CONFIG_IPC
891     if (is_dde_handle(handle)) return DDE_GlobalHandleToSel(handle);
892 #endif
893     if (!VALID_HANDLE(handle)) {
894         WARN(global,"Invalid handle 0x%04x passed to GlobalHandleToSel!\n",handle);
895         return 0;
896     }
897     if (!(handle & 7))
898     {
899         WARN(global, "Program attempted invalid selector conversion\n" );
900         return handle - 1;
901     }
902     return handle | 7;
903 }
904
905
906 /***********************************************************************
907  *           GlobalFirst   (TOOLHELP.51)
908  */
909 BOOL16 WINAPI GlobalFirst16( GLOBALENTRY *pGlobal, WORD wFlags )
910 {
911     if (wFlags == GLOBAL_LRU) return FALSE;
912     pGlobal->dwNext = 0;
913     return GlobalNext16( pGlobal, wFlags );
914 }
915
916
917 /***********************************************************************
918  *           GlobalNext   (TOOLHELP.52)
919  */
920 BOOL16 WINAPI GlobalNext16( GLOBALENTRY *pGlobal, WORD wFlags)
921 {
922     GLOBALARENA *pArena;
923
924     if (pGlobal->dwNext >= globalArenaSize) return FALSE;
925     pArena = pGlobalArena + pGlobal->dwNext;
926     if (wFlags == GLOBAL_FREE)  /* only free blocks */
927     {
928         int i;
929         for (i = pGlobal->dwNext; i < globalArenaSize; i++, pArena++)
930             if (pArena->size == 0) break;  /* block is free */
931         if (i >= globalArenaSize) return FALSE;
932         pGlobal->dwNext = i;
933     }
934
935     pGlobal->dwAddress    = pArena->base;
936     pGlobal->dwBlockSize  = pArena->size;
937     pGlobal->hBlock       = pArena->handle;
938     pGlobal->wcLock       = pArena->lockCount;
939     pGlobal->wcPageLock   = pArena->pageLockCount;
940     pGlobal->wFlags       = (GetCurrentPDB16() == pArena->hOwner);
941     pGlobal->wHeapPresent = FALSE;
942     pGlobal->hOwner       = pArena->hOwner;
943     pGlobal->wType        = GT_UNKNOWN;
944     pGlobal->wData        = 0;
945     pGlobal->dwNext++;
946     return TRUE;
947 }
948
949
950 /***********************************************************************
951  *           GlobalInfo   (TOOLHELP.53)
952  */
953 BOOL16 WINAPI GlobalInfo16( GLOBALINFO *pInfo )
954 {
955     int i;
956     GLOBALARENA *pArena;
957
958     pInfo->wcItems = globalArenaSize;
959     pInfo->wcItemsFree = 0;
960     pInfo->wcItemsLRU = 0;
961     for (i = 0, pArena = pGlobalArena; i < globalArenaSize; i++, pArena++)
962         if (pArena->size == 0) pInfo->wcItemsFree++;
963     return TRUE;
964 }
965
966
967 /***********************************************************************
968  *           GlobalEntryHandle   (TOOLHELP.54)
969  */
970 BOOL16 WINAPI GlobalEntryHandle16( GLOBALENTRY *pGlobal, HGLOBAL16 hItem )
971 {
972     GLOBALARENA *pArena = GET_ARENA_PTR(hItem);
973
974     pGlobal->dwAddress    = pArena->base;
975     pGlobal->dwBlockSize  = pArena->size;
976     pGlobal->hBlock       = pArena->handle;
977     pGlobal->wcLock       = pArena->lockCount;
978     pGlobal->wcPageLock   = pArena->pageLockCount;
979     pGlobal->wFlags       = (GetCurrentPDB16() == pArena->hOwner);
980     pGlobal->wHeapPresent = FALSE;
981     pGlobal->hOwner       = pArena->hOwner;
982     pGlobal->wType        = GT_UNKNOWN;
983     pGlobal->wData        = 0;
984     pGlobal->dwNext++;
985     return TRUE;
986 }
987
988
989 /***********************************************************************
990  *           GlobalEntryModule   (TOOLHELP.55)
991  */
992 BOOL16 WINAPI GlobalEntryModule16( GLOBALENTRY *pGlobal, HMODULE16 hModule,
993                                  WORD wSeg )
994 {
995     return FALSE;
996 }
997
998
999 /***********************************************************************
1000  *           MemManInfo   (TOOLHELP.72)
1001  */
1002 BOOL16 WINAPI MemManInfo16( MEMMANINFO *info )
1003 {
1004     MEMORYSTATUS status;
1005
1006     /*
1007      * Not unsurprisingly although the documention says you 
1008      * _must_ provide the size in the dwSize field, this function
1009      * (under Windows) always fills the structure and returns true.
1010      */
1011     GlobalMemoryStatus( &status );
1012     info->wPageSize            = VIRTUAL_GetPageSize();
1013     info->dwLargestFreeBlock   = status.dwAvailVirtual;
1014     info->dwMaxPagesAvailable  = info->dwLargestFreeBlock / info->wPageSize;
1015     info->dwMaxPagesLockable   = info->dwMaxPagesAvailable;
1016     info->dwTotalLinearSpace   = status.dwTotalVirtual / info->wPageSize;
1017     info->dwTotalUnlockedPages = info->dwTotalLinearSpace;
1018     info->dwFreePages          = info->dwMaxPagesAvailable;
1019     info->dwTotalPages         = info->dwTotalLinearSpace;
1020     info->dwFreeLinearSpace    = info->dwMaxPagesAvailable;
1021     info->dwSwapFilePages      = status.dwTotalPageFile / info->wPageSize;
1022     return TRUE;
1023 }
1024
1025 /***********************************************************************
1026  *           GetFreeMemInfo   (KERNEL.316)
1027  */
1028 DWORD WINAPI GetFreeMemInfo16(void)
1029 {
1030     MEMMANINFO info;
1031     MemManInfo16( &info );
1032     return MAKELONG( info.dwTotalLinearSpace, info.dwMaxPagesAvailable );
1033 }
1034
1035 /*
1036  * Win32 Global heap functions (GlobalXXX).
1037  * These functions included in Win32 for compatibility with 16 bit Windows
1038  * Especially the moveable blocks and handles are oldish. 
1039  * But the ability to directly allocate memory with GPTR and LPTR is widely
1040  * used.
1041  *
1042  * The handle stuff looks horrible, but it's implemented almost like Win95
1043  * does it. 
1044  *
1045  */
1046
1047 #define MAGIC_GLOBAL_USED 0x5342
1048 #define GLOBAL_LOCK_MAX   0xFF
1049 #define HANDLE_TO_INTERN(h)  ((PGLOBAL32_INTERN)(((char *)(h))-2))
1050 #define INTERN_TO_HANDLE(i)  ((HGLOBAL) &((i)->Pointer))
1051 #define POINTER_TO_HANDLE(p) (*(((HGLOBAL *)(p))-1))
1052 #define ISHANDLE(h)          (((DWORD)(h)&2)!=0)
1053 #define ISPOINTER(h)         (((DWORD)(h)&2)==0)
1054
1055 typedef struct __GLOBAL32_INTERN
1056 {
1057    WORD         Magic;
1058    LPVOID       Pointer WINE_PACKED;
1059    BYTE         Flags;
1060    BYTE         LockCount;
1061 } GLOBAL32_INTERN, *PGLOBAL32_INTERN;
1062
1063
1064 /***********************************************************************
1065  *           GlobalAlloc32   (KERNEL32.315)
1066  * RETURNS
1067  *      Handle: Success
1068  *      NULL: Failure
1069  */
1070 HGLOBAL WINAPI GlobalAlloc(
1071                  UINT flags, /* [in] Object allocation attributes */
1072                  DWORD size    /* [in] Number of bytes to allocate */
1073 ) {
1074    PGLOBAL32_INTERN     pintern;
1075    DWORD                hpflags;
1076    LPVOID               palloc;
1077
1078    if(flags&GMEM_ZEROINIT)
1079       hpflags=HEAP_ZERO_MEMORY;
1080    else
1081       hpflags=0;
1082    
1083    if((flags & GMEM_MOVEABLE)==0) /* POINTER */
1084    {
1085       palloc=HeapAlloc(GetProcessHeap(), hpflags, size);
1086       return (HGLOBAL) palloc;
1087    }
1088    else  /* HANDLE */
1089    {
1090       /* HeapLock(GetProcessHeap()); */
1091
1092       pintern=HeapAlloc(GetProcessHeap(), 0,  sizeof(GLOBAL32_INTERN));
1093       if(size)
1094       {
1095          palloc=HeapAlloc(GetProcessHeap(), hpflags, size+sizeof(HGLOBAL));
1096          *(HGLOBAL *)palloc=INTERN_TO_HANDLE(pintern);
1097          pintern->Pointer=palloc+sizeof(HGLOBAL);
1098       }
1099       else
1100          pintern->Pointer=NULL;
1101       pintern->Magic=MAGIC_GLOBAL_USED;
1102       pintern->Flags=flags>>8;
1103       pintern->LockCount=0;
1104       
1105       /* HeapUnlock(GetProcessHeap()); */
1106        
1107       return INTERN_TO_HANDLE(pintern);
1108    }
1109 }
1110
1111
1112 /***********************************************************************
1113  *           GlobalLock32   (KERNEL32.326)
1114  * RETURNS
1115  *      Pointer to first byte of block
1116  *      NULL: Failure
1117  */
1118 LPVOID WINAPI GlobalLock(
1119               HGLOBAL hmem /* [in] Handle of global memory object */
1120 ) {
1121    PGLOBAL32_INTERN pintern;
1122    LPVOID           palloc;
1123
1124    if(ISPOINTER(hmem))
1125       return (LPVOID) hmem;
1126
1127    /* HeapLock(GetProcessHeap()); */
1128    
1129    pintern=HANDLE_TO_INTERN(hmem);
1130    if(pintern->Magic==MAGIC_GLOBAL_USED)
1131    {
1132       if(pintern->LockCount<GLOBAL_LOCK_MAX)
1133          pintern->LockCount++;
1134       palloc=pintern->Pointer;
1135    }
1136    else
1137    {
1138       WARN(global, "invalid handle\n");
1139       palloc=(LPVOID) NULL;
1140    }
1141    /* HeapUnlock(GetProcessHeap()); */;
1142    return palloc;
1143 }
1144
1145
1146 /***********************************************************************
1147  *           GlobalUnlock32   (KERNEL32.332)
1148  * RETURNS
1149  *      TRUE: Object is still locked
1150  *      FALSE: Object is unlocked
1151  */
1152 BOOL WINAPI GlobalUnlock(
1153               HGLOBAL hmem /* [in] Handle of global memory object */
1154 ) {
1155    PGLOBAL32_INTERN       pintern;
1156    BOOL                 locked;
1157
1158    if(ISPOINTER(hmem))
1159       return FALSE;
1160
1161    /* HeapLock(GetProcessHeap()); */
1162    pintern=HANDLE_TO_INTERN(hmem);
1163    
1164    if(pintern->Magic==MAGIC_GLOBAL_USED)
1165    {
1166       if((pintern->LockCount<GLOBAL_LOCK_MAX)&&(pintern->LockCount>0))
1167          pintern->LockCount--;
1168
1169       locked=(pintern->LockCount==0) ? FALSE : TRUE;
1170    }
1171    else
1172    {
1173       WARN(global, "invalid handle\n");
1174       locked=FALSE;
1175    }
1176    /* HeapUnlock(GetProcessHeap()); */
1177    return locked;
1178 }
1179
1180
1181 /***********************************************************************
1182  *           GlobalHandle32   (KERNEL32.325)
1183  * Returns the handle associated with the specified pointer.
1184  *
1185  * NOTES
1186  *      Since there in only one goto, can it be removed and the return
1187  *      be put 'inline'?
1188  *
1189  * RETURNS
1190  *      Handle: Success
1191  *      NULL: Failure
1192  */
1193 HGLOBAL WINAPI GlobalHandle(
1194                  LPCVOID pmem /* [in] Pointer to global memory block */
1195 ) {
1196     HGLOBAL handle;
1197
1198     if (!HEAP_IsInsideHeap( GetProcessHeap(), 0, pmem )) goto error;
1199     handle = POINTER_TO_HANDLE(pmem);
1200     if (HEAP_IsInsideHeap( GetProcessHeap(), 0, (LPCVOID)handle ))
1201     {
1202         if (HANDLE_TO_INTERN(handle)->Magic == MAGIC_GLOBAL_USED)
1203             return handle;  /* valid moveable block */
1204     }
1205     /* maybe FIXED block */
1206     if (HeapValidate( GetProcessHeap(), 0, pmem ))
1207         return (HGLOBAL)pmem;  /* valid fixed block */
1208
1209 error:
1210     SetLastError( ERROR_INVALID_HANDLE );
1211     return 0;
1212 }
1213
1214
1215 /***********************************************************************
1216  *           GlobalReAlloc32   (KERNEL32.328)
1217  * RETURNS
1218  *      Handle: Success
1219  *      NULL: Failure
1220  */
1221 HGLOBAL WINAPI GlobalReAlloc(
1222                  HGLOBAL hmem, /* [in] Handle of global memory object */
1223                  DWORD size,     /* [in] New size of block */
1224                  UINT flags    /* [in] How to reallocate object */
1225 ) {
1226    LPVOID               palloc;
1227    HGLOBAL            hnew;
1228    PGLOBAL32_INTERN     pintern;
1229
1230    hnew = 0;
1231    /* HeapLock(GetProcessHeap()); */
1232    if(flags & GMEM_MODIFY) /* modify flags */
1233    {
1234       if( ISPOINTER(hmem) && (flags & GMEM_MOVEABLE))
1235       {
1236          /* make a fixed block moveable
1237           * actually only NT is able to do this. But it's soo simple
1238           */
1239          if (hmem == 0)
1240          {
1241              ERR(global, "GlobalReAlloc32 with null handle!\n");
1242              SetLastError( ERROR_NOACCESS );
1243              return 0;
1244          }
1245          size=HeapSize(GetProcessHeap(), 0, (LPVOID) hmem);
1246          hnew=GlobalAlloc( flags, size);
1247          palloc=GlobalLock(hnew);
1248          memcpy(palloc, (LPVOID) hmem, size);
1249          GlobalUnlock(hnew);
1250          GlobalFree(hmem);
1251       }
1252       else if( ISPOINTER(hmem) &&(flags & GMEM_DISCARDABLE))
1253       {
1254          /* change the flags to make our block "discardable" */
1255          pintern=HANDLE_TO_INTERN(hmem);
1256          pintern->Flags = pintern->Flags | (GMEM_DISCARDABLE >> 8);
1257          hnew=hmem;
1258       }
1259       else
1260       {
1261          SetLastError(ERROR_INVALID_PARAMETER);
1262          hnew = 0;
1263       }
1264    }
1265    else
1266    {
1267       if(ISPOINTER(hmem))
1268       {
1269          /* reallocate fixed memory */
1270          hnew=(HGLOBAL)HeapReAlloc(GetProcessHeap(), 0, (LPVOID) hmem, size);
1271       }
1272       else
1273       {
1274          /* reallocate a moveable block */
1275          pintern=HANDLE_TO_INTERN(hmem);
1276          if(pintern->LockCount>1) {
1277             ERR(global,"handle 0x%08lx is still locked, cannot realloc!\n",(DWORD)hmem);
1278             SetLastError(ERROR_INVALID_HANDLE);
1279          } else if(size!=0)
1280          {
1281             hnew=hmem;
1282             if(pintern->Pointer)
1283             {
1284                palloc=HeapReAlloc(GetProcessHeap(), 0,
1285                                   pintern->Pointer-sizeof(HGLOBAL),
1286                                   size+sizeof(HGLOBAL) );
1287                pintern->Pointer=palloc+sizeof(HGLOBAL);
1288             }
1289             else
1290             {
1291                palloc=HeapAlloc(GetProcessHeap(), 0, size+sizeof(HGLOBAL));
1292                *(HGLOBAL *)palloc=hmem;
1293                pintern->Pointer=palloc+sizeof(HGLOBAL);
1294             }
1295          }
1296          else
1297          {
1298             if(pintern->Pointer)
1299             {
1300                HeapFree(GetProcessHeap(), 0, pintern->Pointer-sizeof(HGLOBAL));
1301                pintern->Pointer=NULL;
1302             }
1303          }
1304       }
1305    }
1306    /* HeapUnlock(GetProcessHeap()); */
1307    return hnew;
1308 }
1309
1310
1311 /***********************************************************************
1312  *           GlobalFree32   (KERNEL32.322)
1313  * RETURNS
1314  *      NULL: Success
1315  *      Handle: Failure
1316  */
1317 HGLOBAL WINAPI GlobalFree(
1318                  HGLOBAL hmem /* [in] Handle of global memory object */
1319 ) {
1320    PGLOBAL32_INTERN pintern;
1321    HGLOBAL        hreturned = 0;
1322    
1323    if(ISPOINTER(hmem)) /* POINTER */
1324    {
1325       if(!HeapFree(GetProcessHeap(), 0, (LPVOID) hmem)) hmem = 0;
1326    }
1327    else  /* HANDLE */
1328    {
1329       /* HeapLock(GetProcessHeap()); */      
1330       pintern=HANDLE_TO_INTERN(hmem);
1331       
1332       if(pintern->Magic==MAGIC_GLOBAL_USED)
1333       {  
1334          if(pintern->LockCount!=0)
1335             SetLastError(ERROR_INVALID_HANDLE);
1336          if(pintern->Pointer)
1337             if(!HeapFree(GetProcessHeap(), 0, 
1338                          (char *)(pintern->Pointer)-sizeof(HGLOBAL)))
1339                hreturned=hmem;
1340          if(!HeapFree(GetProcessHeap(), 0, pintern)) 
1341             hreturned=hmem;
1342       }      
1343       /* HeapUnlock(GetProcessHeap()); */
1344    }
1345    return hreturned;
1346 }
1347
1348
1349 /***********************************************************************
1350  *           GlobalSize32   (KERNEL32.329)
1351  * RETURNS
1352  *      Size in bytes of the global memory object
1353  *      0: Failure
1354  */
1355 DWORD WINAPI GlobalSize(
1356              HGLOBAL hmem /* [in] Handle of global memory object */
1357 ) {
1358    DWORD                retval;
1359    PGLOBAL32_INTERN     pintern;
1360
1361    if(ISPOINTER(hmem)) 
1362    {
1363       retval=HeapSize(GetProcessHeap(), 0,  (LPVOID) hmem);
1364    }
1365    else
1366    {
1367       /* HeapLock(GetProcessHeap()); */
1368       pintern=HANDLE_TO_INTERN(hmem);
1369       
1370       if(pintern->Magic==MAGIC_GLOBAL_USED)
1371       {
1372         if (!pintern->Pointer) /* handle case of GlobalAlloc( ??,0) */
1373             return 0;
1374          retval=HeapSize(GetProcessHeap(), 0, 
1375                          (char *)(pintern->Pointer)-sizeof(HGLOBAL))-4;
1376       }
1377       else
1378       {
1379          WARN(global, "invalid handle\n");
1380          retval=0;
1381       }
1382       /* HeapUnlock(GetProcessHeap()); */
1383    }
1384    /* HeapSize returns 0xffffffff on failure */
1385    if (retval == 0xffffffff) retval = 0;
1386    return retval;
1387 }
1388
1389
1390 /***********************************************************************
1391  *           GlobalWire32   (KERNEL32.333)
1392  */
1393 LPVOID WINAPI GlobalWire(HGLOBAL hmem)
1394 {
1395    return GlobalLock( hmem );
1396 }
1397
1398
1399 /***********************************************************************
1400  *           GlobalUnWire32   (KERNEL32.330)
1401  */
1402 BOOL WINAPI GlobalUnWire(HGLOBAL hmem)
1403 {
1404    return GlobalUnlock( hmem);
1405 }
1406
1407
1408 /***********************************************************************
1409  *           GlobalFix32   (KERNEL32.320)
1410  */
1411 VOID WINAPI GlobalFix(HGLOBAL hmem)
1412 {
1413     GlobalLock( hmem );
1414 }
1415
1416
1417 /***********************************************************************
1418  *           GlobalUnfix32   (KERNEL32.331)
1419  */
1420 VOID WINAPI GlobalUnfix(HGLOBAL hmem)
1421 {
1422    GlobalUnlock( hmem);
1423 }
1424
1425
1426 /***********************************************************************
1427  *           GlobalFlags32   (KERNEL32.321)
1428  * Returns information about the specified global memory object
1429  *
1430  * NOTES
1431  *      Should this return GMEM_INVALID_HANDLE on invalid handle?
1432  *
1433  * RETURNS
1434  *      Value specifying allocation flags and lock count
1435  *      GMEM_INVALID_HANDLE: Failure
1436  */
1437 UINT WINAPI GlobalFlags(
1438               HGLOBAL hmem /* [in] Handle to global memory object */
1439 ) {
1440    DWORD                retval;
1441    PGLOBAL32_INTERN     pintern;
1442    
1443    if(ISPOINTER(hmem))
1444    {
1445       retval=0;
1446    }
1447    else
1448    {
1449       /* HeapLock(GetProcessHeap()); */
1450       pintern=HANDLE_TO_INTERN(hmem);
1451       if(pintern->Magic==MAGIC_GLOBAL_USED)
1452       {               
1453          retval=pintern->LockCount + (pintern->Flags<<8);
1454          if(pintern->Pointer==0)
1455             retval|= GMEM_DISCARDED;
1456       }
1457       else
1458       {
1459          WARN(global,"Invalid handle: %04x", hmem);
1460          retval=0;
1461       }
1462       /* HeapUnlock(GetProcessHeap()); */
1463    }
1464    return retval;
1465 }
1466
1467
1468 /***********************************************************************
1469  *           GlobalCompact32   (KERNEL32.316)
1470  */
1471 DWORD WINAPI GlobalCompact( DWORD minfree )
1472 {
1473     return 0;  /* GlobalCompact does nothing in Win32 */
1474 }
1475
1476
1477 /***********************************************************************
1478  *           GlobalMemoryStatus   (KERNEL32.327)
1479  * RETURNS
1480  *      None
1481  */
1482 VOID WINAPI GlobalMemoryStatus(
1483             LPMEMORYSTATUS lpmem
1484 ) {
1485 #ifdef linux
1486     FILE *f = fopen( "/proc/meminfo", "r" );
1487     if (f)
1488     {
1489         char buffer[256];
1490         int total, used, free, shared, buffers, cached;
1491
1492         lpmem->dwLength = sizeof(MEMORYSTATUS);
1493         lpmem->dwTotalPhys = lpmem->dwAvailPhys = 0;
1494         lpmem->dwTotalPageFile = lpmem->dwAvailPageFile = 0;
1495         while (fgets( buffer, sizeof(buffer), f ))
1496         {
1497             /* old style /proc/meminfo ... */
1498             if (sscanf( buffer, "Mem: %d %d %d %d %d %d", &total, &used, &free, &shared, &buffers, &cached ))
1499             {
1500                 lpmem->dwTotalPhys += total;
1501                 lpmem->dwAvailPhys += free + buffers + cached;
1502             }
1503             if (sscanf( buffer, "Swap: %d %d %d", &total, &used, &free ))
1504             {
1505                 lpmem->dwTotalPageFile += total;
1506                 lpmem->dwAvailPageFile += free;
1507             }
1508
1509             /* new style /proc/meminfo ... */
1510             if (sscanf(buffer, "MemTotal: %d", &total))
1511                 lpmem->dwTotalPhys = total*1024;
1512             if (sscanf(buffer, "MemFree: %d", &free))
1513                 lpmem->dwAvailPhys = free*1024;
1514             if (sscanf(buffer, "SwapTotal: %d", &total))
1515                 lpmem->dwTotalPageFile = total*1024;
1516             if (sscanf(buffer, "SwapFree: %d", &free))
1517                 lpmem->dwAvailPageFile = free*1024;
1518             if (sscanf(buffer, "Buffers: %d", &buffers))
1519                 lpmem->dwAvailPhys += buffers*1024;
1520             if (sscanf(buffer, "Cached: %d", &cached))
1521                 lpmem->dwAvailPhys += cached*1024;
1522         }
1523         fclose( f );
1524
1525         if (lpmem->dwTotalPhys)
1526         {
1527             lpmem->dwTotalVirtual = lpmem->dwTotalPhys+lpmem->dwTotalPageFile;
1528             lpmem->dwAvailVirtual = lpmem->dwAvailPhys+lpmem->dwAvailPageFile;
1529             lpmem->dwMemoryLoad = (lpmem->dwTotalVirtual-lpmem->dwAvailVirtual)
1530                                       / (lpmem->dwTotalVirtual / 100);
1531             return;
1532         }
1533     }
1534 #endif
1535     /* FIXME: should do something for other systems */
1536     lpmem->dwMemoryLoad    = 0;
1537     lpmem->dwTotalPhys     = 16*1024*1024;
1538     lpmem->dwAvailPhys     = 16*1024*1024;
1539     lpmem->dwTotalPageFile = 16*1024*1024;
1540     lpmem->dwAvailPageFile = 16*1024*1024;
1541     lpmem->dwTotalVirtual  = 32*1024*1024;
1542     lpmem->dwAvailVirtual  = 32*1024*1024;
1543 }
1544
1545
1546 /**********************************************************************
1547  *           WOWGlobalAllocLock (KERNEL32.62)
1548  *
1549  * Combined GlobalAlloc and GlobalLock.
1550  */
1551 SEGPTR WINAPI WOWGlobalAllocLock16(DWORD flags,DWORD cb,HGLOBAL16 *hmem)
1552 {
1553     HGLOBAL16 xhmem;
1554     xhmem = GlobalAlloc16(flags,cb);
1555     if (hmem) *hmem = xhmem;
1556     return WIN16_GlobalLock16(xhmem);
1557 }
1558
1559
1560 /**********************************************************************
1561  *           WOWGlobalUnlockFree (KERNEL32.64)
1562  *
1563  * Combined GlobalUnlock and GlobalFree.
1564  */
1565 WORD WINAPI WOWGlobalUnlockFree16(DWORD vpmem) {
1566     if (!GlobalUnlock16(HIWORD(vpmem)))
1567         return 0;
1568     return GlobalFree16(HIWORD(vpmem));
1569 }