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
