1 /*
2 * VMM VxD implementation
3 *
4 * Copyright 1998 Marcus Meissner
5 * Copyright 1998 Ulrich Weigand
6 * Copyright 1998 Patrik Stridvall
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <stdarg.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winternl.h"
31 #include "wine/debug.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(vxd);
34
35 /*
36 * VMM VxDCall service names are (mostly) taken from Stan Mitchell's
37 * "Inside the Windows 95 File System"
38 */
39
40 #define N_VMM_SERVICE 41
41
42 static const char * const VMM_Service_Name[N_VMM_SERVICE] =
43 {
44 "PageReserve", /* 0x0000 */
45 "PageCommit", /* 0x0001 */
46 "PageDecommit", /* 0x0002 */
47 "PagerRegister", /* 0x0003 */
48 "PagerQuery", /* 0x0004 */
49 "HeapAllocate", /* 0x0005 */
50 "ContextCreate", /* 0x0006 */
51 "ContextDestroy", /* 0x0007 */
52 "PageAttach", /* 0x0008 */
53 "PageFlush", /* 0x0009 */
54 "PageFree", /* 0x000A */
55 "ContextSwitch", /* 0x000B */
56 "HeapReAllocate", /* 0x000C */
57 "PageModifyPermissions", /* 0x000D */
58 "PageQuery", /* 0x000E */
59 "GetCurrentContext", /* 0x000F */
60 "HeapFree", /* 0x0010 */
61 "RegOpenKey", /* 0x0011 */
62 "RegCreateKey", /* 0x0012 */
63 "RegCloseKey", /* 0x0013 */
64 "RegDeleteKey", /* 0x0014 */
65 "RegSetValue", /* 0x0015 */
66 "RegDeleteValue", /* 0x0016 */
67 "RegQueryValue", /* 0x0017 */
68 "RegEnumKey", /* 0x0018 */
69 "RegEnumValue", /* 0x0019 */
70 "RegQueryValueEx", /* 0x001A */
71 "RegSetValueEx", /* 0x001B */
72 "RegFlushKey", /* 0x001C */
73 "RegQueryInfoKey", /* 0x001D */
74 "GetDemandPageInfo", /* 0x001E */
75 "BlockOnID", /* 0x001F */
76 "SignalID", /* 0x0020 */
77 "RegLoadKey", /* 0x0021 */
78 "RegUnLoadKey", /* 0x0022 */
79 "RegSaveKey", /* 0x0023 */
80 "RegRemapPreDefKey", /* 0x0024 */
81 "PageChangePager", /* 0x0025 */
82 "RegQueryMultipleValues", /* 0x0026 */
83 "RegReplaceKey", /* 0x0027 */
84 "<KERNEL32.101>" /* 0x0028 -- What does this do??? */
85 };
86
87 /* PageReserve arena values */
88 #define PR_PRIVATE 0x80000400 /* anywhere in private arena */
89 #define PR_SHARED 0x80060000 /* anywhere in shared arena */
90 #define PR_SYSTEM 0x80080000 /* anywhere in system arena */
91
92 /* PageReserve flags */
93 #define PR_FIXED 0x00000008 /* don't move during PageReAllocate */
94 #define PR_4MEG 0x00000001 /* allocate on 4mb boundary */
95 #define PR_STATIC 0x00000010 /* see PageReserve documentation */
96
97 /* PageCommit default pager handle values */
98 #define PD_ZEROINIT 0x00000001 /* swappable zero-initialized pages */
99 #define PD_NOINIT 0x00000002 /* swappable uninitialized pages */
100 #define PD_FIXEDZERO 0x00000003 /* fixed zero-initialized pages */
101 #define PD_FIXED 0x00000004 /* fixed uninitialized pages */
102
103 /* PageCommit flags */
104 #define PC_FIXED 0x00000008 /* pages are permanently locked */
105 #define PC_LOCKED 0x00000080 /* pages are made present and locked */
106 #define PC_LOCKEDIFDP 0x00000100 /* pages are locked if swap via DOS */
107 #define PC_WRITABLE 0x00020000 /* make the pages writable */
108 #define PC_USER 0x00040000 /* make the pages ring 3 accessible */
109 #define PC_INCR 0x40000000 /* increment "pagerdata" each page */
110 #define PC_PRESENT 0x80000000 /* make pages initially present */
111 #define PC_STATIC 0x20000000 /* allow commit in PR_STATIC object */
112 #define PC_DIRTY 0x08000000 /* make pages initially dirty */
113 #define PC_CACHEDIS 0x00100000 /* Allocate uncached pages - new for WDM */
114 #define PC_CACHEWT 0x00080000 /* Allocate write through cache pages - new for WDM */
115 #define PC_PAGEFLUSH 0x00008000 /* Touch device mapped pages on alloc - new for WDM */
116
117 /* PageCommitContig additional flags */
118 #define PCC_ZEROINIT 0x00000001 /* zero-initialize new pages */
119 #define PCC_NOLIN 0x10000000 /* don't map to any linear address */
120
121
122 /* Pop a DWORD from the 32-bit stack */
123 static inline DWORD stack32_pop( CONTEXT86 *context )
124 {
125 DWORD ret = *(DWORD *)context->Esp;
126 context->Esp += sizeof(DWORD);
127 return ret;
128 }
129
130
131 /***********************************************************************
132 * VxDCall (VMM.VXD.@)
133 */
134 DWORD WINAPI VMM_VxDCall( DWORD service, CONTEXT86 *context )
135 {
136 static int warned;
137
138 switch ( LOWORD(service) )
139 {
140 case 0x0000: /* PageReserve */
141 {
142 LPVOID address;
143 LPVOID ret;
144 DWORD psize = getpagesize();
145 ULONG page = stack32_pop( context );
146 ULONG npages = stack32_pop( context );
147 ULONG flags = stack32_pop( context );
148
149 TRACE("PageReserve: page: %08x, npages: %08x, flags: %08x partial stub!\n",
150 page, npages, flags );
151
152 if ( page == PR_SYSTEM ) {
153 ERR("Can't reserve ring 1 memory\n");
154 return -1;
155 }
156 /* FIXME: This has to be handled separately for the separate
157 address-spaces we now have */
158 if ( page == PR_PRIVATE || page == PR_SHARED ) page = 0;
159 /* FIXME: Handle flags in some way */
160 address = (LPVOID )(page * psize);
161 ret = VirtualAlloc ( address, ( npages * psize ), MEM_RESERVE, 0 );
162 TRACE("PageReserve: returning: %p\n", ret );
163 if ( ret == NULL )
164 return -1;
165 else
166 return (DWORD )ret;
167 }
168
169 case 0x0001: /* PageCommit */
170 {
171 LPVOID address;
172 LPVOID ret;
173 DWORD virt_perm;
174 DWORD psize = getpagesize();
175 ULONG page = stack32_pop( context );
176 ULONG npages = stack32_pop( context );
177 ULONG hpd = stack32_pop( context );
178 ULONG pagerdata = stack32_pop( context );
179 ULONG flags = stack32_pop( context );
180
181 TRACE("PageCommit: page: %08x, npages: %08x, hpd: %08x pagerdata: "
182 "%08x, flags: %08x partial stub\n",
183 page, npages, hpd, pagerdata, flags );
184
185 if ( flags & PC_USER )
186 if ( flags & PC_WRITABLE )
187 virt_perm = PAGE_EXECUTE_READWRITE;
188 else
189 virt_perm = PAGE_EXECUTE_READ;
190 else
191 virt_perm = PAGE_NOACCESS;
192
193 address = (LPVOID )(page * psize);
194 ret = VirtualAlloc ( address, ( npages * psize ), MEM_COMMIT, virt_perm );
195 TRACE("PageCommit: Returning: %p\n", ret );
196 return (DWORD )ret;
197
198 }
199
200 case 0x0002: /* PageDecommit */
201 {
202 LPVOID address;
203 BOOL ret;
204 DWORD psize = getpagesize();
205 ULONG page = stack32_pop( context );
206 ULONG npages = stack32_pop( context );
207 ULONG flags = stack32_pop( context );
208
209 TRACE("PageDecommit: page: %08x, npages: %08x, flags: %08x partial stub\n",
210 page, npages, flags );
211 address = (LPVOID )( page * psize );
212 ret = VirtualFree ( address, ( npages * psize ), MEM_DECOMMIT );
213 TRACE("PageDecommit: Returning: %s\n", ret ? "TRUE" : "FALSE" );
214 return ret;
215 }
216
217 case 0x000d: /* PageModifyPermissions */
218 {
219 DWORD pg_old_perm;
220 DWORD pg_new_perm;
221 DWORD virt_old_perm;
222 DWORD virt_new_perm;
223 MEMORY_BASIC_INFORMATION mbi;
224 LPVOID address;
225 DWORD psize = getpagesize();
226 ULONG page = stack32_pop ( context );
227 ULONG npages = stack32_pop ( context );
228 ULONG permand = stack32_pop ( context );
229 ULONG permor = stack32_pop ( context );
230
231 TRACE("PageModifyPermissions %08x %08x %08x %08x partial stub\n",
232 page, npages, permand, permor );
233 address = (LPVOID )( page * psize );
234
235 VirtualQuery ( address, &mbi, sizeof ( MEMORY_BASIC_INFORMATION ));
236 virt_old_perm = mbi.Protect;
237
238 switch ( virt_old_perm & mbi.Protect ) {
239 case PAGE_READONLY:
240 case PAGE_EXECUTE:
241 case PAGE_EXECUTE_READ:
242 pg_old_perm = PC_USER;
243 break;
244 case PAGE_READWRITE:
245 case PAGE_WRITECOPY:
246 case PAGE_EXECUTE_READWRITE:
247 case PAGE_EXECUTE_WRITECOPY:
248 pg_old_perm = PC_USER | PC_WRITABLE;
249 break;
250 case PAGE_NOACCESS:
251 default:
252 pg_old_perm = 0;
253 break;
254 }
255 pg_new_perm = pg_old_perm;
256 pg_new_perm &= permand & ~PC_STATIC;
257 pg_new_perm |= permor & ~PC_STATIC;
258
259 virt_new_perm = ( virt_old_perm ) & ~0xff;
260 if ( pg_new_perm & PC_USER )
261 {
262 if ( pg_new_perm & PC_WRITABLE )
263 virt_new_perm |= PAGE_EXECUTE_READWRITE;
264 else
265 virt_new_perm |= PAGE_EXECUTE_READ;
266 }
267
268 if ( ! VirtualProtect ( address, ( npages * psize ), virt_new_perm, &virt_old_perm ) ) {
269 ERR("Can't change page permissions for %p\n", address );
270 return 0xffffffff;
271 }
272 TRACE("Returning: %08x\n", pg_old_perm );
273 return pg_old_perm;
274 }
275
276 case 0x000a: /* PageFree */
277 {
278 BOOL ret;
279 LPVOID hmem = (LPVOID) stack32_pop( context );
280 DWORD flags = stack32_pop( context );
281
282 TRACE("PageFree: hmem: %p, flags: %08x partial stub\n",
283 hmem, flags );
284
285 ret = VirtualFree ( hmem, 0, MEM_RELEASE );
286 TRACE("Returning: %d\n", ret );
287 return ret;
288 }
289
290 case 0x0011: /* RegOpenKey */
291 stack32_pop( context ); /* kkey */
292 stack32_pop( context ); /* lpszSubKey */
293 stack32_pop( context ); /* retkey */
294 /* return RegOpenKeyExA( hkey, lpszSubKey, 0, KEY_ALL_ACCESS, retkey ); */
295 if (!warned)
296 {
297 ERR( "Using the native Win95 advapi32.dll is no longer supported.\n" );
298 ERR( "Please configure advapi32 to builtin.\n" );
299 warned++;
300 }
301 return ERROR_CALL_NOT_IMPLEMENTED;
302
303 case 0x0012: /* RegCreateKey */
304 stack32_pop( context ); /* hkey */
305 stack32_pop( context ); /* lpszSubKey */
306 stack32_pop( context ); /* retkey */
307 /* return RegCreateKeyA( hkey, lpszSubKey, retkey ); */
308 if (!warned)
309 {
310 ERR( "Using the native Win95 advapi32.dll is no longer supported.\n" );
311 ERR( "Please configure advapi32 to builtin.\n" );
312 warned++;
313 }
314 return ERROR_CALL_NOT_IMPLEMENTED;
315
316 case 0x0013: /* RegCloseKey */
317 stack32_pop( context ); /* hkey */
318 /* return RegCloseKey( hkey ); */
319 return ERROR_CALL_NOT_IMPLEMENTED;
320
321 case 0x0014: /* RegDeleteKey */
322 stack32_pop( context ); /* hkey */
323 stack32_pop( context ); /* lpszSubKey */
324 /* return RegDeleteKeyA( hkey, lpszSubKey ); */
325 return ERROR_CALL_NOT_IMPLEMENTED;
326
327 case 0x0015: /* RegSetValue */
328 stack32_pop( context ); /* hkey */
329 stack32_pop( context ); /* lpszSubKey */
330 stack32_pop( context ); /* dwType */
331 stack32_pop( context ); /* lpszData */
332 stack32_pop( context ); /* cbData */
333 /* return RegSetValueA( hkey, lpszSubKey, dwType, lpszData, cbData ); */
334 return ERROR_CALL_NOT_IMPLEMENTED;
335
336 case 0x0016: /* RegDeleteValue */
337 stack32_pop( context ); /* hkey */
338 stack32_pop( context ); /* lpszValue */
339 /* return RegDeleteValueA( hkey, lpszValue ); */
340 return ERROR_CALL_NOT_IMPLEMENTED;
341
342 case 0x0017: /* RegQueryValue */
343 stack32_pop( context ); /* hkey */
344 stack32_pop( context ); /* lpszSubKey */
345 stack32_pop( context ); /* lpszData */
346 stack32_pop( context ); /* lpcbData */
347 /* return RegQueryValueA( hkey, lpszSubKey, lpszData, lpcbData ); */
348 return ERROR_CALL_NOT_IMPLEMENTED;
349
350 case 0x0018: /* RegEnumKey */
351 stack32_pop( context ); /* hkey */
352 stack32_pop( context ); /* iSubkey */
353 stack32_pop( context ); /* lpszName */
354 stack32_pop( context ); /* lpcchName */
355 /* return RegEnumKeyA( hkey, iSubkey, lpszName, lpcchName ); */
356 return ERROR_CALL_NOT_IMPLEMENTED;
357
358 case 0x0019: /* RegEnumValue */
359 stack32_pop( context ); /* hkey */
360 stack32_pop( context ); /* iValue */
361 stack32_pop( context ); /* lpszValue */
362 stack32_pop( context ); /* lpcchValue */
363 stack32_pop( context ); /* lpReserved */
364 stack32_pop( context ); /* lpdwType */
365 stack32_pop( context ); /* lpbData */
366 stack32_pop( context ); /* lpcbData */
367 /* return RegEnumValueA( hkey, iValue, lpszValue, lpcchValue, lpReserved, lpdwType, lpbData, lpcbData ); */
368 return ERROR_CALL_NOT_IMPLEMENTED;
369
370 case 0x001A: /* RegQueryValueEx */
371 stack32_pop( context ); /* hkey */
372 stack32_pop( context ); /* lpszValue */
373 stack32_pop( context ); /* lpReserved */
374 stack32_pop( context ); /* lpdwType */
375 stack32_pop( context ); /* lpbData */
376 stack32_pop( context ); /* lpcbData */
377 /* return RegQueryValueExA( hkey, lpszValue, lpReserved, lpdwType, lpbData, lpcbData ); */
378 return ERROR_CALL_NOT_IMPLEMENTED;
379
380 case 0x001B: /* RegSetValueEx */
381 stack32_pop( context ); /* hkey */
382 stack32_pop( context ); /* lpszValue */
383 stack32_pop( context ); /* dwReserved */
384 stack32_pop( context ); /* dwType */
385 stack32_pop( context ); /* lpbData */
386 stack32_pop( context ); /* cbData */
387 /* return RegSetValueExA( hkey, lpszValue, dwReserved, dwType, lpbData, cbData ); */
388 return ERROR_CALL_NOT_IMPLEMENTED;
389
390 case 0x001C: /* RegFlushKey */
391 stack32_pop( context ); /* hkey */
392 /* return RegFlushKey( hkey ); */
393 return ERROR_CALL_NOT_IMPLEMENTED;
394
395 case 0x001D: /* RegQueryInfoKey */
396 /* NOTE: This VxDCall takes only a subset of the parameters that the
397 corresponding Win32 API call does. The implementation in Win95
398 ADVAPI32 sets all output parameters not mentioned here to zero. */
399 stack32_pop( context ); /* hkey */
400 stack32_pop( context ); /* lpcSubKeys */
401 stack32_pop( context ); /* lpcchMaxSubKey */
402 stack32_pop( context ); /* lpcValues */
403 stack32_pop( context ); /* lpcchMaxValueName */
404 stack32_pop( context ); /* lpcchMaxValueData */
405 /* return RegQueryInfoKeyA( hkey, lpcSubKeys, lpcchMaxSubKey, lpcValues, lpcchMaxValueName, lpcchMaxValueData ); */
406 return ERROR_CALL_NOT_IMPLEMENTED;
407
408 case 0x001e: /* GetDemandPageInfo */
409 {
410 DWORD dinfo = stack32_pop( context );
411 DWORD flags = stack32_pop( context );
412
413 /* GetDemandPageInfo is supposed to fill out the struct at
414 * "dinfo" with various low-level memory management information.
415 * Apps are certainly not supposed to call this, although it's
416 * demoed and documented by Pietrek on pages 441-443 of "Windows
417 * 95 System Programming Secrets" if any program needs a real
418 * implementation of this.
419 */
420
421 FIXME("GetDemandPageInfo(%08x %08x): stub!\n", dinfo, flags);
422
423 return 0;
424 }
425
426 case 0x0021: /* RegLoadKey */
427 {
428 HKEY hkey = (HKEY) stack32_pop( context );
429 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
430 LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
431 FIXME("RegLoadKey(%p,%s,%s): stub\n",hkey, debugstr_a(lpszSubKey), debugstr_a(lpszFile));
432 return ERROR_CALL_NOT_IMPLEMENTED;
433 }
434
435 case 0x0022: /* RegUnLoadKey */
436 {
437 HKEY hkey = (HKEY) stack32_pop( context );
438 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
439 FIXME("RegUnLoadKey(%p,%s): stub\n",hkey, debugstr_a(lpszSubKey));
440 return ERROR_CALL_NOT_IMPLEMENTED;
441 }
442
443 case 0x0023: /* RegSaveKey */
444 {
445 HKEY hkey = (HKEY) stack32_pop( context );
446 LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
447 LPSECURITY_ATTRIBUTES sa = (LPSECURITY_ATTRIBUTES)stack32_pop( context );
448 FIXME("RegSaveKey(%p,%s,%p): stub\n",hkey, debugstr_a(lpszFile),sa);
449 return ERROR_CALL_NOT_IMPLEMENTED;
450 }
451
452 #if 0 /* Functions are not yet implemented in misc/registry.c */
453 case 0x0024: /* RegRemapPreDefKey */
454 case 0x0026: /* RegQueryMultipleValues */
455 #endif
456
457 case 0x0027: /* RegReplaceKey */
458 {
459 HKEY hkey = (HKEY) stack32_pop( context );
460 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
461 LPCSTR lpszNewFile= (LPCSTR)stack32_pop( context );
462 LPCSTR lpszOldFile= (LPCSTR)stack32_pop( context );
463 FIXME("RegReplaceKey(%p,%s,%s,%s): stub\n", hkey, debugstr_a(lpszSubKey),
464 debugstr_a(lpszNewFile),debugstr_a(lpszOldFile));
465 return ERROR_CALL_NOT_IMPLEMENTED;
466 }
467
468 default:
469 if (LOWORD(service) < N_VMM_SERVICE)
470 FIXME( "Unimplemented service %s (%08x)\n",
471 VMM_Service_Name[LOWORD(service)], service);
472 else
473 FIXME( "Unknown service %08x\n", service);
474 return 0xffffffff; /* FIXME */
475 }
476 }
477
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.