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