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