winedbg: Fix the way array derefs are done.
[wine] / dlls / kernel32 / dosmem.c
1 /*
2  * DOS memory emulation
3  *
4  * Copyright 1995 Alexandre Julliard
5  * Copyright 1996 Marcus Meissner
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <signal.h>
26 #include <stdarg.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <sys/types.h>
30 #ifdef HAVE_SYS_MMAN_H
31 # include <sys/mman.h>
32 #endif
33
34 #include "windef.h"
35 #include "winbase.h"
36 #include "excpt.h"
37 #include "winternl.h"
38 #include "wine/winbase16.h"
39
40 #include "kernel_private.h"
41 #include "toolhelp.h"
42 #include "wine/debug.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(dosmem);
45 WINE_DECLARE_DEBUG_CHANNEL(selector);
46
47 WORD DOSMEM_0000H;        /* segment at 0:0 */
48 WORD DOSMEM_BiosDataSeg;  /* BIOS data segment at 0x40:0 */
49 WORD DOSMEM_BiosSysSeg;   /* BIOS ROM segment at 0xf000:0 */
50
51 /* DOS memory highest address (including HMA) */
52 #define DOSMEM_SIZE             0x110000
53 #define DOSMEM_64KB             0x10000
54
55 /* when looking at DOS and real mode memory, we activate in three different
56  * modes, depending the situation.
57  * 1/ By default (protected mode), the first MB of memory (actually 0x110000,
58  *    when you also look at the HMA part) is always reserved, whatever you do.
59  *    We allocated some PM selectors to this memory, even if this area is not
60  *    committed at startup
61  * 2/ if a program tries to use the memory through the selectors, we actually
62  *    commit this memory, made of: BIOS segment, but also some system 
63  *    information, usually low in memory that we map for the circumstance also
64  *    in the BIOS segment, so that we keep the low memory protected (for NULL
65  *    pointer deref catching for example). In this case, we're still in PM
66  *    mode, accessing part of the "physical" real mode memory. In fact, we don't
67  *    map all the first meg, we keep 64k uncommitted to still catch NULL 
68  *    pointers dereference
69  * 3/ if the process enters the real mode, then we (also) commit the full first
70  *    MB of memory (and also initialize the DOS structures in it).
71  */
72
73 /* DOS memory base (linear in process address space) */
74 static char *DOSMEM_dosmem;
75 /* number of bytes protected from _dosmem. 0 when DOS memory is initialized, 
76  * 64k otherwise to trap NULL pointers deref */
77 static DWORD DOSMEM_protect;
78
79 static LONG WINAPI dosmem_handler(EXCEPTION_POINTERS* except);
80
81 struct winedos_exports winedos;
82
83 BOOL load_winedos(void)
84 {
85     static HANDLE       hRunOnce /* = 0 */;
86     static HMODULE      hWineDos /* = 0 */;
87
88     /* FIXME: this isn't 100% thread safe, as we won't catch access to 1MB while
89      * loading winedos (and may return uninitialized valued)
90      */
91     if (hWineDos) goto done;
92     if (hRunOnce == 0)
93     {
94         HANDLE hEvent = CreateEventW( NULL, TRUE, FALSE, NULL );
95         if (InterlockedCompareExchangePointer( &hRunOnce, hEvent, 0 ) == 0)
96         {
97             HMODULE hModule;
98
99             /* ok, we're the winning thread */
100             if (!VirtualProtect( DOSMEM_dosmem + DOSMEM_protect,
101                                  DOSMEM_SIZE - DOSMEM_protect,
102                                  PAGE_READWRITE, NULL ) ||
103                 !(hModule = LoadLibraryA( "winedos.dll" )))
104             {
105                 ERR("Could not load winedos.dll, DOS subsystem unavailable\n");
106                 hModule = (HMODULE)1; /* not to try to load it again */
107             }
108             else
109             {
110 #define GET_ADDR(func)  winedos.func = (void *)GetProcAddress( hModule, #func );
111                 GET_ADDR(AllocDosBlock);
112                 GET_ADDR(FreeDosBlock);
113                 GET_ADDR(ResizeDosBlock);
114                 GET_ADDR(inport);
115                 GET_ADDR(outport);
116                 GET_ADDR(EmulateInterruptPM);
117                 GET_ADDR(CallBuiltinHandler);
118                 GET_ADDR(BiosTick);
119 #undef GET_ADDR
120             }
121             RtlRemoveVectoredExceptionHandler( dosmem_handler );
122             hWineDos = hModule;
123             SetEvent( hRunOnce );
124             goto done;
125         }
126         /* someone beat us here... */
127         CloseHandle( hEvent );
128     }
129
130     /* and wait for the winner to have finished */
131     WaitForSingleObject( hRunOnce, INFINITE );
132  done:
133     return (hWineDos != (HMODULE)1);
134 }
135
136 /******************************************************************
137  *              dosmem_handler
138  *
139  * Handler to catch access to our 1MB address space reserved for real memory
140  */
141 static LONG WINAPI dosmem_handler(EXCEPTION_POINTERS* except)
142 {
143     if (except->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION)
144     {
145         char *addr = (char *)except->ExceptionRecord->ExceptionInformation[1];
146         if (addr >= DOSMEM_dosmem + DOSMEM_protect && addr < DOSMEM_dosmem + DOSMEM_SIZE)
147         {
148             if (load_winedos()) return EXCEPTION_CONTINUE_EXECUTION;
149         }
150     }
151     return EXCEPTION_CONTINUE_SEARCH;
152 }
153
154 /***********************************************************************
155  *           DOSMEM_Init
156  *
157  * Create the dos memory segments, and store them into the KERNEL
158  * exported values.
159  */
160 BOOL DOSMEM_Init(void)
161 {
162     char *sysmem;
163     void *addr = (void *)1;
164     SIZE_T size = DOSMEM_SIZE - 1;
165
166     if (NtAllocateVirtualMemory( GetCurrentProcess(), &addr, 0, &size,
167                                  MEM_RESERVE | MEM_COMMIT, PAGE_NOACCESS ))
168     {
169         ERR( "Cannot allocate DOS memory\n" );
170         ExitProcess(1);
171     }
172
173     if (addr <= (void *)DOSMEM_64KB)
174     {
175         DOSMEM_dosmem = 0;
176         DOSMEM_protect = DOSMEM_64KB;
177         sysmem = (char *)0xf0000;  /* store sysmem in high addresses for now */
178     }
179     else
180     {
181         WARN( "First megabyte not available for DOS address space.\n" );
182         DOSMEM_dosmem = addr;
183         DOSMEM_protect = 0;
184         sysmem = DOSMEM_dosmem;
185     }
186
187     RtlAddVectoredExceptionHandler(FALSE, dosmem_handler);
188     DOSMEM_0000H = GLOBAL_CreateBlock( GMEM_FIXED, sysmem,
189                                        DOSMEM_64KB, 0, WINE_LDT_FLAGS_DATA );
190     DOSMEM_BiosDataSeg = GLOBAL_CreateBlock( GMEM_FIXED, sysmem + 0x400,
191                                              0x100, 0, WINE_LDT_FLAGS_DATA );
192     DOSMEM_BiosSysSeg = GLOBAL_CreateBlock( GMEM_FIXED, DOSMEM_dosmem + 0xf0000,
193                                             DOSMEM_64KB, 0, WINE_LDT_FLAGS_DATA );
194
195     return TRUE;
196 }
197
198 /***********************************************************************
199  *           DOSMEM_MapLinearToDos
200  *
201  * Linear address to the DOS address space.
202  */
203 UINT DOSMEM_MapLinearToDos(LPVOID ptr)
204 {
205     if (((char*)ptr >= DOSMEM_dosmem) &&
206         ((char*)ptr < DOSMEM_dosmem + DOSMEM_SIZE))
207           return (char *)ptr - DOSMEM_dosmem;
208     return (UINT)ptr;
209 }
210
211
212 /***********************************************************************
213  *           DOSMEM_MapDosToLinear
214  *
215  * DOS linear address to the linear address space.
216  */
217 LPVOID DOSMEM_MapDosToLinear(UINT ptr)
218 {
219     if (ptr < DOSMEM_SIZE) return DOSMEM_dosmem + ptr;
220     return (LPVOID)ptr;
221 }
222
223
224 /***********************************************************************
225  *           DOSMEM_MapRealToLinear
226  *
227  * Real mode DOS address into a linear pointer
228  */
229 LPVOID DOSMEM_MapRealToLinear(DWORD x)
230 {
231    LPVOID       lin;
232
233    lin = DOSMEM_dosmem + HIWORD(x) * 16 + LOWORD(x);
234    TRACE_(selector)("(0x%08x) returns %p.\n", x, lin );
235    return lin;
236 }