?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winegstreamer: Register stub ColorConvertDMO transform.
[wine.git] / dlls / wow64 / syscall.c
blob7cab0894738647e66e0e4fa6f98ec10562819366
1 /*
2 * WoW64 syscall wrapping
3 *
4 * Copyright 2021 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
21 #include <stdarg.h>
22
23 #include "ntstatus.h"
24 #define WIN32_NO_STATUS
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winnt.h"
28 #include "winternl.h"
29 #include "wine/exception.h"
30 #include "wine/unixlib.h"
31 #include "wow64_private.h"
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(wow);
35
36 USHORT native_machine = 0;
37 USHORT current_machine = 0;
38 ULONG_PTR args_alignment = 0;
39
40 typedef NTSTATUS (WINAPI *syscall_thunk)( UINT *args );
41
42 static const syscall_thunk syscall_thunks[] =
43 {
44 #define SYSCALL_ENTRY(func) wow64_ ## func,
45 ALL_SYSCALLS
46 #undef SYSCALL_ENTRY
47 };
48
49 static const char *syscall_names[] =
50 {
51 #define SYSCALL_ENTRY(func) #func,
52 ALL_SYSCALLS
53 #undef SYSCALL_ENTRY
54 };
55
56 static const SYSTEM_SERVICE_TABLE ntdll_syscall_table =
57 {
58 (ULONG_PTR *)syscall_thunks,
59 (ULONG_PTR *)syscall_names,
60 ARRAY_SIZE(syscall_thunks)
61 };
62
63 static SYSTEM_SERVICE_TABLE syscall_tables[4];
64
65 /* header for Wow64AllocTemp blocks; probably not the right layout */
66 struct mem_header
67 {
68 struct mem_header *next;
69 void *__pad;
70 BYTE data[1];
71 };
72
73 /* stack frame for user callbacks */
74 struct user_callback_frame
75 {
76 struct user_callback_frame *prev_frame;
77 struct mem_header *temp_list;
78 void **ret_ptr;
79 ULONG *ret_len;
80 NTSTATUS status;
81 __wine_jmp_buf jmpbuf;
82 };
83
84
85 SYSTEM_DLL_INIT_BLOCK *pLdrSystemDllInitBlock = NULL;
86
87 /* wow64win syscall table */
88 static const SYSTEM_SERVICE_TABLE *psdwhwin32;
89
90 /* cpu backend dll functions */
91 static void * (WINAPI *pBTCpuGetBopCode)(void);
92 static void (WINAPI *pBTCpuProcessInit)(void);
93 static void (WINAPI *pBTCpuSimulate)(void);
94 static NTSTATUS (WINAPI *pBTCpuResetToConsistentState)( EXCEPTION_POINTERS * );
95
96
97 void *dummy = RtlUnwind;
98
99 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, void *reserved )
100 {
101 if (reason == DLL_PROCESS_ATTACH) LdrDisableThreadCalloutsForDll( inst );
102 return TRUE;
103 }
104
105 void __cdecl __wine_spec_unimplemented_stub( const char *module, const char *function )
106 {
107 EXCEPTION_RECORD record;
108
109 record.ExceptionCode = EXCEPTION_WINE_STUB;
110 record.ExceptionFlags = EH_NONCONTINUABLE;
111 record.ExceptionRecord = NULL;
112 record.ExceptionAddress = __wine_spec_unimplemented_stub;
113 record.NumberParameters = 2;
114 record.ExceptionInformation[0] = (ULONG_PTR)module;
115 record.ExceptionInformation[1] = (ULONG_PTR)function;
116 for (;;) RtlRaiseException( &record );
117 }
118
119
120 /**********************************************************************
121 * wow64_NtAddAtom
122 */
123 NTSTATUS WINAPI wow64_NtAddAtom( UINT *args )
124 {
125 const WCHAR *name = get_ptr( &args );
126 ULONG len = get_ulong( &args );
127 RTL_ATOM *atom = get_ptr( &args );
128
129 return NtAddAtom( name, len, atom );
130 }
131
132
133 /**********************************************************************
134 * wow64_NtAllocateLocallyUniqueId
135 */
136 NTSTATUS WINAPI wow64_NtAllocateLocallyUniqueId( UINT *args )
137 {
138 LUID *luid = get_ptr( &args );
139
140 return NtAllocateLocallyUniqueId( luid );
141 }
142
143
144 /**********************************************************************
145 * wow64_NtAllocateUuids
146 */
147 NTSTATUS WINAPI wow64_NtAllocateUuids( UINT *args )
148 {
149 ULARGE_INTEGER *time = get_ptr( &args );
150 ULONG *delta = get_ptr( &args );
151 ULONG *sequence = get_ptr( &args );
152 UCHAR *seed = get_ptr( &args );
153
154 return NtAllocateUuids( time, delta, sequence, seed );
155 }
156
157
158 /***********************************************************************
159 * wow64_NtCallbackReturn
160 */
161 NTSTATUS WINAPI wow64_NtCallbackReturn( UINT *args )
162 {
163 void *ret_ptr = get_ptr( &args );
164 ULONG ret_len = get_ulong( &args );
165 NTSTATUS status = get_ulong( &args );
166
167 struct user_callback_frame *frame = NtCurrentTeb()->TlsSlots[WOW64_TLS_USERCALLBACKDATA];
168
169 if (!frame) return STATUS_NO_CALLBACK_ACTIVE;
170
171 *frame->ret_ptr = ret_ptr;
172 *frame->ret_len = ret_len;
173 frame->status = status;
174 __wine_longjmp( &frame->jmpbuf, 1 );
175 }
176
177
178 /**********************************************************************
179 * wow64_NtClose
180 */
181 NTSTATUS WINAPI wow64_NtClose( UINT *args )
182 {
183 HANDLE handle = get_handle( &args );
184
185 return NtClose( handle );
186 }
187
188
189 /**********************************************************************
190 * wow64_NtDeleteAtom
191 */
192 NTSTATUS WINAPI wow64_NtDeleteAtom( UINT *args )
193 {
194 RTL_ATOM atom = get_ulong( &args );
195
196 return NtDeleteAtom( atom );
197 }
198
199
200 /**********************************************************************
201 * wow64_NtFindAtom
202 */
203 NTSTATUS WINAPI wow64_NtFindAtom( UINT *args )
204 {
205 const WCHAR *name = get_ptr( &args );
206 ULONG len = get_ulong( &args );
207 RTL_ATOM *atom = get_ptr( &args );
208
209 return NtFindAtom( name, len, atom );
210 }
211
212
213 /**********************************************************************
214 * wow64_NtGetCurrentProcessorNumber
215 */
216 NTSTATUS WINAPI wow64_NtGetCurrentProcessorNumber( UINT *args )
217 {
218 return NtGetCurrentProcessorNumber();
219 }
220
221
222 /**********************************************************************
223 * wow64_NtQueryDefaultLocale
224 */
225 NTSTATUS WINAPI wow64_NtQueryDefaultLocale( UINT *args )
226 {
227 BOOLEAN user = get_ulong( &args );
228 LCID *lcid = get_ptr( &args );
229
230 return NtQueryDefaultLocale( user, lcid );
231 }
232
233
234 /**********************************************************************
235 * wow64_NtQueryDefaultUILanguage
236 */
237 NTSTATUS WINAPI wow64_NtQueryDefaultUILanguage( UINT *args )
238 {
239 LANGID *lang = get_ptr( &args );
240
241 return NtQueryDefaultUILanguage( lang );
242 }
243
244
245 /**********************************************************************
246 * wow64_NtQueryInformationAtom
247 */
248 NTSTATUS WINAPI wow64_NtQueryInformationAtom( UINT *args )
249 {
250 RTL_ATOM atom = get_ulong( &args );
251 ATOM_INFORMATION_CLASS class = get_ulong( &args );
252 void *info = get_ptr( &args );
253 ULONG len = get_ulong( &args );
254 ULONG *retlen = get_ptr( &args );
255
256 if (class != AtomBasicInformation) FIXME( "class %u not supported\n", class );
257 return NtQueryInformationAtom( atom, class, info, len, retlen );
258 }
259
260
261 /**********************************************************************
262 * wow64_NtQueryInstallUILanguage
263 */
264 NTSTATUS WINAPI wow64_NtQueryInstallUILanguage( UINT *args )
265 {
266 LANGID *lang = get_ptr( &args );
267
268 return NtQueryInstallUILanguage( lang );
269 }
270
271
272 /**********************************************************************
273 * wow64_NtSetDebugFilterState
274 */
275 NTSTATUS WINAPI wow64_NtSetDebugFilterState( UINT *args )
276 {
277 ULONG component_id = get_ulong( &args );
278 ULONG level = get_ulong( &args );
279 BOOLEAN state = get_ulong( &args );
280
281 return NtSetDebugFilterState( component_id, level, state );
282 }
283
284
285 /**********************************************************************
286 * wow64_NtSetDefaultLocale
287 */
288 NTSTATUS WINAPI wow64_NtSetDefaultLocale( UINT *args )
289 {
290 BOOLEAN user = get_ulong( &args );
291 LCID lcid = get_ulong( &args );
292
293 return NtSetDefaultLocale( user, lcid );
294 }
295
296
297 /**********************************************************************
298 * wow64_NtSetDefaultUILanguage
299 */
300 NTSTATUS WINAPI wow64_NtSetDefaultUILanguage( UINT *args )
301 {
302 LANGID lang = get_ulong( &args );
303
304 return NtSetDefaultUILanguage( lang );
305 }
306
307
308 /**********************************************************************
309 * wow64___wine_dbg_write
310 */
311 NTSTATUS WINAPI wow64___wine_dbg_write( UINT *args )
312 {
313 const char *str = get_ptr( &args );
314 ULONG len = get_ulong( &args );
315
316 return __wine_dbg_write( str, len );
317 }
318
319
320 /**********************************************************************
321 * wow64___wine_unix_call
322 */
323 NTSTATUS WINAPI wow64___wine_unix_call( UINT *args )
324 {
325 unixlib_handle_t handle = get_ulong64( &args );
326 unsigned int code = get_ulong( &args );
327 void *args_ptr = get_ptr( &args );
328
329 return __wine_unix_call( handle, code, args_ptr );
330 }
331
332
333 /**********************************************************************
334 * wow64___wine_unix_spawnvp
335 */
336 NTSTATUS WINAPI wow64___wine_unix_spawnvp( UINT *args )
337 {
338 ULONG *argv32 = get_ptr( &args );
339 int wait = get_ulong( &args );
340
341 unsigned int i, count = 0;
342 char **argv;
343
344 while (argv32[count]) count++;
345 argv = Wow64AllocateTemp( (count + 1) * sizeof(*argv) );
346 for (i = 0; i < count; i++) argv[i] = ULongToPtr( argv32[i] );
347 argv[count] = NULL;
348 return __wine_unix_spawnvp( argv, wait );
349 }
350
351
352 /**********************************************************************
353 * wow64_wine_server_call
354 */
355 NTSTATUS WINAPI wow64_wine_server_call( UINT *args )
356 {
357 struct __server_request_info32 *req32 = get_ptr( &args );
358
359 unsigned int i;
360 NTSTATUS status;
361 struct __server_request_info req;
362
363 req.u.req = req32->u.req;
364 req.data_count = req32->data_count;
365 for (i = 0; i < req.data_count; i++)
366 {
367 req.data[i].ptr = ULongToPtr( req32->data[i].ptr );
368 req.data[i].size = req32->data[i].size;
369 }
370 req.reply_data = ULongToPtr( req32->reply_data );
371 status = wine_server_call( &req );
372 req32->u.reply = req.u.reply;
373 return status;
374 }
375
376
377 /**********************************************************************
378 * get_syscall_num
379 */
380 static DWORD get_syscall_num( const BYTE *syscall )
381 {
382 DWORD id = ~0u;
383
384 if (!syscall) return id;
385 switch (current_machine)
386 {
387 case IMAGE_FILE_MACHINE_I386:
388 if (syscall[0] == 0xb8 && syscall[5] == 0xba && syscall[10] == 0xff && syscall[11] == 0xd2)
389 id = *(DWORD *)(syscall + 1);
390 break;
391
392 case IMAGE_FILE_MACHINE_ARM:
393 if (*(WORD *)syscall == 0xb40f)
394 {
395 DWORD inst = *(DWORD *)((WORD *)syscall + 1);
396 id = ((inst << 1) & 0x0800) + ((inst << 12) & 0xf000) +
397 ((inst >> 20) & 0x0700) + ((inst >> 16) & 0x00ff);
398 }
399 break;
400 }
401 return id;
402 }
403
404
405 /**********************************************************************
406 * init_image_mapping
407 */
408 void init_image_mapping( HMODULE module )
409 {
410 void **ptr = RtlFindExportedRoutineByName( module, "Wow64Transition" );
411
412 if (ptr) *ptr = pBTCpuGetBopCode();
413 }
414
415
416 /**********************************************************************
417 * init_syscall_table
418 */
419 static void init_syscall_table( HMODULE module, ULONG idx, const SYSTEM_SERVICE_TABLE *orig_table )
420 {
421 static syscall_thunk thunks[2048];
422 static ULONG start_pos;
423
424 const IMAGE_EXPORT_DIRECTORY *exports;
425 const ULONG *functions, *names;
426 const USHORT *ordinals;
427 ULONG id, exp_size, exp_pos, wrap_pos, max_pos = 0;
428 const char **syscall_names = (const char **)orig_table->CounterTable;
429
430 exports = RtlImageDirectoryEntryToData( module, TRUE, IMAGE_DIRECTORY_ENTRY_EXPORT, &exp_size );
431 ordinals = get_rva( module, exports->AddressOfNameOrdinals );
432 functions = get_rva( module, exports->AddressOfFunctions );
433 names = get_rva( module, exports->AddressOfNames );
434
435 for (exp_pos = wrap_pos = 0; exp_pos < exports->NumberOfNames; exp_pos++)
436 {
437 char *name = get_rva( module, names[exp_pos] );
438 int res = -1;
439
440 if (strncmp( name, "Nt", 2 ) && strncmp( name, "wine", 4 ) && strncmp( name, "__wine", 6 ))
441 continue; /* not a syscall */
442
443 if ((id = get_syscall_num( get_rva( module, functions[ordinals[exp_pos]] ))) == ~0u)
444 continue; /* not a syscall */
445
446 if (wrap_pos < orig_table->ServiceLimit) res = strcmp( name, syscall_names[wrap_pos] );
447
448 if (!res) /* got a match */
449 {
450 ULONG table_idx = (id >> 12) & 3, table_pos = id & 0xfff;
451 if (table_idx == idx)
452 {
453 if (start_pos + table_pos < ARRAY_SIZE(thunks))
454 {
455 thunks[start_pos + table_pos] = (syscall_thunk)orig_table->ServiceTable[wrap_pos++];
456 max_pos = max( table_pos, max_pos );
457 }
458 else ERR( "invalid syscall id %04lx for %s\n", id, name );
459 }
460 else ERR( "wrong syscall table id %04lx for %s\n", id, name );
461 }
462 else if (res > 0)
463 {
464 FIXME( "no export for syscall %s\n", syscall_names[wrap_pos] );
465 wrap_pos++;
466 exp_pos--; /* try again */
467 }
468 else FIXME( "missing wrapper for syscall %04lx %s\n", id, name );
469 }
470
471 for ( ; wrap_pos < orig_table->ServiceLimit; wrap_pos++)
472 FIXME( "no export for syscall %s\n", syscall_names[wrap_pos] );
473
474 syscall_tables[idx].ServiceTable = (ULONG_PTR *)(thunks + start_pos);
475 syscall_tables[idx].ServiceLimit = max_pos + 1;
476 start_pos += max_pos + 1;
477 }
478
479
480 /**********************************************************************
481 * load_64bit_module
482 */
483 static HMODULE load_64bit_module( const WCHAR *name )
484 {
485 NTSTATUS status;
486 HMODULE module;
487 UNICODE_STRING str;
488 WCHAR path[MAX_PATH];
489 const WCHAR *dir = get_machine_wow64_dir( IMAGE_FILE_MACHINE_TARGET_HOST );
490
491 swprintf( path, MAX_PATH, L"%s\\%s", dir, name );
492 RtlInitUnicodeString( &str, path );
493 if ((status = LdrLoadDll( NULL, 0, &str, &module )))
494 {
495 ERR( "failed to load dll %lx\n", status );
496 NtTerminateProcess( GetCurrentProcess(), status );
497 }
498 return module;
499 }
500
501
502 /**********************************************************************
503 * load_32bit_module
504 */
505 static HMODULE load_32bit_module( const WCHAR *name )
506 {
507 NTSTATUS status;
508 UNICODE_STRING str;
509 WCHAR path[MAX_PATH];
510 HANDLE file, mapping;
511 LARGE_INTEGER size;
512 IO_STATUS_BLOCK io;
513 OBJECT_ATTRIBUTES attr;
514 SIZE_T len = 0;
515 void *module = NULL;
516 const WCHAR *dir = get_machine_wow64_dir( current_machine );
517
518 swprintf( path, MAX_PATH, L"%s\\%s", dir, name );
519 RtlInitUnicodeString( &str, path );
520 InitializeObjectAttributes( &attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL );
521 if ((status = NtOpenFile( &file, GENERIC_READ | SYNCHRONIZE, &attr, &io,
522 FILE_SHARE_READ | FILE_SHARE_DELETE,
523 FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE ))) goto failed;
524
525 size.QuadPart = 0;
526 status = NtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY |
527 SECTION_MAP_READ | SECTION_MAP_EXECUTE,
528 NULL, &size, PAGE_EXECUTE_READ, SEC_IMAGE, file );
529 NtClose( file );
530 if (status) goto failed;
531
532 status = NtMapViewOfSection( mapping, GetCurrentProcess(), &module, 0, 0, NULL, &len,
533 ViewShare, 0, PAGE_EXECUTE_READ );
534 NtClose( mapping );
535 if (!status) return module;
536
537 failed:
538 ERR( "failed to load dll %lx\n", status );
539 NtTerminateProcess( GetCurrentProcess(), status );
540 return NULL;
541 }
542
543
544 /**********************************************************************
545 * get_cpu_dll_name
546 */
547 static const WCHAR *get_cpu_dll_name(void)
548 {
549 switch (current_machine)
550 {
551 case IMAGE_FILE_MACHINE_I386:
552 return (native_machine == IMAGE_FILE_MACHINE_ARM64 ? L"xtajit.dll" : L"wow64cpu.dll");
553 case IMAGE_FILE_MACHINE_ARM:
554 return L"wowarmhw.dll";
555 default:
556 ERR( "unsupported machine %04x\n", current_machine );
557 RtlExitUserProcess( 1 );
558 }
559 }
560
561
562 /**********************************************************************
563 * process_init
564 */
565 static DWORD WINAPI process_init( RTL_RUN_ONCE *once, void *param, void **context )
566 {
567 HMODULE module;
568 UNICODE_STRING str;
569
570 RtlWow64GetProcessMachines( GetCurrentProcess(), &current_machine, &native_machine );
571 if (!current_machine) current_machine = native_machine;
572 args_alignment = (current_machine == IMAGE_FILE_MACHINE_I386) ? sizeof(ULONG) : sizeof(ULONG64);
573
574 #define GET_PTR(name) p ## name = RtlFindExportedRoutineByName( module, #name )
575
576 RtlInitUnicodeString( &str, L"ntdll.dll" );
577 LdrGetDllHandle( NULL, 0, &str, &module );
578 GET_PTR( LdrSystemDllInitBlock );
579
580 module = load_64bit_module( get_cpu_dll_name() );
581 GET_PTR( BTCpuGetBopCode );
582 GET_PTR( BTCpuProcessInit );
583 GET_PTR( BTCpuResetToConsistentState );
584 GET_PTR( BTCpuSimulate );
585
586 module = load_64bit_module( L"wow64win.dll" );
587 GET_PTR( sdwhwin32 );
588
589 pBTCpuProcessInit();
590
591 module = (HMODULE)(ULONG_PTR)pLdrSystemDllInitBlock->ntdll_handle;
592 init_image_mapping( module );
593 init_syscall_table( module, 0, &ntdll_syscall_table );
594 *(void **)RtlFindExportedRoutineByName( module, "__wine_syscall_dispatcher" ) = pBTCpuGetBopCode();
595
596 module = load_32bit_module( L"win32u.dll" );
597 init_syscall_table( module, 1, psdwhwin32 );
598 NtUnmapViewOfSection( GetCurrentProcess(), module );
599
600 init_file_redirects();
601 return TRUE;
602
603 #undef GET_PTR
604 }
605
606
607 /**********************************************************************
608 * thread_init
609 */
610 static void thread_init(void)
611 {
612 /* update initial context to jump to 32-bit LdrInitializeThunk (cf. 32-bit call_init_thunk) */
613 switch (current_machine)
614 {
615 case IMAGE_FILE_MACHINE_I386:
616 {
617 I386_CONTEXT *ctx_ptr, ctx = { CONTEXT_I386_ALL };
618 ULONG *stack;
619
620 NtQueryInformationThread( GetCurrentThread(), ThreadWow64Context, &ctx, sizeof(ctx), NULL );
621 ctx_ptr = (I386_CONTEXT *)ULongToPtr( ctx.Esp ) - 1;
622 *ctx_ptr = ctx;
623
624 stack = (ULONG *)ctx_ptr;
625 *(--stack) = 0;
626 *(--stack) = 0;
627 *(--stack) = 0;
628 *(--stack) = PtrToUlong( ctx_ptr );
629 *(--stack) = 0xdeadbabe;
630 ctx.Esp = PtrToUlong( stack );
631 ctx.Eip = pLdrSystemDllInitBlock->pLdrInitializeThunk;
632 NtSetInformationThread( GetCurrentThread(), ThreadWow64Context, &ctx, sizeof(ctx) );
633 }
634 break;
635
636 case IMAGE_FILE_MACHINE_ARMNT:
637 {
638 ARM_CONTEXT *ctx_ptr, ctx = { CONTEXT_ARM_ALL };
639
640 NtQueryInformationThread( GetCurrentThread(), ThreadWow64Context, &ctx, sizeof(ctx), NULL );
641 ctx_ptr = (ARM_CONTEXT *)ULongToPtr( ctx.Sp & ~15 ) - 1;
642 *ctx_ptr = ctx;
643
644 ctx.R0 = PtrToUlong( ctx_ptr );
645 ctx.Sp = PtrToUlong( ctx_ptr );
646 ctx.Pc = pLdrSystemDllInitBlock->pLdrInitializeThunk;
647 NtSetInformationThread( GetCurrentThread(), ThreadWow64Context, &ctx, sizeof(ctx) );
648 }
649 break;
650
651 default:
652 ERR( "not supported machine %x\n", current_machine );
653 NtTerminateProcess( GetCurrentProcess(), STATUS_INVALID_IMAGE_FORMAT );
654 }
655 }
656
657
658 /**********************************************************************
659 * free_temp_data
660 */
661 static void free_temp_data(void)
662 {
663 struct mem_header *next, *mem;
664
665 for (mem = NtCurrentTeb()->TlsSlots[WOW64_TLS_TEMPLIST]; mem; mem = next)
666 {
667 next = mem->next;
668 RtlFreeHeap( GetProcessHeap(), 0, mem );
669 }
670 NtCurrentTeb()->TlsSlots[WOW64_TLS_TEMPLIST] = NULL;
671 }
672
673
674 /**********************************************************************
675 * syscall_filter
676 */
677 static LONG CALLBACK syscall_filter( EXCEPTION_POINTERS *ptrs )
678 {
679 switch (ptrs->ExceptionRecord->ExceptionCode)
680 {
681 case STATUS_INVALID_HANDLE:
682 Wow64PassExceptionToGuest( ptrs );
683 break;
684 }
685 return EXCEPTION_EXECUTE_HANDLER;
686 }
687
688
689 /**********************************************************************
690 * Wow64SystemServiceEx (wow64.@)
691 */
692 NTSTATUS WINAPI Wow64SystemServiceEx( UINT num, UINT *args )
693 {
694 NTSTATUS status;
695 UINT id = num & 0xfff;
696 const SYSTEM_SERVICE_TABLE *table = &syscall_tables[(num >> 12) & 3];
697
698 if (id >= table->ServiceLimit || !table->ServiceTable[id])
699 {
700 ERR( "unsupported syscall %04x\n", num );
701 return STATUS_INVALID_SYSTEM_SERVICE;
702 }
703 __TRY
704 {
705 syscall_thunk thunk = (syscall_thunk)table->ServiceTable[id];
706 status = thunk( args );
707 }
708 __EXCEPT( syscall_filter )
709 {
710 status = GetExceptionCode();
711 }
712 __ENDTRY;
713 free_temp_data();
714 return status;
715 }
716
717
718 static void cpu_simulate(void);
719
720 /**********************************************************************
721 * simulate_filter
722 */
723 static LONG CALLBACK simulate_filter( EXCEPTION_POINTERS *ptrs )
724 {
725 Wow64PassExceptionToGuest( ptrs );
726 cpu_simulate(); /* re-enter simulation to run the exception dispatcher */
727 return EXCEPTION_EXECUTE_HANDLER;
728 }
729
730
731 /**********************************************************************
732 * cpu_simulate
733 */
734 static void cpu_simulate(void)
735 {
736 for (;;)
737 {
738 __TRY
739 {
740 pBTCpuSimulate();
741 }
742 __EXCEPT( simulate_filter )
743 {
744 /* restart simulation loop */
745 }
746 __ENDTRY
747 }
748 }
749
750
751 /**********************************************************************
752 * Wow64AllocateTemp (wow64.@)
753 *
754 * FIXME: probably not 100% compatible.
755 */
756 void * WINAPI Wow64AllocateTemp( SIZE_T size )
757 {
758 struct mem_header *mem;
759
760 if (!(mem = RtlAllocateHeap( GetProcessHeap(), 0, offsetof( struct mem_header, data[size] ))))
761 return NULL;
762 mem->next = NtCurrentTeb()->TlsSlots[WOW64_TLS_TEMPLIST];
763 NtCurrentTeb()->TlsSlots[WOW64_TLS_TEMPLIST] = mem;
764 return mem->data;
765 }
766
767
768 /**********************************************************************
769 * Wow64ApcRoutine (wow64.@)
770 */
771 void WINAPI Wow64ApcRoutine( ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, CONTEXT *context )
772 {
773 NTSTATUS retval;
774
775 #ifdef __x86_64__
776 retval = context->Rax;
777 #elif defined(__aarch64__)
778 retval = context->X0;
779 #endif
780
781 /* cf. 32-bit call_user_apc_dispatcher */
782 switch (current_machine)
783 {
784 case IMAGE_FILE_MACHINE_I386:
785 {
786 struct apc_stack_layout
787 {
788 ULONG ret;
789 ULONG context_ptr;
790 ULONG arg1;
791 ULONG arg2;
792 ULONG arg3;
793 ULONG func;
794 I386_CONTEXT context;
795 } *stack;
796 I386_CONTEXT ctx = { CONTEXT_I386_FULL };
797
798 NtQueryInformationThread( GetCurrentThread(), ThreadWow64Context, &ctx, sizeof(ctx), NULL );
799 stack = (struct apc_stack_layout *)ULongToPtr( ctx.Esp & ~3 ) - 1;
800 stack->context_ptr = PtrToUlong( &stack->context );
801 stack->func = arg1 >> 32;
802 stack->arg1 = arg1;
803 stack->arg2 = arg2;
804 stack->arg3 = arg3;
805 stack->context = ctx;
806 stack->context.Eax = retval;
807 ctx.Esp = PtrToUlong( stack );
808 ctx.Eip = pLdrSystemDllInitBlock->pKiUserApcDispatcher;
809 NtSetInformationThread( GetCurrentThread(), ThreadWow64Context, &ctx, sizeof(ctx) );
810 }
811 break;
812
813 case IMAGE_FILE_MACHINE_ARMNT:
814 {
815 struct apc_stack_layout
816 {
817 ULONG func;
818 ULONG align[3];
819 ARM_CONTEXT context;
820 } *stack;
821 ARM_CONTEXT ctx = { CONTEXT_ARM_FULL };
822
823 NtQueryInformationThread( GetCurrentThread(), ThreadWow64Context, &ctx, sizeof(ctx), NULL );
824 stack = (struct apc_stack_layout *)ULongToPtr( ctx.Sp & ~15 ) - 1;
825 stack->func = arg1 >> 32;
826 stack->context = ctx;
827 stack->context.R0 = retval;
828 ctx.Sp = PtrToUlong( stack );
829 ctx.Pc = pLdrSystemDllInitBlock->pKiUserApcDispatcher;
830 ctx.R0 = PtrToUlong( &stack->context );
831 ctx.R1 = arg1;
832 ctx.R2 = arg2;
833 ctx.R3 = arg3;
834 NtSetInformationThread( GetCurrentThread(), ThreadWow64Context, &ctx, sizeof(ctx) );
835 }
836 break;
837 }
838 }
839
840
841 /**********************************************************************
842 * Wow64KiUserCallbackDispatcher (wow64.@)
843 */
844 NTSTATUS WINAPI Wow64KiUserCallbackDispatcher( ULONG id, void *args, ULONG len,
845 void **ret_ptr, ULONG *ret_len )
846 {
847 struct user_callback_frame frame;
848
849 frame.prev_frame = NtCurrentTeb()->TlsSlots[WOW64_TLS_USERCALLBACKDATA];
850 frame.temp_list = NtCurrentTeb()->TlsSlots[WOW64_TLS_TEMPLIST];
851 frame.ret_ptr = ret_ptr;
852 frame.ret_len = ret_len;
853
854 NtCurrentTeb()->TlsSlots[WOW64_TLS_USERCALLBACKDATA] = &frame;
855 NtCurrentTeb()->TlsSlots[WOW64_TLS_TEMPLIST] = NULL;
856
857 /* cf. 32-bit KeUserModeCallback */
858 switch (current_machine)
859 {
860 case IMAGE_FILE_MACHINE_I386:
861 {
862 I386_CONTEXT orig_ctx, ctx = { CONTEXT_I386_FULL };
863 void *args_data;
864 ULONG *stack;
865
866 NtQueryInformationThread( GetCurrentThread(), ThreadWow64Context, &ctx, sizeof(ctx), NULL );
867
868 stack = args_data = ULongToPtr( (ctx.Esp - len) & ~15 );
869 memcpy( args_data, args, len );
870 *(--stack) = 0;
871 *(--stack) = len;
872 *(--stack) = PtrToUlong( args_data );
873 *(--stack) = id;
874 *(--stack) = 0xdeadbabe;
875
876 orig_ctx = ctx;
877 ctx.Esp = PtrToUlong( stack );
878 ctx.Eip = pLdrSystemDllInitBlock->pKiUserCallbackDispatcher;
879 NtSetInformationThread( GetCurrentThread(), ThreadWow64Context, &ctx, sizeof(ctx) );
880
881 if (!__wine_setjmpex( &frame.jmpbuf, NULL ))
882 cpu_simulate();
883 else
884 NtSetInformationThread( GetCurrentThread(), ThreadWow64Context,
885 &orig_ctx, sizeof(orig_ctx) );
886 }
887 break;
888
889 case IMAGE_FILE_MACHINE_ARMNT:
890 {
891 ARM_CONTEXT orig_ctx, ctx = { CONTEXT_ARM_FULL };
892 void *args_data;
893
894 NtQueryInformationThread( GetCurrentThread(), ThreadWow64Context, &ctx, sizeof(ctx), NULL );
895
896 args_data = ULongToPtr( (ctx.Sp - len) & ~15 );
897 memcpy( args_data, args, len );
898
899 ctx.R0 = id;
900 ctx.R1 = PtrToUlong( args );
901 ctx.R2 = len;
902 ctx.Sp = PtrToUlong( args_data );
903 ctx.Pc = pLdrSystemDllInitBlock->pKiUserCallbackDispatcher;
904 NtSetInformationThread( GetCurrentThread(), ThreadWow64Context, &ctx, sizeof(ctx) );
905
906 if (!__wine_setjmpex( &frame.jmpbuf, NULL ))
907 cpu_simulate();
908 else
909 NtSetInformationThread( GetCurrentThread(), ThreadWow64Context,
910 &orig_ctx, sizeof(orig_ctx) );
911 }
912 break;
913 }
914
915 NtCurrentTeb()->TlsSlots[WOW64_TLS_USERCALLBACKDATA] = frame.prev_frame;
916 NtCurrentTeb()->TlsSlots[WOW64_TLS_TEMPLIST] = frame.temp_list;
917 return frame.status;
918 }
919
920
921 /**********************************************************************
922 * Wow64LdrpInitialize (wow64.@)
923 */
924 void WINAPI Wow64LdrpInitialize( CONTEXT *context )
925 {
926 static RTL_RUN_ONCE init_done;
927
928 RtlRunOnceExecuteOnce( &init_done, process_init, NULL, NULL );
929 thread_init();
930 cpu_simulate();
931 }
932
933
934 /**********************************************************************
935 * Wow64PrepareForException (wow64.@)
936 */
937 void WINAPI Wow64PrepareForException( EXCEPTION_RECORD *rec, CONTEXT *context )
938 {
939 EXCEPTION_POINTERS ptrs = { rec, context };
940
941 pBTCpuResetToConsistentState( &ptrs );
942 }
Windows API implementation