Added Get/SetThreadContext support through the server.
diff --git a/include/server.h b/include/server.h index 76694e0..a19287e 100644 --- a/include/server.h +++ b/include/server.h
@@ -27,6 +27,86 @@ /* a path name for server requests (Unicode) */ typedef WCHAR path_t[MAX_PATH+1]; + +/* definitions of the event data depending on the event code */ +struct debug_event_exception +{ + int code; /* exception code */ + int flags; /* exception flags */ + void *record; /* exception record ptr */ + void *addr; /* exception address */ + int nb_params; /* exceptions parameters */ + int params[15]; + int first_chance; /* first chance to handle it? */ + CONTEXT context; /* thread context */ +}; +struct debug_event_create_thread +{ + int handle; /* handle to the new thread */ + void *teb; /* thread teb (in debugged process address space) */ + void *start; /* thread startup routine */ +}; +struct debug_event_create_process +{ + int file; /* handle to the process exe file */ + int process; /* handle to the new process */ + int thread; /* handle to the new thread */ + void *base; /* base of executable image */ + int dbg_offset; /* offset of debug info in file */ + int dbg_size; /* size of debug info */ + void *teb; /* thread teb (in debugged process address space) */ + void *start; /* thread startup routine */ + void *name; /* image name (optional) */ + int unicode; /* is it Unicode? */ +}; +struct debug_event_exit +{ + int exit_code; /* thread or process exit code */ +}; +struct debug_event_load_dll +{ + int handle; /* file handle for the dll */ + void *base; /* base address of the dll */ + int dbg_offset; /* offset of debug info in file */ + int dbg_size; /* size of debug info */ + void *name; /* image name (optional) */ + int unicode; /* is it Unicode? */ +}; +struct debug_event_unload_dll +{ + void *base; /* base address of the dll */ +}; +struct debug_event_output_string +{ + void *string; /* string to display (in debugged process address space) */ + int unicode; /* is it Unicode? */ + int length; /* string length */ +}; +struct debug_event_rip_info +{ + int error; /* ??? */ + int type; /* ??? */ +}; +union debug_event_data +{ + struct debug_event_exception exception; + struct debug_event_create_thread create_thread; + struct debug_event_create_process create_process; + struct debug_event_exit exit; + struct debug_event_load_dll load_dll; + struct debug_event_unload_dll unload_dll; + struct debug_event_output_string output_string; + struct debug_event_rip_info rip_info; +}; + +/* debug event data */ +typedef struct +{ + int code; /* event code */ + union debug_event_data info; /* event information */ +} debug_event_t; + + /* Create a new process from the context of the parent */ struct new_process_request { @@ -707,92 +787,18 @@ /* Wait for a debug event */ struct wait_debug_event_request { - IN int timeout; /* timeout in ms */ - OUT int code; /* event code */ - OUT void* pid; /* process id */ - OUT void* tid; /* thread id */ -/* OUT union debug_event_data data; */ + IN int timeout; /* timeout in ms */ + OUT void* pid; /* process id */ + OUT void* tid; /* thread id */ + OUT debug_event_t event; /* debug event data */ }; /* Send a debug event */ struct send_debug_event_request { - IN int code; /* event code */ - OUT int status; /* event continuation status */ -/* IN union debug_event_data data; */ -}; - - -/* definitions of the event data depending on the event code */ -struct debug_event_exception -{ - int code; /* exception code */ - int flags; /* exception flags */ - void *record; /* exception record ptr */ - void *addr; /* exception address */ - int nb_params; /* exceptions parameters */ - int params[15]; - int first_chance; /* first chance to handle it? */ - CONTEXT context; /* thread context */ -}; -struct debug_event_create_thread -{ - int handle; /* handle to the new thread */ - void *teb; /* thread teb (in debugged process address space) */ - void *start; /* thread startup routine */ -}; -struct debug_event_create_process -{ - int file; /* handle to the process exe file */ - int process; /* handle to the new process */ - int thread; /* handle to the new thread */ - void *base; /* base of executable image */ - int dbg_offset; /* offset of debug info in file */ - int dbg_size; /* size of debug info */ - void *teb; /* thread teb (in debugged process address space) */ - void *start; /* thread startup routine */ - void *name; /* image name (optional) */ - int unicode; /* is it Unicode? */ -}; -struct debug_event_exit -{ - int exit_code; /* thread or process exit code */ -}; -struct debug_event_load_dll -{ - int handle; /* file handle for the dll */ - void *base; /* base address of the dll */ - int dbg_offset; /* offset of debug info in file */ - int dbg_size; /* size of debug info */ - void *name; /* image name (optional) */ - int unicode; /* is it Unicode? */ -}; -struct debug_event_unload_dll -{ - void *base; /* base address of the dll */ -}; -struct debug_event_output_string -{ - void *string; /* string to display (in debugged process address space) */ - int unicode; /* is it Unicode? */ - int length; /* string length */ -}; -struct debug_event_rip_info -{ - int error; /* ??? */ - int type; /* ??? */ -}; -union debug_event_data -{ - struct debug_event_exception exception; - struct debug_event_create_thread create_thread; - struct debug_event_create_process create_process; - struct debug_event_exit exit; - struct debug_event_load_dll load_dll; - struct debug_event_unload_dll unload_dll; - struct debug_event_output_string output_string; - struct debug_event_rip_info rip_info; + OUT int status; /* event continuation status */ + IN debug_event_t event; /* debug event data */ }; @@ -1005,6 +1011,24 @@ }; +/* Retrieve the current context of a thread */ +struct get_thread_context_request +{ + IN int handle; /* thread handle */ + IN unsigned int flags; /* context flags */ + OUT CONTEXT context; /* thread context */ +}; + + +/* Set the current context of a thread */ +struct set_thread_context_request +{ + IN int handle; /* thread handle */ + IN unsigned int flags; /* context flags */ + IN CONTEXT context; /* thread context */ +}; + + /* Everything below this line is generated automatically by tools/make_requests */ /* ### make_requests begin ### */ @@ -1100,6 +1124,8 @@ REQ_OPEN_TIMER, REQ_SET_TIMER, REQ_CANCEL_TIMER, + REQ_GET_THREAD_CONTEXT, + REQ_SET_THREAD_CONTEXT, REQ_NB_REQUESTS };
diff --git a/scheduler/debugger.c b/scheduler/debugger.c index 53fd9ed..8a09485 100644 --- a/scheduler/debugger.c +++ b/scheduler/debugger.c
@@ -11,22 +11,7 @@ #include "server.h" #include "debugtools.h" -DEFAULT_DEBUG_CHANNEL(debugstr) - -/********************************************************************** - * DEBUG_SendEvent - * - * Internal helper to send a debug event request to the server. - */ -static DWORD DEBUG_SendEvent( int code, void *data, int size ) -{ - DWORD ret = 0; - struct send_debug_event_request *req = get_req_buffer(); - req->code = code; - memcpy( req + 1, data, size ); - if (!server_call( REQ_SEND_DEBUG_EVENT )) ret = req->status; - return ret; -} +DEFAULT_DEBUG_CHANNEL(debugstr); /********************************************************************** @@ -39,21 +24,21 @@ int i; DWORD ret = 0; struct send_debug_event_request *req = get_req_buffer(); - struct debug_event_exception *event = (struct debug_event_exception *)(req + 1); - req->code = EXCEPTION_DEBUG_EVENT; - event->code = rec->ExceptionCode; - event->flags = rec->ExceptionFlags; - event->record = rec->ExceptionRecord; - event->addr = rec->ExceptionAddress; - event->nb_params = rec->NumberParameters; - for (i = 0; i < event->nb_params; i++) event->params[i] = rec->ExceptionInformation[i]; - event->first_chance = first_chance; - event->context = *context; + req->event.code = EXCEPTION_DEBUG_EVENT; + req->event.info.exception.code = rec->ExceptionCode; + req->event.info.exception.flags = rec->ExceptionFlags; + req->event.info.exception.record = rec->ExceptionRecord; + req->event.info.exception.addr = rec->ExceptionAddress; + req->event.info.exception.nb_params = rec->NumberParameters; + req->event.info.exception.first_chance = first_chance; + req->event.info.exception.context = *context; + for (i = 0; i < req->event.info.exception.nb_params; i++) + req->event.info.exception.params[i] = rec->ExceptionInformation[i]; if (!server_call( REQ_SEND_DEBUG_EVENT )) { ret = req->status; - *context = event->context; + *context = req->event.info.exception.context; } return ret; } @@ -67,22 +52,24 @@ */ DWORD DEBUG_SendCreateProcessEvent( HFILE file, HMODULE module, void *entry ) { - struct debug_event_create_process event; + DWORD ret = 0; + struct send_debug_event_request *req = get_req_buffer(); - event.file = file; - event.process = 0; /* will be filled by server */ - event.thread = 0; /* will be filled by server */ - event.base = (void *)module; - event.dbg_offset = 0; /* FIXME */ - event.dbg_size = 0; /* FIXME */ - event.teb = NtCurrentTeb(); - event.start = entry; - event.name = 0; /* FIXME */ - event.unicode = 0; /* FIXME */ - return DEBUG_SendEvent( CREATE_PROCESS_DEBUG_EVENT, &event, sizeof(event) ); + req->event.code = CREATE_PROCESS_DEBUG_EVENT; + req->event.info.create_process.file = file; + req->event.info.create_process.process = 0; /* will be filled by server */ + req->event.info.create_process.thread = 0; /* will be filled by server */ + req->event.info.create_process.base = (void *)module; + req->event.info.create_process.dbg_offset = 0; /* FIXME */ + req->event.info.create_process.dbg_size = 0; /* FIXME */ + req->event.info.create_process.teb = NtCurrentTeb(); + req->event.info.create_process.start = entry; + req->event.info.create_process.name = 0; /* FIXME */ + req->event.info.create_process.unicode = 0; /* FIXME */ + if (!server_call( REQ_SEND_DEBUG_EVENT )) ret = req->status; + return ret; } - /********************************************************************** * DEBUG_SendCreateThreadEvent * @@ -91,12 +78,15 @@ */ DWORD DEBUG_SendCreateThreadEvent( void *entry ) { - struct debug_event_create_thread event; + DWORD ret = 0; + struct send_debug_event_request *req = get_req_buffer(); - event.handle = 0; /* will be filled by server */ - event.teb = NtCurrentTeb(); - event.start = entry; - return DEBUG_SendEvent( CREATE_THREAD_DEBUG_EVENT, &event, sizeof(event) ); + req->event.code = CREATE_THREAD_DEBUG_EVENT; + req->event.info.create_thread.handle = 0; /* will be filled by server */ + req->event.info.create_thread.teb = NtCurrentTeb(); + req->event.info.create_thread.start = entry; + if (!server_call( REQ_SEND_DEBUG_EVENT )) ret = req->status; + return ret; } @@ -107,15 +97,18 @@ */ DWORD DEBUG_SendLoadDLLEvent( HFILE file, HMODULE module, LPSTR *name ) { - struct debug_event_load_dll event; + DWORD ret = 0; + struct send_debug_event_request *req = get_req_buffer(); - event.handle = file; - event.base = (void *)module; - event.dbg_offset = 0; /* FIXME */ - event.dbg_size = 0; /* FIXME */ - event.name = name; - event.unicode = 0; - return DEBUG_SendEvent( LOAD_DLL_DEBUG_EVENT, &event, sizeof(event) ); + req->event.code = LOAD_DLL_DEBUG_EVENT; + req->event.info.load_dll.handle = file; + req->event.info.load_dll.base = (void *)module; + req->event.info.load_dll.dbg_offset = 0; /* FIXME */ + req->event.info.load_dll.dbg_size = 0; /* FIXME */ + req->event.info.load_dll.name = name; + req->event.info.load_dll.unicode = 0; + if (!server_call( REQ_SEND_DEBUG_EVENT )) ret = req->status; + return ret; } @@ -126,10 +119,13 @@ */ DWORD DEBUG_SendUnloadDLLEvent( HMODULE module ) { - struct debug_event_unload_dll event; + DWORD ret = 0; + struct send_debug_event_request *req = get_req_buffer(); - event.base = (void *)module; - return DEBUG_SendEvent( UNLOAD_DLL_DEBUG_EVENT, &event, sizeof(event) ); + req->event.code = UNLOAD_DLL_DEBUG_EVENT; + req->event.info.unload_dll.base = (void *)module; + if (!server_call( REQ_SEND_DEBUG_EVENT )) ret = req->status; + return ret; } @@ -147,73 +143,72 @@ BOOL WINAPI WaitForDebugEvent( LPDEBUG_EVENT event, DWORD timeout ) { struct wait_debug_event_request *req = get_req_buffer(); - union debug_event_data *data = (union debug_event_data *)(req + 1); int i; req->timeout = timeout; if (server_call( REQ_WAIT_DEBUG_EVENT )) return FALSE; - if ((req->code < 0) || (req->code > RIP_EVENT)) - server_protocol_error( "WaitForDebugEvent: bad code %d\n", req->code ); + if ((req->event.code < 0) || (req->event.code > RIP_EVENT)) + server_protocol_error( "WaitForDebugEvent: bad code %d\n", req->event.code ); - event->dwDebugEventCode = req->code; + event->dwDebugEventCode = req->event.code; event->dwProcessId = (DWORD)req->pid; event->dwThreadId = (DWORD)req->tid; - switch(req->code) + switch(req->event.code) { case EXCEPTION_DEBUG_EVENT: - event->u.Exception.ExceptionRecord.ExceptionCode = data->exception.code; - event->u.Exception.ExceptionRecord.ExceptionFlags = data->exception.flags; - event->u.Exception.ExceptionRecord.ExceptionRecord = data->exception.record; - event->u.Exception.ExceptionRecord.ExceptionAddress = data->exception.addr; - event->u.Exception.ExceptionRecord.NumberParameters = data->exception.nb_params; - for (i = 0; i < data->exception.nb_params; i++) - event->u.Exception.ExceptionRecord.ExceptionInformation[i] = data->exception.params[i]; - event->u.Exception.dwFirstChance = data->exception.first_chance; + event->u.Exception.ExceptionRecord.ExceptionCode = req->event.info.exception.code; + event->u.Exception.ExceptionRecord.ExceptionFlags = req->event.info.exception.flags; + event->u.Exception.ExceptionRecord.ExceptionRecord = req->event.info.exception.record; + event->u.Exception.ExceptionRecord.ExceptionAddress = req->event.info.exception.addr; + event->u.Exception.ExceptionRecord.NumberParameters = req->event.info.exception.nb_params; + for (i = 0; i < req->event.info.exception.nb_params; i++) + event->u.Exception.ExceptionRecord.ExceptionInformation[i] = req->event.info.exception.params[i]; + event->u.Exception.dwFirstChance = req->event.info.exception.first_chance; break; case CREATE_THREAD_DEBUG_EVENT: - event->u.CreateThread.hThread = data->create_thread.handle; - event->u.CreateThread.lpThreadLocalBase = data->create_thread.teb; - event->u.CreateThread.lpStartAddress = data->create_thread.start; + event->u.CreateThread.hThread = req->event.info.create_thread.handle; + event->u.CreateThread.lpThreadLocalBase = req->event.info.create_thread.teb; + event->u.CreateThread.lpStartAddress = req->event.info.create_thread.start; break; case CREATE_PROCESS_DEBUG_EVENT: - event->u.CreateProcessInfo.hFile = data->create_process.file; - event->u.CreateProcessInfo.hProcess = data->create_process.process; - event->u.CreateProcessInfo.hThread = data->create_process.thread; - event->u.CreateProcessInfo.lpBaseOfImage = data->create_process.base; - event->u.CreateProcessInfo.dwDebugInfoFileOffset = data->create_process.dbg_offset; - event->u.CreateProcessInfo.nDebugInfoSize = data->create_process.dbg_size; - event->u.CreateProcessInfo.lpThreadLocalBase = data->create_process.teb; - event->u.CreateProcessInfo.lpStartAddress = data->create_process.start; - event->u.CreateProcessInfo.lpImageName = data->create_process.name; - event->u.CreateProcessInfo.fUnicode = data->create_process.unicode; - if (data->create_process.file == -1) event->u.CreateProcessInfo.hFile = 0; + event->u.CreateProcessInfo.hFile = req->event.info.create_process.file; + event->u.CreateProcessInfo.hProcess = req->event.info.create_process.process; + event->u.CreateProcessInfo.hThread = req->event.info.create_process.thread; + event->u.CreateProcessInfo.lpBaseOfImage = req->event.info.create_process.base; + event->u.CreateProcessInfo.dwDebugInfoFileOffset = req->event.info.create_process.dbg_offset; + event->u.CreateProcessInfo.nDebugInfoSize = req->event.info.create_process.dbg_size; + event->u.CreateProcessInfo.lpThreadLocalBase = req->event.info.create_process.teb; + event->u.CreateProcessInfo.lpStartAddress = req->event.info.create_process.start; + event->u.CreateProcessInfo.lpImageName = req->event.info.create_process.name; + event->u.CreateProcessInfo.fUnicode = req->event.info.create_process.unicode; + if (req->event.info.create_process.file == -1) event->u.CreateProcessInfo.hFile = 0; break; case EXIT_THREAD_DEBUG_EVENT: - event->u.ExitThread.dwExitCode = data->exit.exit_code; + event->u.ExitThread.dwExitCode = req->event.info.exit.exit_code; break; case EXIT_PROCESS_DEBUG_EVENT: - event->u.ExitProcess.dwExitCode = data->exit.exit_code; + event->u.ExitProcess.dwExitCode = req->event.info.exit.exit_code; break; case LOAD_DLL_DEBUG_EVENT: - event->u.LoadDll.hFile = data->load_dll.handle; - event->u.LoadDll.lpBaseOfDll = data->load_dll.base; - event->u.LoadDll.dwDebugInfoFileOffset = data->load_dll.dbg_offset; - event->u.LoadDll.nDebugInfoSize = data->load_dll.dbg_size; - event->u.LoadDll.lpImageName = data->load_dll.name; - event->u.LoadDll.fUnicode = data->load_dll.unicode; - if (data->load_dll.handle == -1) event->u.LoadDll.hFile = 0; + event->u.LoadDll.hFile = req->event.info.load_dll.handle; + event->u.LoadDll.lpBaseOfDll = req->event.info.load_dll.base; + event->u.LoadDll.dwDebugInfoFileOffset = req->event.info.load_dll.dbg_offset; + event->u.LoadDll.nDebugInfoSize = req->event.info.load_dll.dbg_size; + event->u.LoadDll.lpImageName = req->event.info.load_dll.name; + event->u.LoadDll.fUnicode = req->event.info.load_dll.unicode; + if (req->event.info.load_dll.handle == -1) event->u.LoadDll.hFile = 0; break; case UNLOAD_DLL_DEBUG_EVENT: - event->u.UnloadDll.lpBaseOfDll = data->unload_dll.base; + event->u.UnloadDll.lpBaseOfDll = req->event.info.unload_dll.base; break; case OUTPUT_DEBUG_STRING_EVENT: - event->u.DebugString.lpDebugStringData = data->output_string.string; - event->u.DebugString.fUnicode = data->output_string.unicode; - event->u.DebugString.nDebugStringLength = data->output_string.length; + event->u.DebugString.lpDebugStringData = req->event.info.output_string.string; + event->u.DebugString.fUnicode = req->event.info.output_string.unicode; + event->u.DebugString.nDebugStringLength = req->event.info.output_string.length; break; case RIP_EVENT: - event->u.RipInfo.dwError = data->rip_info.error; - event->u.RipInfo.dwType = data->rip_info.type; + event->u.RipInfo.dwError = req->event.info.rip_info.error; + event->u.RipInfo.dwType = req->event.info.rip_info.type; break; } return TRUE; @@ -251,11 +246,12 @@ { if (PROCESS_Current()->flags & PDB32_DEBUGGED) { - struct debug_event_output_string event; - event.string = (void *)str; - event.unicode = 0; - event.length = strlen(str) + 1; - DEBUG_SendEvent( OUTPUT_DEBUG_STRING_EVENT, &event, sizeof(event) ); + struct send_debug_event_request *req = get_req_buffer(); + req->event.code = OUTPUT_DEBUG_STRING_EVENT; + req->event.info.output_string.string = (void *)str; + req->event.info.output_string.unicode = 0; + req->event.info.output_string.length = strlen(str) + 1; + server_call( REQ_SEND_DEBUG_EVENT ); } TRACE("%s\n", str); @@ -269,11 +265,12 @@ { if (PROCESS_Current()->flags & PDB32_DEBUGGED) { - struct debug_event_output_string event; - event.string = (void *)str; - event.unicode = 1; - event.length = (lstrlenW(str) + 1) * sizeof(WCHAR); - DEBUG_SendEvent( OUTPUT_DEBUG_STRING_EVENT, &event, sizeof(event) ); + struct send_debug_event_request *req = get_req_buffer(); + req->event.code = OUTPUT_DEBUG_STRING_EVENT; + req->event.info.output_string.string = (void *)str; + req->event.info.output_string.unicode = 1; + req->event.info.output_string.length = (lstrlenW(str) + 1) * sizeof(WCHAR); + server_call( REQ_SEND_DEBUG_EVENT ); } TRACE("%s\n", debugstr_w(str));
diff --git a/scheduler/thread.c b/scheduler/thread.c index f4c3534..4038a8a 100644 --- a/scheduler/thread.c +++ b/scheduler/thread.c
@@ -516,14 +516,17 @@ * Success: TRUE * Failure: FALSE */ -BOOL WINAPI SetThreadContext( - HANDLE handle, /* [in] Handle to thread with context */ - const CONTEXT *context) /* [out] Address of context structure */ +BOOL WINAPI SetThreadContext( HANDLE handle, /* [in] Handle to thread with context */ + const CONTEXT *context ) /* [in] Address of context structure */ { - FIXME("not implemented\n" ); - return TRUE; + struct set_thread_context_request *req = get_req_buffer(); + req->handle = handle; + req->flags = context->ContextFlags; + memcpy( &req->context, context, sizeof(*context) ); + return !server_call( REQ_SET_THREAD_CONTEXT ); } + /*********************************************************************** * GetThreadContext [KERNEL32.294] Retrieves context of thread. * @@ -531,25 +534,15 @@ * Success: TRUE * Failure: FALSE */ -BOOL WINAPI GetThreadContext( - HANDLE handle, /* [in] Handle to thread with context */ - CONTEXT *context) /* [out] Address of context structure */ +BOOL WINAPI GetThreadContext( HANDLE handle, /* [in] Handle to thread with context */ + CONTEXT *context ) /* [out] Address of context structure */ { -#ifdef __i386__ - WORD cs, ds; - - FIXME("returning dummy info\n" ); - - /* make up some plausible values for segment registers */ - GET_CS(cs); - GET_DS(ds); - context->SegCs = cs; - context->SegDs = ds; - context->SegEs = ds; - context->SegGs = ds; - context->SegSs = ds; - context->SegFs = ds; -#endif + struct get_thread_context_request *req = get_req_buffer(); + req->handle = handle; + req->flags = context->ContextFlags; + memcpy( &req->context, context, sizeof(*context) ); + if (server_call( REQ_GET_THREAD_CONTEXT )) return FALSE; + memcpy( context, &req->context, sizeof(*context) ); return TRUE; }
diff --git a/server/Makefile.in b/server/Makefile.in index b4ec97a..e2bad9f 100644 --- a/server/Makefile.in +++ b/server/Makefile.in
@@ -8,6 +8,7 @@ C_SRCS = \ change.c \ console.c \ + context_i386.c \ debugger.c \ device.c \ event.c \
diff --git a/server/context_i386.c b/server/context_i386.c new file mode 100644 index 0000000..129577c --- /dev/null +++ b/server/context_i386.c
@@ -0,0 +1,264 @@ +/* + * i386 register context support + * + * Copyright (C) 1999 Alexandre Julliard + */ + +#include "config.h" + +#ifdef __i386__ + +#include <assert.h> +#include <errno.h> +#include <sys/ptrace.h> +#include <sys/user.h> + +#include "winbase.h" +#include "winerror.h" + +#include "thread.h" +#include "request.h" + + +#ifndef PTRACE_PEEKUSER +#define PTRACE_PEEKUSER PT_READ_U +#endif +#ifndef PTRACE_POKEUSER +#define PTRACE_POKEUSER PT_WRITE_U +#endif +#ifndef PTRACE_GETREGS +#define PTRACE_GETREGS PT_GETREGS +#endif +#ifndef PTRACE_GETFPREGS +#define PTRACE_GETFPREGS PT_GETFPREGS +#endif + +#ifdef linux + +/* debug register offset in struct user */ +#define DR_OFFSET(dr) ((int)((((struct user *)0)->u_debugreg) + (dr))) + +/* retrieve a debug register */ +static inline int get_debug_reg( int pid, int num, DWORD *data ) +{ + int res = ptrace( PTRACE_PEEKUSER, pid, DR_OFFSET(num), 0 ); + if ((res == -1) && errno) + { + file_set_error(); + return -1; + } + *data = res; + return 0; +} + +/* retrieve a thread context */ +static void get_thread_context( struct thread *thread, unsigned int flags, CONTEXT *context ) +{ + int pid = thread->unix_pid; + if (flags & CONTEXT_FULL) + { + struct user_regs_struct regs; + if (ptrace( PTRACE_GETREGS, pid, 0, ®s ) == -1) goto error; + if (flags & CONTEXT_INTEGER) + { + context->Eax = regs.eax; + context->Ebx = regs.ebx; + context->Ecx = regs.ecx; + context->Edx = regs.edx; + context->Esi = regs.esi; + context->Edi = regs.edi; + } + if (flags & CONTEXT_CONTROL) + { + context->Ebp = regs.ebp; + context->Esp = regs.esp; + context->Eip = regs.eip; + context->SegCs = regs.xcs & 0xffff; + context->SegSs = regs.xss & 0xffff; + context->EFlags = regs.eflags; + } + if (flags & CONTEXT_SEGMENTS) + { + context->SegDs = regs.xds & 0xffff; + context->SegEs = regs.xes & 0xffff; + context->SegFs = regs.xfs & 0xffff; + context->SegGs = regs.xgs & 0xffff; + } + } + if (flags & CONTEXT_DEBUG_REGISTERS) + { + if (get_debug_reg( pid, 0, &context->Dr0 ) == -1) goto error; + if (get_debug_reg( pid, 1, &context->Dr1 ) == -1) goto error; + if (get_debug_reg( pid, 2, &context->Dr2 ) == -1) goto error; + if (get_debug_reg( pid, 3, &context->Dr3 ) == -1) goto error; + if (get_debug_reg( pid, 6, &context->Dr6 ) == -1) goto error; + if (get_debug_reg( pid, 7, &context->Dr7 ) == -1) goto error; + } + if (flags & CONTEXT_FLOATING_POINT) + { + /* we can use context->FloatSave directly as it is using the */ + /* correct structure (the same as fsave/frstor) */ + if (ptrace( PTRACE_GETFPREGS, pid, 0, &context->FloatSave ) == -1) goto error; + context->FloatSave.Cr0NpxState = 0; /* FIXME */ + } + return; + error: + file_set_error(); +} + + +/* set a thread context */ +static void set_thread_context( struct thread *thread, unsigned int flags, CONTEXT *context ) +{ + int pid = thread->unix_pid; + if (flags & CONTEXT_FULL) + { + struct user_regs_struct regs; + if ((flags & CONTEXT_FULL) != CONTEXT_FULL) /* need to preserve some registers */ + { + if (ptrace( PTRACE_GETREGS, pid, 0, ®s ) == -1) goto error; + } + if (flags & CONTEXT_INTEGER) + { + regs.eax = context->Eax; + regs.ebx = context->Ebx; + regs.ecx = context->Ecx; + regs.edx = context->Edx; + regs.esi = context->Esi; + regs.edi = context->Edi; + } + if (flags & CONTEXT_CONTROL) + { + regs.ebp = context->Ebp; + regs.esp = context->Esp; + regs.eip = context->Eip; + regs.xcs = context->SegCs; + regs.xss = context->SegSs; + regs.eflags = context->EFlags; + } + if (flags & CONTEXT_SEGMENTS) + { + regs.xds = context->SegDs; + regs.xes = context->SegEs; + regs.xfs = context->SegFs; + regs.xgs = context->SegGs; + } + if (ptrace( PTRACE_SETREGS, pid, 0, ®s ) == -1) goto error; + } + if (flags & CONTEXT_DEBUG_REGISTERS) + { + if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(0), context->Dr0 ) == -1) goto error; + if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(1), context->Dr1 ) == -1) goto error; + if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(2), context->Dr2 ) == -1) goto error; + if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(3), context->Dr3 ) == -1) goto error; + if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(6), context->Dr6 ) == -1) goto error; + if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(7), context->Dr7 ) == -1) goto error; + } + if (flags & CONTEXT_FLOATING_POINT) + { + /* we can use context->FloatSave directly as it is using the */ + /* correct structure (the same as fsave/frstor) */ + if (ptrace( PTRACE_SETFPREGS, pid, 0, &context->FloatSave ) == -1) goto error; + context->FloatSave.Cr0NpxState = 0; /* FIXME */ + } + return; + error: + file_set_error(); +} + +#else /* linux */ +#error You must implement get/set_thread_context for your platform +#endif /* linux */ + + +/* copy a context structure according to the flags */ +static void copy_context( CONTEXT *to, CONTEXT *from, int flags ) +{ + if (flags & CONTEXT_CONTROL) + { + to->Ebp = from->Ebp; + to->Eip = from->Eip; + to->Esp = from->Esp; + to->SegCs = from->SegCs; + to->SegSs = from->SegSs; + to->EFlags = from->EFlags; + } + if (flags & CONTEXT_INTEGER) + { + to->Eax = from->Eax; + to->Ebx = from->Ebx; + to->Ecx = from->Ecx; + to->Edx = from->Edx; + to->Esi = from->Esi; + to->Edi = from->Edi; + } + if (flags & CONTEXT_SEGMENTS) + { + to->SegDs = from->SegDs; + to->SegEs = from->SegEs; + to->SegFs = from->SegFs; + to->SegGs = from->SegGs; + } + if (flags & CONTEXT_DEBUG_REGISTERS) + { + to->Dr0 = from->Dr0; + to->Dr1 = from->Dr1; + to->Dr2 = from->Dr2; + to->Dr3 = from->Dr3; + to->Dr6 = from->Dr6; + to->Dr7 = from->Dr7; + } + if (flags & CONTEXT_FLOATING_POINT) + { + to->FloatSave = from->FloatSave; + } +} + +/* retrieve the current context of a thread */ +DECL_HANDLER(get_thread_context) +{ + struct thread *thread; + CONTEXT *context; + + if ((thread = get_thread_from_handle( req->handle, THREAD_GET_CONTEXT ))) + { + if ((context = get_debug_context( thread ))) /* thread is inside an exception event */ + { + copy_context( &req->context, context, req->flags ); + } + else + { + suspend_thread( thread, 0 ); + if (thread->attached) get_thread_context( thread, req->flags, &req->context ); + else set_error( ERROR_ACCESS_DENIED ); + resume_thread( thread ); + } + release_object( thread ); + } +} + + +/* set the current context of a thread */ +DECL_HANDLER(set_thread_context) +{ + struct thread *thread; + CONTEXT *context; + + if ((thread = get_thread_from_handle( req->handle, THREAD_SET_CONTEXT ))) + { + if ((context = get_debug_context( thread ))) /* thread is inside an exception event */ + { + copy_context( context, &req->context, req->flags ); + } + else + { + suspend_thread( thread, 0 ); + if (thread->attached) set_thread_context( thread, req->flags, &req->context ); + else set_error( ERROR_ACCESS_DENIED ); + resume_thread( thread ); + } + release_object( thread ); + } +} + +#endif /* __i386__ */
diff --git a/server/debugger.c b/server/debugger.c index 6e370e0..7cbf183 100644 --- a/server/debugger.c +++ b/server/debugger.c
@@ -28,8 +28,7 @@ struct thread *debugger; /* debugger thread receiving the event */ enum debug_event_state state; /* event state */ int status; /* continuation status */ - int code; /* event code */ - union debug_event_data data; /* event data */ + debug_event_t data; /* event data */ }; /* debug context */ @@ -84,21 +83,6 @@ debug_ctx_destroy /* destroy */ }; -/* size of the event data */ -static const int event_sizes[] = -{ - 0, - sizeof(struct debug_event_exception), /* EXCEPTION_DEBUG_EVENT */ - sizeof(struct debug_event_create_thread), /* CREATE_THREAD_DEBUG_EVENT */ - sizeof(struct debug_event_create_process), /* CREATE_PROCESS_DEBUG_EVENT */ - sizeof(struct debug_event_exit), /* EXIT_THREAD_DEBUG_EVENT */ - sizeof(struct debug_event_exit), /* EXIT_PROCESS_DEBUG_EVENT */ - sizeof(struct debug_event_load_dll), /* LOAD_DLL_DEBUG_EVENT */ - sizeof(struct debug_event_unload_dll), /* UNLOAD_DLL_DEBUG_EVENT */ - sizeof(struct debug_event_output_string), /* OUTPUT_DEBUG_STRING_EVENT */ - sizeof(struct debug_event_rip_info) /* RIP_EVENT */ -}; - /* initialise the fields that do not need to be filled by the client */ static int fill_debug_event( struct thread *debugger, struct thread *thread, @@ -107,45 +91,45 @@ int handle; /* some events need special handling */ - switch(event->code) + switch(event->data.code) { case CREATE_THREAD_DEBUG_EVENT: - if ((event->data.create_thread.handle = alloc_handle( debugger->process, thread, + if ((event->data.info.create_thread.handle = alloc_handle( debugger->process, thread, /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */ THREAD_ALL_ACCESS, FALSE )) == -1) return 0; break; case CREATE_PROCESS_DEBUG_EVENT: - if ((handle = event->data.create_process.file) != -1) + if ((handle = event->data.info.create_process.file) != -1) { if ((handle = duplicate_handle( thread->process, handle, debugger->process, GENERIC_READ, FALSE, 0 )) == -1) return 0; - event->data.create_process.file = handle; + event->data.info.create_process.file = handle; } - if ((event->data.create_process.process = alloc_handle( debugger->process, thread->process, + if ((event->data.info.create_process.process = alloc_handle( debugger->process, thread->process, /* documented: PROCESS_VM_READ | PROCESS_VM_WRITE */ PROCESS_ALL_ACCESS, FALSE )) == -1) { if (handle != -1) close_handle( debugger->process, handle ); return 0; } - if ((event->data.create_process.thread = alloc_handle( debugger->process, thread, + if ((event->data.info.create_process.thread = alloc_handle( debugger->process, thread, /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */ THREAD_ALL_ACCESS, FALSE )) == -1) { if (handle != -1) close_handle( debugger->process, handle ); - close_handle( debugger->process, event->data.create_process.process ); + close_handle( debugger->process, event->data.info.create_process.process ); return 0; } break; case LOAD_DLL_DEBUG_EVENT: - if ((handle = event->data.load_dll.handle) != -1) + if ((handle = event->data.info.load_dll.handle) != -1) { if ((handle = duplicate_handle( thread->process, handle, debugger->process, GENERIC_READ, FALSE, 0 )) == -1) return 0; - event->data.load_dll.handle = handle; + event->data.info.load_dll.handle = handle; } break; } @@ -196,14 +180,14 @@ event->state = EVENT_SENT; debug_ctx->to_send = event->next; - req->code = event->code; + req->event.code = event->data.code; req->pid = event->sender->process; req->tid = event->sender; - memcpy( req + 1, &event->data, event_sizes[event->code] ); + memcpy( &req->event, &event->data, sizeof(req->event) ); } else /* timeout or error */ { - req->code = 0; + req->event.code = 0; req->pid = 0; req->tid = 0; thread->error = signaled; @@ -219,8 +203,10 @@ req->status = event->status; /* copy the context into the reply */ - if (event->code == EXCEPTION_DEBUG_EVENT) - memcpy( req + 1, &event->data, event_sizes[event->code] ); + if (event->data.code == EXCEPTION_DEBUG_EVENT) + memcpy( &req->event.info.exception.context, + &event->data.info.exception.context, + sizeof(req->event.info.exception.context) ); } static void debug_event_dump( struct object *obj, int verbose ) @@ -228,7 +214,7 @@ struct debug_event *debug_event = (struct debug_event *)obj; assert( obj->ops == &debug_event_ops ); fprintf( stderr, "Debug event sender=%p code=%d state=%d\n", - debug_event->sender, debug_event->code, debug_event->state ); + debug_event->sender, debug_event->data.code, debug_event->state ); } static int debug_event_signaled( struct object *obj, struct thread *thread ) @@ -252,20 +238,20 @@ if (event->state == EVENT_QUEUED) { struct process *debugger = event->debugger->process; - switch(event->code) + switch(event->data.code) { case CREATE_THREAD_DEBUG_EVENT: - close_handle( debugger, event->data.create_thread.handle ); + close_handle( debugger, event->data.info.create_thread.handle ); break; case CREATE_PROCESS_DEBUG_EVENT: - if (event->data.create_process.file != -1) - close_handle( debugger, event->data.create_process.file ); - close_handle( debugger, event->data.create_process.thread ); - close_handle( debugger, event->data.create_process.process ); + if (event->data.info.create_process.file != -1) + close_handle( debugger, event->data.info.create_process.file ); + close_handle( debugger, event->data.info.create_process.thread ); + close_handle( debugger, event->data.info.create_process.process ); break; case LOAD_DLL_DEBUG_EVENT: - if (event->data.load_dll.handle != -1) - close_handle( debugger, event->data.load_dll.handle ); + if (event->data.info.load_dll.handle != -1) + close_handle( debugger, event->data.info.load_dll.handle ); break; } } @@ -346,7 +332,7 @@ /* queue a debug event for a debugger */ static struct debug_event *queue_debug_event( struct thread *debugger, struct thread *thread, - int code, void *data ) + debug_event_t *data ) { struct debug_ctx *debug_ctx = debugger->debug_ctx; struct debug_event *event; @@ -360,14 +346,13 @@ event->next = NULL; event->prev = NULL; event->state = EVENT_QUEUED; - event->code = code; event->sender = (struct thread *)grab_object( thread ); event->debugger = (struct thread *)grab_object( debugger ); - memcpy( &event->data, data, event_sizes[code] ); + memcpy( &event->data, data, sizeof(event->data) ); if (!fill_debug_event( debugger, thread, event )) { - event->code = -1; /* make sure we don't attempt to close handles */ + event->data.code = -1; /* make sure we don't attempt to close handles */ release_object( event ); return NULL; } @@ -377,6 +362,22 @@ return event; } +/* return a pointer to the context in case the thread is inside an exception event */ +CONTEXT *get_debug_context( struct thread *thread ) +{ + struct debug_event *event; + struct thread *debugger = thread->process->debugger; + + if (!debugger) return NULL; /* not being debugged */ + assert( debugger->debug_ctx ); + + /* find the exception event in the debugger's queue */ + for (event = debugger->debug_ctx->event_head; event; event = event->next) + if (event->sender == thread && (event->data.code == EXCEPTION_DEBUG_EVENT)) + return &event->data.info.exception.context; + return NULL; +} + /* attach a process to a debugger thread */ int debugger_attach( struct process *process, struct thread *debugger ) { @@ -417,13 +418,12 @@ if (debugger) /* being debugged -> send an event to the debugger */ { struct debug_event *event; - struct debug_event_exit exit; - exit.exit_code = exit_code; - if (thread->process->running_threads == 1) - /* this is the last thread, send an exit process event */ - event = queue_debug_event( debugger, thread, EXIT_PROCESS_DEBUG_EVENT, &exit ); - else - event = queue_debug_event( debugger, thread, EXIT_THREAD_DEBUG_EVENT, &exit ); + debug_event_t exit; + exit.info.exit.exit_code = exit_code; + /* if this is the last thread, send an exit process event */ + exit.code = ((thread->process->running_threads == 1) ? + EXIT_PROCESS_DEBUG_EVENT : EXIT_THREAD_DEBUG_EVENT); + event = queue_debug_event( debugger, thread, &exit ); if (event) release_object( event ); } @@ -441,9 +441,9 @@ { if (!wait_for_debug_event( req->timeout )) { - req->code = 0; - req->pid = NULL; - req->tid = NULL; + req->event.code = 0; + req->pid = NULL; + req->tid = NULL; } } @@ -481,13 +481,13 @@ struct thread *debugger = current->process->debugger; struct debug_event *event; - if ((req->code <= 0) || (req->code > RIP_EVENT)) + if ((req->event.code <= 0) || (req->event.code > RIP_EVENT)) { - fatal_protocol_error( current, "send_debug_event: bad code %d\n", req->code ); + fatal_protocol_error( current, "send_debug_event: bad code %d\n", req->event.code ); return; } req->status = 0; - if (debugger && ((event = queue_debug_event( debugger, current, req->code, req + 1 )))) + if (debugger && ((event = queue_debug_event( debugger, current, &req->event )))) { /* wait for continue_debug_event */ struct object *obj = &event->obj;
diff --git a/server/object.h b/server/object.h index 5825dce..fb874f7 100644 --- a/server/object.h +++ b/server/object.h
@@ -155,6 +155,7 @@ extern int debugger_attach( struct process *process, struct thread *debugger ); extern void debug_exit_thread( struct thread *thread, int exit_code ); +extern CONTEXT *get_debug_context( struct thread *thread ); /* mapping functions */
diff --git a/server/request.h b/server/request.h index da50d44..80ad9aa 100644 --- a/server/request.h +++ b/server/request.h
@@ -157,6 +157,8 @@ DECL_HANDLER(open_timer); DECL_HANDLER(set_timer); DECL_HANDLER(cancel_timer); +DECL_HANDLER(get_thread_context); +DECL_HANDLER(set_thread_context); #ifdef WANT_REQUEST_HANDLERS @@ -254,6 +256,8 @@ { (void(*)())req_open_timer, sizeof(struct open_timer_request) }, { (void(*)())req_set_timer, sizeof(struct set_timer_request) }, { (void(*)())req_cancel_timer, sizeof(struct cancel_timer_request) }, + { (void(*)())req_get_thread_context, sizeof(struct get_thread_context_request) }, + { (void(*)())req_set_thread_context, sizeof(struct set_thread_context_request) }, }; #endif /* WANT_REQUEST_HANDLERS */
diff --git a/server/trace.c b/server/trace.c index 35fb9e7..7fc5eb6 100644 --- a/server/trace.c +++ b/server/trace.c
@@ -9,6 +9,7 @@ #include <sys/types.h> #include <sys/uio.h> #include "winsock2.h" +#include "winnt.h" #include "request.h" #include "unicode.h" @@ -26,6 +27,17 @@ fputc( '}', stderr ); } +static void dump_uints( const int *ptr, int len ) +{ + fputc( '{', stderr ); + while (len) + { + fprintf( stderr, "%08x", *ptr++ ); + if (--len) fputc( ',', stderr ); + } + fputc( '}', stderr ); +} + static void dump_bytes( const unsigned char *ptr, int len ) { fputc( '{', stderr ); @@ -44,15 +56,103 @@ fputc( '\"', stderr ); } +static void dump_path_t( const path_t *path ) +{ + dump_unicode_string( *path ); +} + +static void dump_context( const CONTEXT *context ) +{ +#ifdef __i386__ + fprintf( stderr, "{flags=%08lx,eax=%08lx,ebx=%08lx,ecx=%08lx,edx=%08lx,esi=%08lx,edi=%08lx," + "ebp=%08lx,eip=%08lx,esp=%08lx,eflags=%08lx,cs=%04lx,ds=%04lx,es=%04lx," + "fs=%04lx,gs=%04lx,dr0=%08lx,dr1=%08lx,dr2=%08lx,dr3=%08lx,dr6=%08lx,dr7=%08lx,", + context->ContextFlags, context->Eax, context->Ebx, context->Ecx, context->Edx, + context->Esi, context->Edi, context->Ebp, context->Eip, context->Esp, context->EFlags, + context->SegCs, context->SegDs, context->SegEs, context->SegFs, context->SegGs, + context->Dr0, context->Dr1, context->Dr2, context->Dr3, context->Dr6, context->Dr7 ); + fprintf( stderr, "float=" ); + dump_uints( (int *)&context->FloatSave, sizeof(context->FloatSave) / sizeof(int) ); + fprintf( stderr, "}" ); +#else + dump_uints( (int *)context, sizeof(*context) / sizeof(int) ); +#endif +} + +static void dump_debug_event_t( const debug_event_t *event ) +{ + int i; + switch(event->code) + { + case EXCEPTION_DEBUG_EVENT: + fprintf( stderr, "{exception,code=%x,flags=%x,rec=%p,addr=%p,params={", + event->info.exception.code, event->info.exception.flags, + event->info.exception.record, event->info.exception.addr ); + for (i = 0; i < event->info.exception.nb_params; i++) + { + if (i) fputc( ',', stderr ); + fprintf( stderr, "%x", event->info.exception.params[i] ); + } + fprintf( stderr, "},first_chance=%d,context=", event->info.exception.first_chance ); + dump_context( &event->info.exception.context ); + fputc( '}', stderr ); + break; + case CREATE_THREAD_DEBUG_EVENT: + fprintf( stderr, "{create_thread,thread=%d,teb=%p,start=%p}", + event->info.create_thread.handle, event->info.create_thread.teb, + event->info.create_thread.start ); + break; + case CREATE_PROCESS_DEBUG_EVENT: + fprintf( stderr, "{create_process,file=%d,process=%d,thread=%d,base=%p,offset=%d," + "size=%d,teb=%p,start=%p,name=%p,unicode=%d}", + event->info.create_process.file, event->info.create_process.process, + event->info.create_process.thread, event->info.create_process.base, + event->info.create_process.dbg_offset, event->info.create_process.dbg_size, + event->info.create_process.teb, event->info.create_process.start, + event->info.create_process.name, event->info.create_process.unicode ); + break; + case EXIT_THREAD_DEBUG_EVENT: + fprintf( stderr, "{exit_thread,code=%d}", event->info.exit.exit_code ); + break; + case EXIT_PROCESS_DEBUG_EVENT: + fprintf( stderr, "{exit_process,code=%d}", event->info.exit.exit_code ); + break; + case LOAD_DLL_DEBUG_EVENT: + fprintf( stderr, "{load_dll,file=%d,base=%p,offset=%d,size=%d,name=%p,unicode=%d}", + event->info.load_dll.handle, event->info.load_dll.base, + event->info.load_dll.dbg_offset, event->info.load_dll.dbg_size, + event->info.load_dll.name, event->info.load_dll.unicode ); + break; + case UNLOAD_DLL_DEBUG_EVENT: + fprintf( stderr, "{unload_dll,base=%p}", event->info.unload_dll.base ); + break; + case OUTPUT_DEBUG_STRING_EVENT: + fprintf( stderr, "{output_string,data=%p,unicode=%d,len=%d}", + event->info.output_string.string, event->info.output_string.unicode, + event->info.output_string.length ); + break; + case RIP_EVENT: + fprintf( stderr, "{rip,err=%d,type=%d}", + event->info.rip_info.error, event->info.rip_info.type ); + break; + case 0: /* zero is the code returned on timeouts */ + fprintf( stderr, "{}" ); + break; + default: + fprintf( stderr, "{code=??? (%d)}", event->code ); + break; + } +} + /* dumping for functions for requests that have a variable part */ -static void dump_varargs_select_request( struct select_request *req ) +static void dump_varargs_select_request( const struct select_request *req ) { dump_ints( req->handles, req->count ); } -static void dump_varargs_get_apcs_reply( struct get_apcs_request *req ) +static void dump_varargs_get_apcs_reply( const struct get_apcs_request *req ) { int i; for (i = 0; i < 2 * req->count; i++) @@ -60,34 +160,34 @@ fprintf( stderr, "}" ); } -static void dump_varargs_get_socket_event_reply( struct get_socket_event_request *req ) +static void dump_varargs_get_socket_event_reply( const struct get_socket_event_request *req ) { dump_ints( req->errors, FD_MAX_EVENTS ); } -static void dump_varargs_read_process_memory_reply( struct read_process_memory_request *req ) +static void dump_varargs_read_process_memory_reply( const struct read_process_memory_request *req ) { int count = MIN( req->len, get_req_size( req->data, sizeof(int) ) ); dump_bytes( (unsigned char *)req->data, count * sizeof(int) ); } -static void dump_varargs_write_process_memory_request( struct write_process_memory_request *req ) +static void dump_varargs_write_process_memory_request( const struct write_process_memory_request *req ) { int count = MIN( req->len, get_req_size( req->data, sizeof(int) ) ); dump_bytes( (unsigned char *)req->data, count * sizeof(int) ); } -static void dump_varargs_set_key_value_request( struct set_key_value_request *req ) +static void dump_varargs_set_key_value_request( const struct set_key_value_request *req ) { dump_bytes( req->data, req->len ); } -static void dump_varargs_get_key_value_reply( struct get_key_value_request *req ) +static void dump_varargs_get_key_value_reply( const struct get_key_value_request *req ) { dump_bytes( req->data, req->len ); } -static void dump_varargs_enum_key_value_reply( struct enum_key_value_request *req ) +static void dump_varargs_enum_key_value_reply( const struct enum_key_value_request *req ) { dump_bytes( req->data, req->len ); } @@ -97,7 +197,7 @@ /* Everything below this line is generated automatically by tools/make_requests */ /* ### make_requests begin ### */ -static void dump_new_process_request( struct new_process_request *req ) +static void dump_new_process_request( const struct new_process_request *req ) { fprintf( stderr, " inherit=%d,", req->inherit ); fprintf( stderr, " inherit_all=%d,", req->inherit_all ); @@ -112,35 +212,35 @@ fprintf( stderr, " cmdline=\"%s\"", req->cmdline ); } -static void dump_new_process_reply( struct new_process_request *req ) +static void dump_new_process_reply( const struct new_process_request *req ) { fprintf( stderr, " pid=%p,", req->pid ); fprintf( stderr, " handle=%d", req->handle ); } -static void dump_new_thread_request( struct new_thread_request *req ) +static void dump_new_thread_request( const struct new_thread_request *req ) { fprintf( stderr, " pid=%p,", req->pid ); fprintf( stderr, " suspend=%d,", req->suspend ); fprintf( stderr, " inherit=%d", req->inherit ); } -static void dump_new_thread_reply( struct new_thread_request *req ) +static void dump_new_thread_reply( const struct new_thread_request *req ) { fprintf( stderr, " tid=%p,", req->tid ); fprintf( stderr, " handle=%d", req->handle ); } -static void dump_set_debug_request( struct set_debug_request *req ) +static void dump_set_debug_request( const struct set_debug_request *req ) { fprintf( stderr, " level=%d", req->level ); } -static void dump_init_process_request( struct init_process_request *req ) +static void dump_init_process_request( const struct init_process_request *req ) { } -static void dump_init_process_reply( struct init_process_request *req ) +static void dump_init_process_reply( const struct init_process_request *req ) { fprintf( stderr, " start_flags=%d,", req->start_flags ); fprintf( stderr, " hstdin=%d,", req->hstdin ); @@ -151,46 +251,46 @@ fprintf( stderr, " cmdline=\"%s\"", req->cmdline ); } -static void dump_init_process_done_request( struct init_process_done_request *req ) +static void dump_init_process_done_request( const struct init_process_done_request *req ) { fprintf( stderr, " dummy=%d", req->dummy ); } -static void dump_init_thread_request( struct init_thread_request *req ) +static void dump_init_thread_request( const struct init_thread_request *req ) { fprintf( stderr, " unix_pid=%d,", req->unix_pid ); fprintf( stderr, " teb=%p", req->teb ); } -static void dump_init_thread_reply( struct init_thread_request *req ) +static void dump_init_thread_reply( const struct init_thread_request *req ) { fprintf( stderr, " pid=%p,", req->pid ); fprintf( stderr, " tid=%p", req->tid ); } -static void dump_get_thread_buffer_request( struct get_thread_buffer_request *req ) +static void dump_get_thread_buffer_request( const struct get_thread_buffer_request *req ) { fprintf( stderr, " dummy=%d", req->dummy ); } -static void dump_terminate_process_request( struct terminate_process_request *req ) +static void dump_terminate_process_request( const struct terminate_process_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " exit_code=%d", req->exit_code ); } -static void dump_terminate_thread_request( struct terminate_thread_request *req ) +static void dump_terminate_thread_request( const struct terminate_thread_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " exit_code=%d", req->exit_code ); } -static void dump_get_process_info_request( struct get_process_info_request *req ) +static void dump_get_process_info_request( const struct get_process_info_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_get_process_info_reply( struct get_process_info_request *req ) +static void dump_get_process_info_reply( const struct get_process_info_request *req ) { fprintf( stderr, " pid=%p,", req->pid ); fprintf( stderr, " exit_code=%d,", req->exit_code ); @@ -199,7 +299,7 @@ fprintf( stderr, " system_affinity=%d", req->system_affinity ); } -static void dump_set_process_info_request( struct set_process_info_request *req ) +static void dump_set_process_info_request( const struct set_process_info_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " mask=%d,", req->mask ); @@ -207,19 +307,19 @@ fprintf( stderr, " affinity=%d", req->affinity ); } -static void dump_get_thread_info_request( struct get_thread_info_request *req ) +static void dump_get_thread_info_request( const struct get_thread_info_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_get_thread_info_reply( struct get_thread_info_request *req ) +static void dump_get_thread_info_reply( const struct get_thread_info_request *req ) { fprintf( stderr, " tid=%p,", req->tid ); fprintf( stderr, " exit_code=%d,", req->exit_code ); fprintf( stderr, " priority=%d", req->priority ); } -static void dump_set_thread_info_request( struct set_thread_info_request *req ) +static void dump_set_thread_info_request( const struct set_thread_info_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " mask=%d,", req->mask ); @@ -227,72 +327,72 @@ fprintf( stderr, " affinity=%d", req->affinity ); } -static void dump_suspend_thread_request( struct suspend_thread_request *req ) +static void dump_suspend_thread_request( const struct suspend_thread_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_suspend_thread_reply( struct suspend_thread_request *req ) +static void dump_suspend_thread_reply( const struct suspend_thread_request *req ) { fprintf( stderr, " count=%d", req->count ); } -static void dump_resume_thread_request( struct resume_thread_request *req ) +static void dump_resume_thread_request( const struct resume_thread_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_resume_thread_reply( struct resume_thread_request *req ) +static void dump_resume_thread_reply( const struct resume_thread_request *req ) { fprintf( stderr, " count=%d", req->count ); } -static void dump_debugger_request( struct debugger_request *req ) +static void dump_debugger_request( const struct debugger_request *req ) { fprintf( stderr, " op=%d", req->op ); } -static void dump_queue_apc_request( struct queue_apc_request *req ) +static void dump_queue_apc_request( const struct queue_apc_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " func=%p,", req->func ); fprintf( stderr, " param=%p", req->param ); } -static void dump_get_apcs_request( struct get_apcs_request *req ) +static void dump_get_apcs_request( const struct get_apcs_request *req ) { } -static void dump_get_apcs_reply( struct get_apcs_request *req ) +static void dump_get_apcs_reply( const struct get_apcs_request *req ) { fprintf( stderr, " count=%d,", req->count ); fprintf( stderr, " apcs=" ); dump_varargs_get_apcs_reply( req ); } -static void dump_close_handle_request( struct close_handle_request *req ) +static void dump_close_handle_request( const struct close_handle_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_get_handle_info_request( struct get_handle_info_request *req ) +static void dump_get_handle_info_request( const struct get_handle_info_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_get_handle_info_reply( struct get_handle_info_request *req ) +static void dump_get_handle_info_reply( const struct get_handle_info_request *req ) { fprintf( stderr, " flags=%d", req->flags ); } -static void dump_set_handle_info_request( struct set_handle_info_request *req ) +static void dump_set_handle_info_request( const struct set_handle_info_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " flags=%d,", req->flags ); fprintf( stderr, " mask=%d", req->mask ); } -static void dump_dup_handle_request( struct dup_handle_request *req ) +static void dump_dup_handle_request( const struct dup_handle_request *req ) { fprintf( stderr, " src_process=%d,", req->src_process ); fprintf( stderr, " src_handle=%d,", req->src_handle ); @@ -302,24 +402,24 @@ fprintf( stderr, " options=%d", req->options ); } -static void dump_dup_handle_reply( struct dup_handle_request *req ) +static void dump_dup_handle_reply( const struct dup_handle_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_open_process_request( struct open_process_request *req ) +static void dump_open_process_request( const struct open_process_request *req ) { fprintf( stderr, " pid=%p,", req->pid ); fprintf( stderr, " access=%08x,", req->access ); fprintf( stderr, " inherit=%d", req->inherit ); } -static void dump_open_process_reply( struct open_process_request *req ) +static void dump_open_process_reply( const struct open_process_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_select_request( struct select_request *req ) +static void dump_select_request( const struct select_request *req ) { fprintf( stderr, " count=%d,", req->count ); fprintf( stderr, " flags=%d,", req->flags ); @@ -328,12 +428,12 @@ dump_varargs_select_request( req ); } -static void dump_select_reply( struct select_request *req ) +static void dump_select_reply( const struct select_request *req ) { fprintf( stderr, " signaled=%d", req->signaled ); } -static void dump_create_event_request( struct create_event_request *req ) +static void dump_create_event_request( const struct create_event_request *req ) { fprintf( stderr, " manual_reset=%d,", req->manual_reset ); fprintf( stderr, " initial_state=%d,", req->initial_state ); @@ -342,18 +442,18 @@ dump_unicode_string( req->name ); } -static void dump_create_event_reply( struct create_event_request *req ) +static void dump_create_event_reply( const struct create_event_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_event_op_request( struct event_op_request *req ) +static void dump_event_op_request( const struct event_op_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " op=%d", req->op ); } -static void dump_open_event_request( struct open_event_request *req ) +static void dump_open_event_request( const struct open_event_request *req ) { fprintf( stderr, " access=%08x,", req->access ); fprintf( stderr, " inherit=%d,", req->inherit ); @@ -361,12 +461,12 @@ dump_unicode_string( req->name ); } -static void dump_open_event_reply( struct open_event_request *req ) +static void dump_open_event_reply( const struct open_event_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_create_mutex_request( struct create_mutex_request *req ) +static void dump_create_mutex_request( const struct create_mutex_request *req ) { fprintf( stderr, " owned=%d,", req->owned ); fprintf( stderr, " inherit=%d,", req->inherit ); @@ -374,17 +474,17 @@ dump_unicode_string( req->name ); } -static void dump_create_mutex_reply( struct create_mutex_request *req ) +static void dump_create_mutex_reply( const struct create_mutex_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_release_mutex_request( struct release_mutex_request *req ) +static void dump_release_mutex_request( const struct release_mutex_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_open_mutex_request( struct open_mutex_request *req ) +static void dump_open_mutex_request( const struct open_mutex_request *req ) { fprintf( stderr, " access=%08x,", req->access ); fprintf( stderr, " inherit=%d,", req->inherit ); @@ -392,12 +492,12 @@ dump_unicode_string( req->name ); } -static void dump_open_mutex_reply( struct open_mutex_request *req ) +static void dump_open_mutex_reply( const struct open_mutex_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_create_semaphore_request( struct create_semaphore_request *req ) +static void dump_create_semaphore_request( const struct create_semaphore_request *req ) { fprintf( stderr, " initial=%08x,", req->initial ); fprintf( stderr, " max=%08x,", req->max ); @@ -406,23 +506,23 @@ dump_unicode_string( req->name ); } -static void dump_create_semaphore_reply( struct create_semaphore_request *req ) +static void dump_create_semaphore_reply( const struct create_semaphore_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_release_semaphore_request( struct release_semaphore_request *req ) +static void dump_release_semaphore_request( const struct release_semaphore_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " count=%08x", req->count ); } -static void dump_release_semaphore_reply( struct release_semaphore_request *req ) +static void dump_release_semaphore_reply( const struct release_semaphore_request *req ) { fprintf( stderr, " prev_count=%08x", req->prev_count ); } -static void dump_open_semaphore_request( struct open_semaphore_request *req ) +static void dump_open_semaphore_request( const struct open_semaphore_request *req ) { fprintf( stderr, " access=%08x,", req->access ); fprintf( stderr, " inherit=%d,", req->inherit ); @@ -430,12 +530,12 @@ dump_unicode_string( req->name ); } -static void dump_open_semaphore_reply( struct open_semaphore_request *req ) +static void dump_open_semaphore_reply( const struct open_semaphore_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_create_file_request( struct create_file_request *req ) +static void dump_create_file_request( const struct create_file_request *req ) { fprintf( stderr, " access=%08x,", req->access ); fprintf( stderr, " inherit=%d,", req->inherit ); @@ -445,32 +545,32 @@ fprintf( stderr, " name=\"%s\"", req->name ); } -static void dump_create_file_reply( struct create_file_request *req ) +static void dump_create_file_reply( const struct create_file_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_alloc_file_handle_request( struct alloc_file_handle_request *req ) +static void dump_alloc_file_handle_request( const struct alloc_file_handle_request *req ) { fprintf( stderr, " access=%08x", req->access ); } -static void dump_alloc_file_handle_reply( struct alloc_file_handle_request *req ) +static void dump_alloc_file_handle_reply( const struct alloc_file_handle_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_get_read_fd_request( struct get_read_fd_request *req ) +static void dump_get_read_fd_request( const struct get_read_fd_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_get_write_fd_request( struct get_write_fd_request *req ) +static void dump_get_write_fd_request( const struct get_write_fd_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_set_file_pointer_request( struct set_file_pointer_request *req ) +static void dump_set_file_pointer_request( const struct set_file_pointer_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " low=%d,", req->low ); @@ -478,35 +578,35 @@ fprintf( stderr, " whence=%d", req->whence ); } -static void dump_set_file_pointer_reply( struct set_file_pointer_request *req ) +static void dump_set_file_pointer_reply( const struct set_file_pointer_request *req ) { fprintf( stderr, " new_low=%d,", req->new_low ); fprintf( stderr, " new_high=%d", req->new_high ); } -static void dump_truncate_file_request( struct truncate_file_request *req ) +static void dump_truncate_file_request( const struct truncate_file_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_set_file_time_request( struct set_file_time_request *req ) +static void dump_set_file_time_request( const struct set_file_time_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " access_time=%ld,", req->access_time ); fprintf( stderr, " write_time=%ld", req->write_time ); } -static void dump_flush_file_request( struct flush_file_request *req ) +static void dump_flush_file_request( const struct flush_file_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_get_file_info_request( struct get_file_info_request *req ) +static void dump_get_file_info_request( const struct get_file_info_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_get_file_info_reply( struct get_file_info_request *req ) +static void dump_get_file_info_reply( const struct get_file_info_request *req ) { fprintf( stderr, " type=%d,", req->type ); fprintf( stderr, " attr=%d,", req->attr ); @@ -520,7 +620,7 @@ fprintf( stderr, " serial=%08x", req->serial ); } -static void dump_lock_file_request( struct lock_file_request *req ) +static void dump_lock_file_request( const struct lock_file_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " offset_low=%08x,", req->offset_low ); @@ -529,7 +629,7 @@ fprintf( stderr, " count_high=%08x", req->count_high ); } -static void dump_unlock_file_request( struct unlock_file_request *req ) +static void dump_unlock_file_request( const struct unlock_file_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " offset_low=%08x,", req->offset_low ); @@ -538,18 +638,18 @@ fprintf( stderr, " count_high=%08x", req->count_high ); } -static void dump_create_pipe_request( struct create_pipe_request *req ) +static void dump_create_pipe_request( const struct create_pipe_request *req ) { fprintf( stderr, " inherit=%d", req->inherit ); } -static void dump_create_pipe_reply( struct create_pipe_request *req ) +static void dump_create_pipe_reply( const struct create_pipe_request *req ) { fprintf( stderr, " handle_read=%d,", req->handle_read ); fprintf( stderr, " handle_write=%d", req->handle_write ); } -static void dump_create_socket_request( struct create_socket_request *req ) +static void dump_create_socket_request( const struct create_socket_request *req ) { fprintf( stderr, " access=%08x,", req->access ); fprintf( stderr, " inherit=%d,", req->inherit ); @@ -558,38 +658,38 @@ fprintf( stderr, " protocol=%d", req->protocol ); } -static void dump_create_socket_reply( struct create_socket_request *req ) +static void dump_create_socket_reply( const struct create_socket_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_accept_socket_request( struct accept_socket_request *req ) +static void dump_accept_socket_request( const struct accept_socket_request *req ) { fprintf( stderr, " lhandle=%d,", req->lhandle ); fprintf( stderr, " access=%08x,", req->access ); fprintf( stderr, " inherit=%d", req->inherit ); } -static void dump_accept_socket_reply( struct accept_socket_request *req ) +static void dump_accept_socket_reply( const struct accept_socket_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_set_socket_event_request( struct set_socket_event_request *req ) +static void dump_set_socket_event_request( const struct set_socket_event_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " mask=%08x,", req->mask ); fprintf( stderr, " event=%d", req->event ); } -static void dump_get_socket_event_request( struct get_socket_event_request *req ) +static void dump_get_socket_event_request( const struct get_socket_event_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " service=%d,", req->service ); fprintf( stderr, " s_event=%d", req->s_event ); } -static void dump_get_socket_event_reply( struct get_socket_event_request *req ) +static void dump_get_socket_event_reply( const struct get_socket_event_request *req ) { fprintf( stderr, " mask=%08x,", req->mask ); fprintf( stderr, " pmask=%08x,", req->pmask ); @@ -598,7 +698,7 @@ dump_varargs_get_socket_event_reply( req ); } -static void dump_enable_socket_event_request( struct enable_socket_event_request *req ) +static void dump_enable_socket_event_request( const struct enable_socket_event_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " mask=%08x,", req->mask ); @@ -606,59 +706,59 @@ fprintf( stderr, " cstate=%08x", req->cstate ); } -static void dump_alloc_console_request( struct alloc_console_request *req ) +static void dump_alloc_console_request( const struct alloc_console_request *req ) { fprintf( stderr, " access=%08x,", req->access ); fprintf( stderr, " inherit=%d", req->inherit ); } -static void dump_alloc_console_reply( struct alloc_console_request *req ) +static void dump_alloc_console_reply( const struct alloc_console_request *req ) { fprintf( stderr, " handle_in=%d,", req->handle_in ); fprintf( stderr, " handle_out=%d", req->handle_out ); } -static void dump_free_console_request( struct free_console_request *req ) +static void dump_free_console_request( const struct free_console_request *req ) { fprintf( stderr, " dummy=%d", req->dummy ); } -static void dump_open_console_request( struct open_console_request *req ) +static void dump_open_console_request( const struct open_console_request *req ) { fprintf( stderr, " output=%d,", req->output ); fprintf( stderr, " access=%08x,", req->access ); fprintf( stderr, " inherit=%d", req->inherit ); } -static void dump_open_console_reply( struct open_console_request *req ) +static void dump_open_console_reply( const struct open_console_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_set_console_fd_request( struct set_console_fd_request *req ) +static void dump_set_console_fd_request( const struct set_console_fd_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " file_handle=%d,", req->file_handle ); fprintf( stderr, " pid=%d", req->pid ); } -static void dump_get_console_mode_request( struct get_console_mode_request *req ) +static void dump_get_console_mode_request( const struct get_console_mode_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_get_console_mode_reply( struct get_console_mode_request *req ) +static void dump_get_console_mode_reply( const struct get_console_mode_request *req ) { fprintf( stderr, " mode=%d", req->mode ); } -static void dump_set_console_mode_request( struct set_console_mode_request *req ) +static void dump_set_console_mode_request( const struct set_console_mode_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " mode=%d", req->mode ); } -static void dump_set_console_info_request( struct set_console_info_request *req ) +static void dump_set_console_info_request( const struct set_console_info_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " mask=%d,", req->mask ); @@ -667,12 +767,12 @@ fprintf( stderr, " title=\"%s\"", req->title ); } -static void dump_get_console_info_request( struct get_console_info_request *req ) +static void dump_get_console_info_request( const struct get_console_info_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_get_console_info_reply( struct get_console_info_request *req ) +static void dump_get_console_info_reply( const struct get_console_info_request *req ) { fprintf( stderr, " cursor_size=%d,", req->cursor_size ); fprintf( stderr, " cursor_visible=%d,", req->cursor_visible ); @@ -680,41 +780,41 @@ fprintf( stderr, " title=\"%s\"", req->title ); } -static void dump_write_console_input_request( struct write_console_input_request *req ) +static void dump_write_console_input_request( const struct write_console_input_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " count=%d", req->count ); } -static void dump_write_console_input_reply( struct write_console_input_request *req ) +static void dump_write_console_input_reply( const struct write_console_input_request *req ) { fprintf( stderr, " written=%d", req->written ); } -static void dump_read_console_input_request( struct read_console_input_request *req ) +static void dump_read_console_input_request( const struct read_console_input_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " count=%d,", req->count ); fprintf( stderr, " flush=%d", req->flush ); } -static void dump_read_console_input_reply( struct read_console_input_request *req ) +static void dump_read_console_input_reply( const struct read_console_input_request *req ) { fprintf( stderr, " read=%d", req->read ); } -static void dump_create_change_notification_request( struct create_change_notification_request *req ) +static void dump_create_change_notification_request( const struct create_change_notification_request *req ) { fprintf( stderr, " subtree=%d,", req->subtree ); fprintf( stderr, " filter=%d", req->filter ); } -static void dump_create_change_notification_reply( struct create_change_notification_request *req ) +static void dump_create_change_notification_reply( const struct create_change_notification_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_create_mapping_request( struct create_mapping_request *req ) +static void dump_create_mapping_request( const struct create_mapping_request *req ) { fprintf( stderr, " size_high=%d,", req->size_high ); fprintf( stderr, " size_low=%d,", req->size_low ); @@ -725,12 +825,12 @@ dump_unicode_string( req->name ); } -static void dump_create_mapping_reply( struct create_mapping_request *req ) +static void dump_create_mapping_reply( const struct create_mapping_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_open_mapping_request( struct open_mapping_request *req ) +static void dump_open_mapping_request( const struct open_mapping_request *req ) { fprintf( stderr, " access=%08x,", req->access ); fprintf( stderr, " inherit=%d,", req->inherit ); @@ -738,107 +838,109 @@ dump_unicode_string( req->name ); } -static void dump_open_mapping_reply( struct open_mapping_request *req ) +static void dump_open_mapping_reply( const struct open_mapping_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_get_mapping_info_request( struct get_mapping_info_request *req ) +static void dump_get_mapping_info_request( const struct get_mapping_info_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_get_mapping_info_reply( struct get_mapping_info_request *req ) +static void dump_get_mapping_info_reply( const struct get_mapping_info_request *req ) { fprintf( stderr, " size_high=%d,", req->size_high ); fprintf( stderr, " size_low=%d,", req->size_low ); fprintf( stderr, " protect=%d", req->protect ); } -static void dump_create_device_request( struct create_device_request *req ) +static void dump_create_device_request( const struct create_device_request *req ) { fprintf( stderr, " access=%08x,", req->access ); fprintf( stderr, " inherit=%d,", req->inherit ); fprintf( stderr, " id=%d", req->id ); } -static void dump_create_device_reply( struct create_device_request *req ) +static void dump_create_device_reply( const struct create_device_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_create_snapshot_request( struct create_snapshot_request *req ) +static void dump_create_snapshot_request( const struct create_snapshot_request *req ) { fprintf( stderr, " inherit=%d,", req->inherit ); fprintf( stderr, " flags=%d", req->flags ); } -static void dump_create_snapshot_reply( struct create_snapshot_request *req ) +static void dump_create_snapshot_reply( const struct create_snapshot_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_next_process_request( struct next_process_request *req ) +static void dump_next_process_request( const struct next_process_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " reset=%d", req->reset ); } -static void dump_next_process_reply( struct next_process_request *req ) +static void dump_next_process_reply( const struct next_process_request *req ) { fprintf( stderr, " pid=%p,", req->pid ); fprintf( stderr, " threads=%d,", req->threads ); fprintf( stderr, " priority=%d", req->priority ); } -static void dump_wait_debug_event_request( struct wait_debug_event_request *req ) +static void dump_wait_debug_event_request( const struct wait_debug_event_request *req ) { fprintf( stderr, " timeout=%d", req->timeout ); } -static void dump_wait_debug_event_reply( struct wait_debug_event_request *req ) +static void dump_wait_debug_event_reply( const struct wait_debug_event_request *req ) { - fprintf( stderr, " code=%d,", req->code ); fprintf( stderr, " pid=%p,", req->pid ); - fprintf( stderr, " tid=%p", req->tid ); + fprintf( stderr, " tid=%p,", req->tid ); + fprintf( stderr, " event=" ); + dump_debug_event_t( &req->event ); } -static void dump_send_debug_event_request( struct send_debug_event_request *req ) +static void dump_send_debug_event_request( const struct send_debug_event_request *req ) { - fprintf( stderr, " code=%d", req->code ); + fprintf( stderr, " event=" ); + dump_debug_event_t( &req->event ); } -static void dump_send_debug_event_reply( struct send_debug_event_request *req ) +static void dump_send_debug_event_reply( const struct send_debug_event_request *req ) { fprintf( stderr, " status=%d", req->status ); } -static void dump_continue_debug_event_request( struct continue_debug_event_request *req ) +static void dump_continue_debug_event_request( const struct continue_debug_event_request *req ) { fprintf( stderr, " pid=%p,", req->pid ); fprintf( stderr, " tid=%p,", req->tid ); fprintf( stderr, " status=%d", req->status ); } -static void dump_debug_process_request( struct debug_process_request *req ) +static void dump_debug_process_request( const struct debug_process_request *req ) { fprintf( stderr, " pid=%p", req->pid ); } -static void dump_read_process_memory_request( struct read_process_memory_request *req ) +static void dump_read_process_memory_request( const struct read_process_memory_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " addr=%p,", req->addr ); fprintf( stderr, " len=%d", req->len ); } -static void dump_read_process_memory_reply( struct read_process_memory_request *req ) +static void dump_read_process_memory_reply( const struct read_process_memory_request *req ) { fprintf( stderr, " data=" ); dump_varargs_read_process_memory_reply( req ); } -static void dump_write_process_memory_request( struct write_process_memory_request *req ) +static void dump_write_process_memory_request( const struct write_process_memory_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " addr=%p,", req->addr ); @@ -849,72 +951,72 @@ dump_varargs_write_process_memory_request( req ); } -static void dump_create_key_request( struct create_key_request *req ) +static void dump_create_key_request( const struct create_key_request *req ) { fprintf( stderr, " parent=%d,", req->parent ); fprintf( stderr, " access=%08x,", req->access ); fprintf( stderr, " options=%08x,", req->options ); fprintf( stderr, " modif=%ld,", req->modif ); fprintf( stderr, " name=" ); - dump_unicode_string( req->name ); + dump_path_t( &req->name ); fprintf( stderr, "," ); fprintf( stderr, " class=" ); dump_unicode_string( req->class ); } -static void dump_create_key_reply( struct create_key_request *req ) +static void dump_create_key_reply( const struct create_key_request *req ) { fprintf( stderr, " hkey=%d,", req->hkey ); fprintf( stderr, " created=%d", req->created ); } -static void dump_open_key_request( struct open_key_request *req ) +static void dump_open_key_request( const struct open_key_request *req ) { fprintf( stderr, " parent=%d,", req->parent ); fprintf( stderr, " access=%08x,", req->access ); fprintf( stderr, " name=" ); - dump_unicode_string( req->name ); + dump_path_t( &req->name ); } -static void dump_open_key_reply( struct open_key_request *req ) +static void dump_open_key_reply( const struct open_key_request *req ) { fprintf( stderr, " hkey=%d", req->hkey ); } -static void dump_delete_key_request( struct delete_key_request *req ) +static void dump_delete_key_request( const struct delete_key_request *req ) { fprintf( stderr, " hkey=%d,", req->hkey ); fprintf( stderr, " name=" ); - dump_unicode_string( req->name ); + dump_path_t( &req->name ); } -static void dump_close_key_request( struct close_key_request *req ) +static void dump_close_key_request( const struct close_key_request *req ) { fprintf( stderr, " hkey=%d", req->hkey ); } -static void dump_enum_key_request( struct enum_key_request *req ) +static void dump_enum_key_request( const struct enum_key_request *req ) { fprintf( stderr, " hkey=%d,", req->hkey ); fprintf( stderr, " index=%d", req->index ); } -static void dump_enum_key_reply( struct enum_key_request *req ) +static void dump_enum_key_reply( const struct enum_key_request *req ) { fprintf( stderr, " modif=%ld,", req->modif ); fprintf( stderr, " name=" ); - dump_unicode_string( req->name ); + dump_path_t( &req->name ); fprintf( stderr, "," ); fprintf( stderr, " class=" ); dump_unicode_string( req->class ); } -static void dump_query_key_info_request( struct query_key_info_request *req ) +static void dump_query_key_info_request( const struct query_key_info_request *req ) { fprintf( stderr, " hkey=%d", req->hkey ); } -static void dump_query_key_info_reply( struct query_key_info_request *req ) +static void dump_query_key_info_reply( const struct query_key_info_request *req ) { fprintf( stderr, " subkeys=%d,", req->subkeys ); fprintf( stderr, " max_subkey=%d,", req->max_subkey ); @@ -924,32 +1026,32 @@ fprintf( stderr, " max_data=%d,", req->max_data ); fprintf( stderr, " modif=%ld,", req->modif ); fprintf( stderr, " name=" ); - dump_unicode_string( req->name ); + dump_path_t( &req->name ); fprintf( stderr, "," ); fprintf( stderr, " class=" ); dump_unicode_string( req->class ); } -static void dump_set_key_value_request( struct set_key_value_request *req ) +static void dump_set_key_value_request( const struct set_key_value_request *req ) { fprintf( stderr, " hkey=%d,", req->hkey ); fprintf( stderr, " type=%d,", req->type ); fprintf( stderr, " len=%d,", req->len ); fprintf( stderr, " name=" ); - dump_unicode_string( req->name ); + dump_path_t( &req->name ); fprintf( stderr, "," ); fprintf( stderr, " data=" ); dump_varargs_set_key_value_request( req ); } -static void dump_get_key_value_request( struct get_key_value_request *req ) +static void dump_get_key_value_request( const struct get_key_value_request *req ) { fprintf( stderr, " hkey=%d,", req->hkey ); fprintf( stderr, " name=" ); dump_unicode_string( req->name ); } -static void dump_get_key_value_reply( struct get_key_value_request *req ) +static void dump_get_key_value_reply( const struct get_key_value_request *req ) { fprintf( stderr, " type=%d,", req->type ); fprintf( stderr, " len=%d,", req->len ); @@ -957,52 +1059,52 @@ dump_varargs_get_key_value_reply( req ); } -static void dump_enum_key_value_request( struct enum_key_value_request *req ) +static void dump_enum_key_value_request( const struct enum_key_value_request *req ) { fprintf( stderr, " hkey=%d,", req->hkey ); fprintf( stderr, " index=%d", req->index ); } -static void dump_enum_key_value_reply( struct enum_key_value_request *req ) +static void dump_enum_key_value_reply( const struct enum_key_value_request *req ) { fprintf( stderr, " type=%d,", req->type ); fprintf( stderr, " len=%d,", req->len ); fprintf( stderr, " name=" ); - dump_unicode_string( req->name ); + dump_path_t( &req->name ); fprintf( stderr, "," ); fprintf( stderr, " data=" ); dump_varargs_enum_key_value_reply( req ); } -static void dump_delete_key_value_request( struct delete_key_value_request *req ) +static void dump_delete_key_value_request( const struct delete_key_value_request *req ) { fprintf( stderr, " hkey=%d,", req->hkey ); fprintf( stderr, " name=" ); - dump_unicode_string( req->name ); + dump_path_t( &req->name ); } -static void dump_load_registry_request( struct load_registry_request *req ) +static void dump_load_registry_request( const struct load_registry_request *req ) { fprintf( stderr, " hkey=%d,", req->hkey ); fprintf( stderr, " file=%d,", req->file ); fprintf( stderr, " name=" ); - dump_unicode_string( req->name ); + dump_path_t( &req->name ); } -static void dump_save_registry_request( struct save_registry_request *req ) +static void dump_save_registry_request( const struct save_registry_request *req ) { fprintf( stderr, " hkey=%d,", req->hkey ); fprintf( stderr, " file=%d", req->file ); } -static void dump_set_registry_levels_request( struct set_registry_levels_request *req ) +static void dump_set_registry_levels_request( const struct set_registry_levels_request *req ) { fprintf( stderr, " current=%d,", req->current ); fprintf( stderr, " saving=%d,", req->saving ); fprintf( stderr, " version=%d", req->version ); } -static void dump_create_timer_request( struct create_timer_request *req ) +static void dump_create_timer_request( const struct create_timer_request *req ) { fprintf( stderr, " inherit=%d,", req->inherit ); fprintf( stderr, " manual=%d,", req->manual ); @@ -1010,12 +1112,12 @@ dump_unicode_string( req->name ); } -static void dump_create_timer_reply( struct create_timer_request *req ) +static void dump_create_timer_reply( const struct create_timer_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_open_timer_request( struct open_timer_request *req ) +static void dump_open_timer_request( const struct open_timer_request *req ) { fprintf( stderr, " access=%08x,", req->access ); fprintf( stderr, " inherit=%d,", req->inherit ); @@ -1023,12 +1125,12 @@ dump_unicode_string( req->name ); } -static void dump_open_timer_reply( struct open_timer_request *req ) +static void dump_open_timer_reply( const struct open_timer_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } -static void dump_set_timer_request( struct set_timer_request *req ) +static void dump_set_timer_request( const struct set_timer_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); fprintf( stderr, " sec=%d,", req->sec ); @@ -1038,11 +1140,31 @@ fprintf( stderr, " arg=%p", req->arg ); } -static void dump_cancel_timer_request( struct cancel_timer_request *req ) +static void dump_cancel_timer_request( const struct cancel_timer_request *req ) { fprintf( stderr, " handle=%d", req->handle ); } +static void dump_get_thread_context_request( const struct get_thread_context_request *req ) +{ + fprintf( stderr, " handle=%d,", req->handle ); + fprintf( stderr, " flags=%08x", req->flags ); +} + +static void dump_get_thread_context_reply( const struct get_thread_context_request *req ) +{ + fprintf( stderr, " context=" ); + dump_context( &req->context ); +} + +static void dump_set_thread_context_request( const struct set_thread_context_request *req ) +{ + fprintf( stderr, " handle=%d,", req->handle ); + fprintf( stderr, " flags=%08x,", req->flags ); + fprintf( stderr, " context=" ); + dump_context( &req->context ); +} + static const dump_func req_dumpers[REQ_NB_REQUESTS] = { (dump_func)dump_new_process_request, (dump_func)dump_new_thread_request, @@ -1134,6 +1256,8 @@ (dump_func)dump_open_timer_request, (dump_func)dump_set_timer_request, (dump_func)dump_cancel_timer_request, + (dump_func)dump_get_thread_context_request, + (dump_func)dump_set_thread_context_request, }; static const dump_func reply_dumpers[REQ_NB_REQUESTS] = { @@ -1227,6 +1351,8 @@ (dump_func)dump_open_timer_reply, (dump_func)0, (dump_func)0, + (dump_func)dump_get_thread_context_reply, + (dump_func)0, }; static const char * const req_names[REQ_NB_REQUESTS] = { @@ -1320,6 +1446,8 @@ "open_timer", "set_timer", "cancel_timer", + "get_thread_context", + "set_thread_context", }; /* ### make_requests end ### */
diff --git a/tools/make_requests b/tools/make_requests index 62ff329..9a8e6c9 100755 --- a/tools/make_requests +++ b/tools/make_requests
@@ -8,15 +8,17 @@ %formats = ( - "int" => "%d", - "long" => "%ld", - "char" => "%c", - "unsigned int" => "%08x", - "void*" => "%p", - "time_t" => "%ld", - "path_t" => "&dump_unicode_string", - "char[1]" => "\\\"%s\\\"", - "WCHAR[1]" => "&dump_unicode_string" + "int" => "%d", + "long" => "%ld", + "char" => "%c", + "unsigned int" => "%08x", + "void*" => "%p", + "time_t" => "%ld", + "path_t" => "&dump_path_t", + "debug_event_t" => "&dump_debug_event_t", + "CONTEXT" => "&dump_context", + "char[1]" => "\\\"%s\\\"", + "WCHAR[1]" => "&dump_unicode_string" ); my @requests = (); @@ -123,7 +125,7 @@ { my $name = shift; my $req = shift; - push @trace_lines, "static void dump_${name}_$req( struct ${name}_request *req )\n{\n"; + push @trace_lines, "static void dump_${name}_$req( const struct ${name}_request *req )\n{\n"; while ($#_ >= 0) { my $type = shift; @@ -134,7 +136,8 @@ { my $func = $1; push @trace_lines, " fprintf( stderr, \" $var=\" );\n"; - push @trace_lines, " $func( req->$var );\n"; + if ($type =~ /[1]/) { push @trace_lines, " $func( req->$var );\n"; } + else { push @trace_lines, " $func( &req->$var );\n"; } push @trace_lines, " fprintf( stderr, \",\" );\n" if ($#_ > 0); } else