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