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