Add implementation for RtlQueryRegistryValues, RtlCheckRegistryKey and
[wine] / dlls / kernel / global16.c
1 /*
2  * Global heap functions
3  *
4  * Copyright 1995 Alexandre Julliard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20 /* 0xffff sometimes seems to mean: CURRENT_DS */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <sys/types.h>
26 #include <stdlib.h>
27 #include <time.h>
28 #include <stdio.h>
29 #ifdef HAVE_UNISTD_H
30 # include <unistd.h>
31 #endif
32 #include <string.h>
33 #ifdef HAVE_SYS_PARAM_H
34 #include <sys/param.h>
35 #endif
36 #ifdef HAVE_SYS_SYSCTL_H
37 #include <sys/sysctl.h>
38 #endif
39
40 #include "wine/winbase16.h"
41 #include "ntstatus.h"
42 #include "toolhelp.h"
43 #include "miscemu.h"
44 #include "stackframe.h"
45 #include "kernel_private.h"
46 #include "wine/debug.h"
47 #include "winerror.h"
48
49 WINE_DEFAULT_DEBUG_CHANNEL(global);
50
51   /* Global arena block */
52 typedef struct
53 {
54     DWORD     base;          /* Base address (0 if discarded) */
55     DWORD     size;          /* Size in bytes (0 indicates a free block) */
56     HGLOBAL16 handle;        /* Handle for this block */
57     HGLOBAL16 hOwner;        /* Owner of this block */
58     BYTE      lockCount;     /* Count of GlobalFix() calls */
59     BYTE      pageLockCount; /* Count of GlobalPageLock() calls */
60     BYTE      flags;         /* Allocation flags */
61     BYTE      selCount;      /* Number of selectors allocated for this block */
62 } GLOBALARENA;
63
64   /* Flags definitions */
65 #define GA_MOVEABLE     0x02  /* same as GMEM_MOVEABLE */
66 #define GA_DGROUP       0x04
67 #define GA_DISCARDABLE  0x08
68 #define GA_IPCSHARE     0x10  /* same as GMEM_DDESHARE */
69 #define GA_DOSMEM       0x20
70
71 /* Arena array (FIXME) */
72 static GLOBALARENA *pGlobalArena;
73 static int globalArenaSize;
74
75 #define GLOBAL_MAX_ALLOC_SIZE 0x00ff0000  /* Largest allocation is 16M - 64K */
76
77 #define VALID_HANDLE(handle) (((handle)>>__AHSHIFT)<globalArenaSize)
78 #define GET_ARENA_PTR(handle)  (pGlobalArena + ((handle) >> __AHSHIFT))
79
80
81 /***********************************************************************
82  *           GLOBAL_GetArena
83  *
84  * Return the arena for a given selector, growing the arena array if needed.
85  */
86 static GLOBALARENA *GLOBAL_GetArena( WORD sel, WORD selcount )
87 {
88     if (((sel >> __AHSHIFT) + selcount) > globalArenaSize)
89     {
90         int newsize = ((sel >> __AHSHIFT) + selcount + 0xff) & ~0xff;
91         GLOBALARENA *pNewArena = realloc( pGlobalArena,
92                                           newsize * sizeof(GLOBALARENA) );
93         if (!pNewArena) return 0;
94         pGlobalArena = pNewArena;
95         memset( pGlobalArena + globalArenaSize, 0,
96                 (newsize - globalArenaSize) * sizeof(GLOBALARENA) );
97         globalArenaSize = newsize;
98     }
99     return pGlobalArena + (sel >> __AHSHIFT);
100 }
101
102 void debug_handles(void)
103 {
104     int printed=0;
105     int i;
106     for (i = globalArenaSize-1 ; i>=0 ; i--) {
107         if (pGlobalArena[i].size!=0 && (pGlobalArena[i].handle & 0x8000)){
108             printed=1;
109             DPRINTF("0x%08x, ",pGlobalArena[i].handle);
110         }
111     }
112     if (printed)
113         DPRINTF("\n");
114 }
115
116
117 /***********************************************************************
118  *           GLOBAL_CreateBlock
119  *
120  * Create a global heap block for a fixed range of linear memory.
121  */
122 HGLOBAL16 GLOBAL_CreateBlock( WORD flags, const void *ptr, DWORD size,
123                               HGLOBAL16 hOwner, unsigned char selflags )
124 {
125     WORD sel, selcount;
126     GLOBALARENA *pArena;
127
128       /* Allocate the selector(s) */
129
130     sel = SELECTOR_AllocBlock( ptr, size, selflags );
131     if (!sel) return 0;
132     selcount = (size + 0xffff) / 0x10000;
133
134     if (!(pArena = GLOBAL_GetArena( sel, selcount )))
135     {
136         SELECTOR_FreeBlock( sel );
137         return 0;
138     }
139
140       /* Fill the arena block */
141
142     pArena->base = (DWORD)ptr;
143     pArena->size = GetSelectorLimit16(sel) + 1;
144     pArena->handle = (flags & GMEM_MOVEABLE) ? sel - 1 : sel;
145     pArena->hOwner = hOwner;
146     pArena->lockCount = 0;
147     pArena->pageLockCount = 0;
148     pArena->flags = flags & GA_MOVEABLE;
149     if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
150     if (flags & GMEM_DDESHARE) pArena->flags |= GA_IPCSHARE;
151     if (!(selflags & (WINE_LDT_FLAGS_CODE^WINE_LDT_FLAGS_DATA))) pArena->flags |= GA_DGROUP;
152     pArena->selCount = selcount;
153     if (selcount > 1)  /* clear the next arena blocks */
154         memset( pArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
155
156     return pArena->handle;
157 }
158
159
160 /***********************************************************************
161  *           GLOBAL_FreeBlock
162  *
163  * Free a block allocated by GLOBAL_CreateBlock, without touching
164  * the associated linear memory range.
165  */
166 BOOL16 GLOBAL_FreeBlock( HGLOBAL16 handle )
167 {
168     WORD sel;
169     GLOBALARENA *pArena;
170
171     if (!handle) return TRUE;
172     sel = GlobalHandleToSel16( handle );
173     if (!VALID_HANDLE(sel)) return FALSE;
174     pArena = GET_ARENA_PTR(sel);
175     SELECTOR_FreeBlock( sel );
176     memset( pArena, 0, sizeof(GLOBALARENA) );
177     return TRUE;
178 }
179
180 /***********************************************************************
181  *           GLOBAL_MoveBlock
182  */
183 BOOL16 GLOBAL_MoveBlock( HGLOBAL16 handle, const void *ptr, DWORD size )
184 {
185     WORD sel;
186     GLOBALARENA *pArena;
187
188     if (!handle) return TRUE;
189     sel = GlobalHandleToSel16( handle );
190     if (!VALID_HANDLE(sel)) return FALSE;
191     pArena = GET_ARENA_PTR(sel);
192     if (pArena->selCount != 1)
193         return FALSE;
194
195     pArena->base = (DWORD)ptr;
196     pArena->size = size;
197     SELECTOR_ReallocBlock( sel, ptr, size );
198     return TRUE;
199 }
200
201 /***********************************************************************
202  *           GLOBAL_Alloc
203  *
204  * Implementation of GlobalAlloc16()
205  */
206 HGLOBAL16 GLOBAL_Alloc( UINT16 flags, DWORD size, HGLOBAL16 hOwner, unsigned char selflags )
207 {
208     void *ptr;
209     HGLOBAL16 handle;
210
211     TRACE("%ld flags=%04x\n", size, flags );
212
213     /* If size is 0, create a discarded block */
214
215     if (size == 0) return GLOBAL_CreateBlock( flags, NULL, 1, hOwner, selflags );
216
217     /* Fixup the size */
218
219     if (size >= GLOBAL_MAX_ALLOC_SIZE - 0x1f) return 0;
220     size = (size + 0x1f) & ~0x1f;
221
222     /* Allocate the linear memory */
223     ptr = HeapAlloc( GetProcessHeap(), 0, size );
224       /* FIXME: free discardable blocks and try again? */
225     if (!ptr) return 0;
226
227       /* Allocate the selector(s) */
228
229     handle = GLOBAL_CreateBlock( flags, ptr, size, hOwner, selflags );
230     if (!handle)
231     {
232         HeapFree( GetProcessHeap(), 0, ptr );
233         return 0;
234     }
235
236     if (flags & GMEM_ZEROINIT) memset( ptr, 0, size );
237     return handle;
238 }
239
240 /***********************************************************************
241  *           GlobalAlloc     (KERNEL.15)
242  *           GlobalAlloc16   (KERNEL32.24)
243  * RETURNS
244  *      Handle: Success
245  *      NULL: Failure
246  */
247 HGLOBAL16 WINAPI GlobalAlloc16(
248                  UINT16 flags, /* [in] Object allocation attributes */
249                  DWORD size    /* [in] Number of bytes to allocate */
250 ) {
251     HANDLE16 owner = GetCurrentPDB16();
252
253     if (flags & GMEM_DDESHARE)
254         owner = GetExePtr(owner);  /* Make it a module handle */
255     return GLOBAL_Alloc( flags, size, owner, WINE_LDT_FLAGS_DATA );
256 }
257
258
259 /***********************************************************************
260  *           GlobalReAlloc     (KERNEL.16)
261  * RETURNS
262  *      Handle: Success
263  *      NULL: Failure
264  */
265 HGLOBAL16 WINAPI GlobalReAlloc16(
266                  HGLOBAL16 handle, /* [in] Handle of global memory object */
267                  DWORD size,       /* [in] New size of block */
268                  UINT16 flags      /* [in] How to reallocate object */
269 ) {
270     WORD selcount;
271     DWORD oldsize;
272     void *ptr, *newptr;
273     GLOBALARENA *pArena, *pNewArena;
274     WORD sel = GlobalHandleToSel16( handle );
275
276     TRACE("%04x %ld flags=%04x\n",
277                     handle, size, flags );
278     if (!handle) return 0;
279
280     if (!VALID_HANDLE(handle))
281     {
282         WARN("Invalid handle 0x%04x!\n", handle);
283         return 0;
284     }
285     pArena = GET_ARENA_PTR( handle );
286
287       /* Discard the block if requested */
288
289     if ((size == 0) && (flags & GMEM_MOVEABLE) && !(flags & GMEM_MODIFY))
290     {
291         if (!(pArena->flags & GA_MOVEABLE) ||
292             !(pArena->flags & GA_DISCARDABLE) ||
293             (pArena->lockCount > 0) || (pArena->pageLockCount > 0)) return 0;
294         if (pArena->flags & GA_DOSMEM)
295             DOSMEM_FreeBlock( (void *)pArena->base );
296         else
297             HeapFree( GetProcessHeap(), 0, (void *)pArena->base );
298         pArena->base = 0;
299
300         /* Note: we rely on the fact that SELECTOR_ReallocBlock won't
301          * change the selector if we are shrinking the block.
302          * FIXME: shouldn't we keep selectors until the block is deleted?
303          */
304         SELECTOR_ReallocBlock( sel, 0, 1 );
305         return handle;
306     }
307
308       /* Fixup the size */
309
310     if (size > GLOBAL_MAX_ALLOC_SIZE - 0x20) return 0;
311     if (size == 0) size = 0x20;
312     else size = (size + 0x1f) & ~0x1f;
313
314       /* Change the flags */
315
316     if (flags & GMEM_MODIFY)
317     {
318           /* Change the flags, leaving GA_DGROUP alone */
319         pArena->flags = (pArena->flags & GA_DGROUP) | (flags & GA_MOVEABLE);
320         if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
321         return handle;
322     }
323
324       /* Reallocate the linear memory */
325
326     ptr = (void *)pArena->base;
327     oldsize = pArena->size;
328     TRACE("oldbase %p oldsize %08lx newsize %08lx\n", ptr,oldsize,size);
329     if (ptr && (size == oldsize)) return handle;  /* Nothing to do */
330
331     if (pArena->flags & GA_DOSMEM)
332     {
333         if (DOSMEM_ResizeBlock(ptr, size, TRUE) == size) 
334             newptr = ptr;
335         else if(pArena->pageLockCount > 0)
336             newptr = 0;
337         else
338         {
339             newptr = DOSMEM_GetBlock( size, 0 );
340             if (newptr)
341             {
342                 memcpy( newptr, ptr, oldsize );
343                 DOSMEM_FreeBlock( ptr );
344             }
345         }
346     }
347     else
348     {
349         /*
350          * if more than one reader (e.g. some pointer has been 
351          * given out by GetVDMPointer32W16),
352          * only try to realloc in place
353          */
354
355         if (ptr)
356             newptr = HeapReAlloc( GetProcessHeap(),
357                 (pArena->pageLockCount > 0) ? HEAP_REALLOC_IN_PLACE_ONLY : 0, 
358                               ptr, size );
359         else
360             newptr = HeapAlloc( GetProcessHeap(),
361                 (pArena->pageLockCount > 0) ? HEAP_REALLOC_IN_PLACE_ONLY : 0, 
362                               size );
363
364     }
365
366     if (!newptr)
367     {
368         FIXME("Realloc failed lock %d\n",pArena->pageLockCount);
369         if (pArena->pageLockCount <1)
370         {
371             if (pArena->flags & GA_DOSMEM)
372                 DOSMEM_FreeBlock( (void *)pArena->base );
373             else
374                 HeapFree( GetProcessHeap(), 0, ptr );
375             SELECTOR_FreeBlock( sel );
376             memset( pArena, 0, sizeof(GLOBALARENA) );
377         }
378         return 0;
379     }
380     ptr = newptr;
381
382       /* Reallocate the selector(s) */
383
384     sel = SELECTOR_ReallocBlock( sel, ptr, size );
385     if (!sel)
386     {
387         if (pArena->flags & GA_DOSMEM)
388             DOSMEM_FreeBlock( (void *)pArena->base );
389         else
390             HeapFree( GetProcessHeap(), 0, ptr );
391         memset( pArena, 0, sizeof(GLOBALARENA) );
392         return 0;
393     }
394     selcount = (size + 0xffff) / 0x10000;
395
396     if (!(pNewArena = GLOBAL_GetArena( sel, selcount )))
397     {        
398         if (pArena->flags & GA_DOSMEM)
399             DOSMEM_FreeBlock( (void *)pArena->base );
400         else
401             HeapFree( GetProcessHeap(), 0, ptr );
402         SELECTOR_FreeBlock( sel );
403         return 0;
404     }
405
406       /* Fill the new arena block
407          As we may have used HEAP_REALLOC_IN_PLACE_ONLY, areas may overlap*/
408
409     if (pNewArena != pArena) memmove( pNewArena, pArena, sizeof(GLOBALARENA) );
410     pNewArena->base = (DWORD)ptr;
411     pNewArena->size = GetSelectorLimit16(sel) + 1;
412     pNewArena->selCount = selcount;
413     pNewArena->handle = (pNewArena->flags & GA_MOVEABLE) ? sel - 1 : sel;
414
415     if (selcount > 1)  /* clear the next arena blocks */
416         memset( pNewArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
417
418     if ((oldsize < size) && (flags & GMEM_ZEROINIT))
419         memset( (char *)ptr + oldsize, 0, size - oldsize );
420     return pNewArena->handle;
421 }
422
423
424 /***********************************************************************
425  *           GlobalFree     (KERNEL.17)
426  *           GlobalFree16   (KERNEL32.31)
427  * RETURNS
428  *      NULL: Success
429  *      Handle: Failure
430  */
431 HGLOBAL16 WINAPI GlobalFree16(
432                  HGLOBAL16 handle /* [in] Handle of global memory object */
433 ) {
434     void *ptr;
435
436     if (!VALID_HANDLE(handle))
437     {
438         WARN("Invalid handle 0x%04x passed to GlobalFree16!\n",handle);
439         return 0;
440     }
441     ptr = (void *)GET_ARENA_PTR(handle)->base;
442
443     TRACE("%04x\n", handle );
444     if (!GLOBAL_FreeBlock( handle )) return handle;  /* failed */
445     HeapFree( GetProcessHeap(), 0, ptr );
446     return 0;
447 }
448
449
450 /**********************************************************************
451  *           K32WOWGlobalLock16         (KERNEL32.60)
452  */
453 SEGPTR WINAPI K32WOWGlobalLock16( HGLOBAL16 handle )
454 {
455     WORD sel = GlobalHandleToSel16( handle );
456     TRACE("(%04x) -> %08lx\n", handle, MAKELONG( 0, sel ) );
457
458     if (handle)
459     {
460         if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
461
462         if (!VALID_HANDLE(handle)) {
463             WARN("Invalid handle 0x%04x passed to WIN16_GlobalLock16!\n",handle);
464             sel = 0;
465         }
466         else if (!GET_ARENA_PTR(handle)->base)
467             sel = 0;
468         else
469             GET_ARENA_PTR(handle)->lockCount++;
470     }
471
472     return MAKESEGPTR( sel, 0 );
473
474 }
475
476
477 /***********************************************************************
478  *           GlobalLock   (KERNEL.18)
479  *
480  * This is the GlobalLock16() function used by 16-bit code.
481  */
482 SEGPTR WINAPI WIN16_GlobalLock16( HGLOBAL16 handle )
483 {
484     SEGPTR ret = K32WOWGlobalLock16( handle );
485     CURRENT_STACK16->ecx = SELECTOROF(ret);  /* selector must be returned in CX as well */
486     return ret;
487 }
488
489
490 /***********************************************************************
491  *           GlobalLock16   (KERNEL32.25)
492  *
493  * This is the GlobalLock16() function used by 32-bit code.
494  *
495  * RETURNS
496  *      Pointer to first byte of memory block
497  *      NULL: Failure
498  */
499 LPVOID WINAPI GlobalLock16(
500               HGLOBAL16 handle /* [in] Handle of global memory object */
501 ) {
502     if (!handle) return 0;
503     if (!VALID_HANDLE(handle))
504         return 0;
505     GET_ARENA_PTR(handle)->lockCount++;
506     return (LPVOID)GET_ARENA_PTR(handle)->base;
507 }
508
509
510 /***********************************************************************
511  *           GlobalUnlock     (KERNEL.19)
512  *           GlobalUnlock16   (KERNEL32.26)
513  * NOTES
514  *      Should the return values be cast to booleans?
515  *
516  * RETURNS
517  *      TRUE: Object is still locked
518  *      FALSE: Object is unlocked
519  */
520 BOOL16 WINAPI GlobalUnlock16(
521               HGLOBAL16 handle /* [in] Handle of global memory object */
522 ) {
523     GLOBALARENA *pArena = GET_ARENA_PTR(handle);
524     if (!VALID_HANDLE(handle)) {
525         WARN("Invalid handle 0x%04x passed to GlobalUnlock16!\n",handle);
526         return 0;
527     }
528     TRACE("%04x\n", handle );
529     if (pArena->lockCount) pArena->lockCount--;
530     return pArena->lockCount;
531 }
532
533 /***********************************************************************
534  *     GlobalChangeLockCount               (KERNEL.365)
535  *
536  * This is declared as a register function as it has to preserve
537  * *all* registers, even AX/DX !
538  *
539  */
540 void WINAPI GlobalChangeLockCount16( HGLOBAL16 handle, INT16 delta,
541                                      CONTEXT86 *context )
542 {
543     if ( delta == 1 )
544         GlobalLock16( handle );
545     else if ( delta == -1 )
546         GlobalUnlock16( handle );
547     else
548         ERR("(%04X, %d): strange delta value\n", handle, delta );
549 }
550
551 /***********************************************************************
552  *           GlobalSize     (KERNEL.20)
553  *           GlobalSize16   (KERNEL32.32)
554  * RETURNS
555  *      Size in bytes of object
556  *      0: Failure
557  */
558 DWORD WINAPI GlobalSize16(
559              HGLOBAL16 handle /* [in] Handle of global memory object */
560 ) {
561     TRACE("%04x\n", handle );
562     if (!handle) return 0;
563     if (!VALID_HANDLE(handle))
564         return 0;
565     return GET_ARENA_PTR(handle)->size;
566 }
567
568
569 /***********************************************************************
570  *           GlobalHandle   (KERNEL.21)
571  * NOTES
572  *      Why is GlobalHandleToSel used here with the sel as input?
573  *
574  * RETURNS
575  *      Handle: Success
576  *      NULL: Failure
577  */
578 DWORD WINAPI GlobalHandle16(
579              WORD sel /* [in] Address of global memory block */
580 ) {
581     TRACE("%04x\n", sel );
582     if (!VALID_HANDLE(sel)) {
583         WARN("Invalid handle 0x%04x passed to GlobalHandle16!\n",sel);
584         return 0;
585     }
586     return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel16(sel) );
587 }
588
589 /***********************************************************************
590  *           GlobalHandleNoRIP   (KERNEL.159)
591  */
592 DWORD WINAPI GlobalHandleNoRIP16( WORD sel )
593 {
594     int i;
595     for (i = globalArenaSize-1 ; i>=0 ; i--) {
596         if (pGlobalArena[i].size!=0 && pGlobalArena[i].handle == sel)
597                 return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel16(sel) );
598     }
599     return 0;
600 }
601
602
603 /***********************************************************************
604  *           GlobalFlags     (KERNEL.22)
605  *
606  * NOTES
607  *      Should this return GMEM_INVALID_HANDLE instead of 0 on invalid
608  *      handle?
609  *
610  * RETURNS
611  *      Value specifying flags and lock count
612  *      GMEM_INVALID_HANDLE: Invalid handle
613  */
614 UINT16 WINAPI GlobalFlags16(
615               HGLOBAL16 handle /* [in] Handle of global memory object */
616 ) {
617     GLOBALARENA *pArena;
618
619     TRACE("%04x\n", handle );
620     if (!VALID_HANDLE(handle)) {
621         WARN("Invalid handle 0x%04x passed to GlobalFlags16!\n",handle);
622         return 0;
623     }
624     pArena = GET_ARENA_PTR(handle);
625     return pArena->lockCount |
626            ((pArena->flags & GA_DISCARDABLE) ? GMEM_DISCARDABLE : 0) |
627            ((pArena->base == 0) ? GMEM_DISCARDED : 0);
628 }
629
630
631 /***********************************************************************
632  *           LockSegment   (KERNEL.23)
633  */
634 HGLOBAL16 WINAPI LockSegment16( HGLOBAL16 handle )
635 {
636     TRACE("%04x\n", handle );
637     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
638     if (!VALID_HANDLE(handle)) {
639         WARN("Invalid handle 0x%04x passed to LockSegment16!\n",handle);
640         return 0;
641     }
642     GET_ARENA_PTR(handle)->lockCount++;
643     return handle;
644 }
645
646
647 /***********************************************************************
648  *           UnlockSegment   (KERNEL.24)
649  */
650 void WINAPI UnlockSegment16( HGLOBAL16 handle )
651 {
652     TRACE("%04x\n", handle );
653     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
654     if (!VALID_HANDLE(handle)) {
655         WARN("Invalid handle 0x%04x passed to UnlockSegment16!\n",handle);
656         return;
657     }
658     GET_ARENA_PTR(handle)->lockCount--;
659     /* FIXME: this ought to return the lock count in CX (go figure...) */
660 }
661
662
663 /***********************************************************************
664  *           GlobalCompact   (KERNEL.25)
665  */
666 DWORD WINAPI GlobalCompact16( DWORD desired )
667 {
668     return GLOBAL_MAX_ALLOC_SIZE;
669 }
670
671
672 /***********************************************************************
673  *           GlobalFreeAll   (KERNEL.26)
674  */
675 void WINAPI GlobalFreeAll16( HGLOBAL16 owner )
676 {
677     int i;
678     GLOBALARENA *pArena;
679
680     pArena = pGlobalArena;
681     for (i = 0; i < globalArenaSize; i++, pArena++)
682     {
683         if ((pArena->size != 0) && (pArena->hOwner == owner))
684             GlobalFree16( pArena->handle );
685     }
686 }
687
688
689 /***********************************************************************
690  *           GlobalWire     (KERNEL.111)
691  *           GlobalWire16   (KERNEL32.29)
692  */
693 SEGPTR WINAPI GlobalWire16( HGLOBAL16 handle )
694 {
695     return WIN16_GlobalLock16( handle );
696 }
697
698
699 /***********************************************************************
700  *           GlobalUnWire     (KERNEL.112)
701  *           GlobalUnWire16   (KERNEL32.30)
702  */
703 BOOL16 WINAPI GlobalUnWire16( HGLOBAL16 handle )
704 {
705     return !GlobalUnlock16( handle );
706 }
707
708
709 /***********************************************************************
710  *           SetSwapAreaSize   (KERNEL.106)
711  */
712 LONG WINAPI SetSwapAreaSize16( WORD size )
713 {
714     FIXME("(%d) - stub!\n", size );
715     return MAKELONG( size, 0xffff );
716 }
717
718
719 /***********************************************************************
720  *           GlobalLRUOldest   (KERNEL.163)
721  */
722 HGLOBAL16 WINAPI GlobalLRUOldest16( HGLOBAL16 handle )
723 {
724     TRACE("%04x\n", handle );
725     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
726     return handle;
727 }
728
729
730 /***********************************************************************
731  *           GlobalLRUNewest   (KERNEL.164)
732  */
733 HGLOBAL16 WINAPI GlobalLRUNewest16( HGLOBAL16 handle )
734 {
735     TRACE("%04x\n", handle );
736     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
737     return handle;
738 }
739
740
741 /***********************************************************************
742  *           GetFreeSpace   (KERNEL.169)
743  */
744 DWORD WINAPI GetFreeSpace16( UINT16 wFlags )
745 {
746     MEMORYSTATUS ms;
747     GlobalMemoryStatus( &ms );
748     return ms.dwAvailVirtual;
749 }
750
751 /***********************************************************************
752  *           GlobalDOSAlloc   (KERNEL.184)
753  * RETURNS
754  *      Address (HW=Paragraph segment; LW=Selector)
755  */
756 DWORD WINAPI GlobalDOSAlloc16(
757              DWORD size /* [in] Number of bytes to be allocated */
758 ) {
759    UINT16    uParagraph;
760    LPVOID    lpBlock = DOSMEM_GetBlock( size, &uParagraph );
761
762    if( lpBlock )
763    {
764        HMODULE16 hModule = GetModuleHandle16("KERNEL");
765        WORD      wSelector;
766        GLOBALARENA *pArena;
767
768        wSelector = GLOBAL_CreateBlock(GMEM_FIXED, lpBlock, size, hModule, WINE_LDT_FLAGS_DATA );
769        pArena = GET_ARENA_PTR(wSelector);
770        pArena->flags |= GA_DOSMEM;
771        return MAKELONG(wSelector,uParagraph);
772    }
773    return 0;
774 }
775
776
777 /***********************************************************************
778  *           GlobalDOSFree      (KERNEL.185)
779  * RETURNS
780  *      NULL: Success
781  *      sel: Failure
782  */
783 WORD WINAPI GlobalDOSFree16(
784             WORD sel /* [in] Selector */
785 ) {
786    DWORD   block = GetSelectorBase(sel);
787
788    if( block && block < 0x100000 )
789    {
790        LPVOID lpBlock = DOSMEM_MapDosToLinear( block );
791        if( DOSMEM_FreeBlock( lpBlock ) )
792            GLOBAL_FreeBlock( sel );
793        sel = 0;
794    }
795    return sel;
796 }
797
798
799 /***********************************************************************
800  *           GlobalPageLock   (KERNEL.191)
801  *           GlobalSmartPageLock(KERNEL.230)
802  */
803 WORD WINAPI GlobalPageLock16( HGLOBAL16 handle )
804 {
805     TRACE("%04x\n", handle );
806     if (!VALID_HANDLE(handle)) {
807         WARN("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  *           GlobalSmartPageUnlock(KERNEL.231)
817  */
818 WORD WINAPI GlobalPageUnlock16( HGLOBAL16 handle )
819 {
820     TRACE("%04x\n", handle );
821     if (!VALID_HANDLE(handle)) {
822         WARN("Invalid handle 0x%04x passed to GlobalPageUnlock!\n",handle);
823         return 0;
824     }
825     return --(GET_ARENA_PTR(handle)->pageLockCount);
826 }
827
828
829 /***********************************************************************
830  *           GlobalFix     (KERNEL.197)
831  *           GlobalFix16   (KERNEL32.27)
832  */
833 WORD WINAPI GlobalFix16( HGLOBAL16 handle )
834 {
835     TRACE("%04x\n", handle );
836     if (!VALID_HANDLE(handle)) {
837         WARN("Invalid handle 0x%04x passed to GlobalFix16!\n",handle);
838         return 0;
839     }
840     GET_ARENA_PTR(handle)->lockCount++;
841
842     return GlobalHandleToSel16(handle);
843 }
844
845
846 /***********************************************************************
847  *           GlobalUnfix     (KERNEL.198)
848  *           GlobalUnfix16   (KERNEL32.28)
849  */
850 void WINAPI GlobalUnfix16( HGLOBAL16 handle )
851 {
852     TRACE("%04x\n", handle );
853     if (!VALID_HANDLE(handle)) {
854         WARN("Invalid handle 0x%04x passed to GlobalUnfix16!\n",handle);
855         return;
856     }
857     GET_ARENA_PTR(handle)->lockCount--;
858 }
859
860
861 /***********************************************************************
862  *           FarSetOwner   (KERNEL.403)
863  */
864 void WINAPI FarSetOwner16( HGLOBAL16 handle, HANDLE16 hOwner )
865 {
866     if (!VALID_HANDLE(handle)) {
867         WARN("Invalid handle 0x%04x passed to FarSetOwner!\n",handle);
868         return;
869     }
870     GET_ARENA_PTR(handle)->hOwner = hOwner;
871 }
872
873
874 /***********************************************************************
875  *           FarGetOwner   (KERNEL.404)
876  */
877 HANDLE16 WINAPI FarGetOwner16( HGLOBAL16 handle )
878 {
879     if (!VALID_HANDLE(handle)) {
880         WARN("Invalid handle 0x%04x passed to FarGetOwner!\n",handle);
881         return 0;
882     }
883     return GET_ARENA_PTR(handle)->hOwner;
884 }
885
886
887 /***********************************************************************
888  *           GlobalHandleToSel   (TOOLHELP.50)
889  */
890 WORD WINAPI GlobalHandleToSel16( HGLOBAL16 handle )
891 {
892     if (!handle) return 0;
893     if (!VALID_HANDLE(handle)) {
894         WARN("Invalid handle 0x%04x passed to GlobalHandleToSel!\n",handle);
895         return 0;
896     }
897     if (!(handle & 7))
898     {
899         WARN("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     FIXME("(%p, 0x%04x, 0x%04x), stub.\n", pGlobal, hModule, wSeg);
996     return FALSE;
997 }
998
999
1000 /***********************************************************************
1001  *           MemManInfo   (TOOLHELP.72)
1002  */
1003 BOOL16 WINAPI MemManInfo16( MEMMANINFO *info )
1004 {
1005     MEMORYSTATUS status;
1006
1007     /*
1008      * Not unsurprisingly although the documention says you
1009      * _must_ provide the size in the dwSize field, this function
1010      * (under Windows) always fills the structure and returns true.
1011      */
1012     GlobalMemoryStatus( &status );
1013     info->wPageSize            = getpagesize();
1014     info->dwLargestFreeBlock   = status.dwAvailVirtual;
1015     info->dwMaxPagesAvailable  = info->dwLargestFreeBlock / info->wPageSize;
1016     info->dwMaxPagesLockable   = info->dwMaxPagesAvailable;
1017     info->dwTotalLinearSpace   = status.dwTotalVirtual / info->wPageSize;
1018     info->dwTotalUnlockedPages = info->dwTotalLinearSpace;
1019     info->dwFreePages          = info->dwMaxPagesAvailable;
1020     info->dwTotalPages         = info->dwTotalLinearSpace;
1021     info->dwFreeLinearSpace    = info->dwMaxPagesAvailable;
1022     info->dwSwapFilePages      = status.dwTotalPageFile / info->wPageSize;
1023     return TRUE;
1024 }
1025
1026 /***********************************************************************
1027  *           GetFreeMemInfo   (KERNEL.316)
1028  */
1029 DWORD WINAPI GetFreeMemInfo16(void)
1030 {
1031     MEMMANINFO info;
1032     MemManInfo16( &info );
1033     return MAKELONG( info.dwTotalLinearSpace, info.dwMaxPagesAvailable );
1034 }
1035
1036 /***********************************************************************
1037  *           A20Proc   (KERNEL.165)
1038  *           A20_Proc  (SYSTEM.20)
1039  */
1040 void WINAPI A20Proc16( WORD unused )
1041 {
1042     /* this is also a NOP in Windows */
1043 }
1044
1045 /***********************************************************************
1046  *           LimitEMSPages   (KERNEL.156)
1047  */
1048 DWORD WINAPI LimitEMSPages16( DWORD unused )
1049 {
1050     return 0;
1051 }