Moved idle event handling to the server.
diff --git a/include/process.h b/include/process.h index f7bf458..4a74bea 100644 --- a/include/process.h +++ b/include/process.h
@@ -91,8 +91,6 @@ HANDLE *dos_handles; /* Handles mapping DOS -> Win32 */ WORD winver; /* Windows version figured out by VERSION_GetVersion */ struct _SERVICETABLE *service_table; /* Service table for service thread */ - HANDLE idle_event; /* event to signal, when the process is idle */ - HANDLE16 main_queue; /* main message queue of the process */ } PDB; /* Process flags */
diff --git a/include/queue.h b/include/queue.h index d3a6c24..4a1be22 100644 --- a/include/queue.h +++ b/include/queue.h
@@ -90,7 +90,7 @@ HQUEUE16 next; /* Next queue */ HQUEUE16 self; /* Handle to self (was: reserved) */ TEB* teb; /* Thread owning queue */ - HANDLE hEvent; /* Event handle */ + HANDLE server_queue; /* Handle to server-side queue */ CRITICAL_SECTION cSection; /* Queue access critical section */ DWORD magic; /* magic number should be QUEUE_MAGIC */
diff --git a/include/server.h b/include/server.h index 774b8eb..ee1afd8 100644 --- a/include/server.h +++ b/include/server.h
@@ -170,6 +170,7 @@ { IN void* module; /* main module base address */ IN void* entry; /* process entry point */ + IN int gui; /* is it a GUI process? */ OUT int debugged; /* being debugged? */ }; @@ -1147,6 +1148,29 @@ OUT WCHAR name[1]; /* atom name */ }; + +/* Get the message queue of the current thread */ +struct get_msg_queue_request +{ + OUT int handle; /* handle to the queue */ +}; + +/* Wake up a message queue */ +struct wake_queue_request +{ + IN int handle; /* handle to the queue */ + IN unsigned int bits; /* wake bits */ +}; + +/* Wait for a process to start waiting on input */ +struct wait_input_idle_request +{ + IN int handle; /* process handle */ + IN int timeout; /* timeout */ + OUT int event; /* handle to idle event */ +}; + + /* Everything below this line is generated automatically by tools/make_requests */ /* ### make_requests begin ### */ @@ -1255,10 +1279,13 @@ REQ_DELETE_ATOM, REQ_FIND_ATOM, REQ_GET_ATOM_NAME, + REQ_GET_MSG_QUEUE, + REQ_WAKE_QUEUE, + REQ_WAIT_INPUT_IDLE, REQ_NB_REQUESTS }; -#define SERVER_PROTOCOL_VERSION 12 +#define SERVER_PROTOCOL_VERSION 13 /* ### make_requests end ### */ /* Everything above this line is generated automatically by tools/make_requests */
diff --git a/scheduler/process.c b/scheduler/process.c index dd55f7d..0a9ce5d 100644 --- a/scheduler/process.c +++ b/scheduler/process.c
@@ -187,7 +187,6 @@ pdb->group = pdb; pdb->priority = 8; /* Normal */ pdb->winver = 0xffff; /* to be determined */ - pdb->main_queue = INVALID_HANDLE_VALUE16; initial_envdb.startup_info = &initial_startup; /* Setup the server connection */ @@ -218,14 +217,6 @@ if (!HEAP_CreateSystemHeap()) return FALSE; pdb->heap = HeapCreate( HEAP_GROWABLE, 0, 0 ); - /* Create the idle event for the initial process - FIXME 1: Shouldn't we call UserSignalProc for the initial process too? - FIXME 2: It seems to me that the initial pdb becomes never freed, so I don't now - where to release the idle event for the initial process. - */ - pdb->idle_event = CreateEventA ( NULL, TRUE, FALSE, NULL ); - pdb->idle_event = ConvertToGlobalHandle ( pdb->idle_event ); - /* Copy the parent environment */ if (!ENV_BuildEnvironment()) return FALSE; @@ -332,7 +323,7 @@ __TRY { struct init_process_done_request *req = get_req_buffer(); - int debugged; + int debugged, console_app; HMODULE16 hModule16; UINT cmdShow = SW_SHOWNORMAL; LPTHREAD_START_ROUTINE entry; @@ -347,6 +338,7 @@ /* Retrieve entry point address */ entry = (LPTHREAD_START_ROUTINE)RVA_PTR( module, OptionalHeader.AddressOfEntryPoint ); + console_app = (PE_HEADER(module)->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI); /* Create 16-bit dummy module */ if ((hModule16 = MODULE_CreateDummyModule( pdb->exe_modref->filename, module )) < 32) @@ -358,12 +350,12 @@ NtCurrentTeb(), NULL, 0 )) goto error; - if (PE_HEADER(module)->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI) - pdb->flags |= PDB32_CONSOLE_PROC; + if (console_app) pdb->flags |= PDB32_CONSOLE_PROC; /* Signal the parent process to continue */ req->module = (void *)module; req->entry = entry; + req->gui = !console_app; server_call( REQ_INIT_PROCESS_DONE ); debugged = req->debugged; @@ -376,8 +368,7 @@ LeaveCriticalSection( &pdb->crit_section ); /* Call UserSignalProc ( USIG_PROCESS_RUNNING ... ) only for non-GUI win32 apps */ - if (pdb->flags & PDB32_CONSOLE_PROC) - PROCESS_CallUserSignalProc( USIG_PROCESS_RUNNING, 0 ); + if (console_app) PROCESS_CallUserSignalProc( USIG_PROCESS_RUNNING, 0 ); TRACE_(relay)( "Starting Win32 process (entryproc=%p)\n", entry ); if (debugged) DbgBreakPoint();
diff --git a/server/Makefile.in b/server/Makefile.in index 0db09e5..2416736 100644 --- a/server/Makefile.in +++ b/server/Makefile.in
@@ -22,6 +22,7 @@ pipe.c \ process.c \ ptrace.c \ + queue.c \ registry.c \ request.c \ select.c \
diff --git a/server/object.h b/server/object.h index 8869504..66ce781 100644 --- a/server/object.h +++ b/server/object.h
@@ -72,6 +72,14 @@ #endif }; +struct wait_queue_entry +{ + struct wait_queue_entry *next; + struct wait_queue_entry *prev; + struct object *obj; + struct thread *thread; +}; + extern void *mem_alloc( size_t size ); /* malloc wrapper */ extern void *memdup( const void *data, size_t len ); extern void *alloc_object( const struct object_ops *ops, int fd );
diff --git a/server/process.c b/server/process.c index 733b693..987bdd8 100644 --- a/server/process.c +++ b/server/process.c
@@ -137,6 +137,8 @@ req->hstderr = alloc_handle( process, process->console_out, GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, 1 ); } + /* some handles above may have been invalid; this is not an error */ + if (get_error() == STATUS_INVALID_HANDLE) clear_error(); return 1; } @@ -165,6 +167,8 @@ process->console_in = NULL; process->console_out = NULL; process->init_event = NULL; + process->idle_event = NULL; + process->queue = NULL; process->ldt_copy = NULL; process->ldt_flags = NULL; process->exe.next = NULL; @@ -282,6 +286,8 @@ if (process->prev) process->prev->next = process->next; else first_process = process->next; if (process->init_event) release_object( process->init_event ); + if (process->idle_event) release_object( process->idle_event ); + if (process->queue) release_object( process->queue ); if (process->exe.file) release_object( process->exe.file ); } @@ -813,6 +819,7 @@ set_event( process->init_event ); release_object( process->init_event ); process->init_event = NULL; + if (req->gui) process->idle_event = create_event( NULL, 0, 1, 0 ); if (current->suspend + current->process->suspend > 0) stop_thread( current ); req->debugged = (current->process->debugger != 0); } @@ -919,3 +926,19 @@ { process_unload_dll( current->process, req->base ); } + +/* wait for a process to start waiting on input */ +/* FIXME: only returns event for now, wait is done in the client */ +DECL_HANDLER(wait_input_idle) +{ + struct process *process; + + req->event = -1; + if ((process = get_process_from_handle( req->handle, PROCESS_QUERY_INFORMATION ))) + { + if (process->idle_event && process != current->process && process->queue != current->queue) + req->event = alloc_handle( current->process, process->idle_event, + EVENT_ALL_ACCESS, 0 ); + release_object( process ); + } +}
diff --git a/server/process.h b/server/process.h index ae606a5..2b7a699 100644 --- a/server/process.h +++ b/server/process.h
@@ -13,6 +13,8 @@ #include "object.h" +struct msg_queue; + /* process structures */ struct process_dll @@ -45,6 +47,8 @@ struct object *console_in; /* console input */ struct object *console_out; /* console output */ struct event *init_event; /* event for init done */ + struct event *idle_event; /* event for input idle */ + struct msg_queue *queue; /* main message queue */ struct process_dll exe; /* main exe file */ void *ldt_copy; /* pointer to LDT copy in client addr space */ void *ldt_flags; /* pointer to LDT flags in client addr space */
diff --git a/server/queue.c b/server/queue.c new file mode 100644 index 0000000..80cfda6 --- /dev/null +++ b/server/queue.c
@@ -0,0 +1,130 @@ +/* + * Server-side message queues + * + * Copyright (C) 2000 Alexandre Julliard + */ + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> + +#include "handle.h" +#include "thread.h" +#include "process.h" +#include "request.h" + +struct msg_queue +{ + struct object obj; /* object header */ + struct thread *thread; /* thread owning this queue */ + int signaled; /* queue has been signaled */ +}; + +static void msg_queue_dump( struct object *obj, int verbose ); +static int msg_queue_add_queue( struct object *obj, struct wait_queue_entry *entry ); +static void msg_queue_remove_queue( struct object *obj, struct wait_queue_entry *entry ); +static int msg_queue_signaled( struct object *obj, struct thread *thread ); +static int msg_queue_satisfied( struct object *obj, struct thread *thread ); + +static const struct object_ops msg_queue_ops = +{ + sizeof(struct msg_queue), /* size */ + msg_queue_dump, /* dump */ + msg_queue_add_queue, /* add_queue */ + msg_queue_remove_queue, /* remove_queue */ + msg_queue_signaled, /* signaled */ + msg_queue_satisfied, /* satisfied */ + NULL, /* get_poll_events */ + NULL, /* poll_event */ + no_read_fd, /* get_read_fd */ + no_write_fd, /* get_write_fd */ + no_flush, /* flush */ + no_get_file_info, /* get_file_info */ + no_destroy /* destroy */ +}; + + +static struct msg_queue *create_msg_queue( struct thread *thread ) +{ + struct msg_queue *queue; + + if ((queue = alloc_object( &msg_queue_ops, -1 ))) + { + queue->signaled = 0; + queue->thread = thread; + thread->queue = queue; + if (!thread->process->queue) + thread->process->queue = (struct msg_queue *)grab_object( queue ); + } + return queue; +} + +static int msg_queue_add_queue( struct object *obj, struct wait_queue_entry *entry ) +{ + struct msg_queue *queue = (struct msg_queue *)obj; + struct process *process = entry->thread->process; + + /* if waiting on the main process queue, set the idle event */ + if (entry->thread == queue->thread && process->queue == queue) + { + if (process->idle_event) set_event( process->idle_event ); + } + add_queue( obj, entry ); + return 1; +} + +static void msg_queue_remove_queue(struct object *obj, struct wait_queue_entry *entry ) +{ + struct msg_queue *queue = (struct msg_queue *)obj; + struct process *process = entry->thread->process; + + remove_queue( obj, entry ); + + /* if waiting on the main process queue, reset the idle event */ + if (entry->thread == queue->thread && process->queue == queue) + { + if (process->idle_event) reset_event( process->idle_event ); + } +} + +static void msg_queue_dump( struct object *obj, int verbose ) +{ + struct msg_queue *queue = (struct msg_queue *)obj; + fprintf( stderr, "Msg queue signaled=%d owner=%p\n", queue->signaled, queue->thread ); +} + +static int msg_queue_signaled( struct object *obj, struct thread *thread ) +{ + struct msg_queue *queue = (struct msg_queue *)obj; + return queue->signaled; +} + +static int msg_queue_satisfied( struct object *obj, struct thread *thread ) +{ + struct msg_queue *queue = (struct msg_queue *)obj; + queue->signaled = 0; + return 0; /* Not abandoned */ +} + +/* get the message queue of the current thread */ +DECL_HANDLER(get_msg_queue) +{ + struct msg_queue *queue = current->queue; + + req->handle = -1; + if (!queue) queue = create_msg_queue( current ); + if (queue) req->handle = alloc_handle( current->process, queue, SYNCHRONIZE, 0 ); +} + +/* wake up a message queue */ +DECL_HANDLER(wake_queue) +{ + struct msg_queue *queue = (struct msg_queue *)get_handle_obj( current->process, req->handle, + 0, &msg_queue_ops ); + if (queue) + { + queue->signaled = 1; + wake_up( &queue->obj, 0 ); + release_object( queue ); + } +}
diff --git a/server/request.h b/server/request.h index f87b4f5..6e3c943 100644 --- a/server/request.h +++ b/server/request.h
@@ -173,6 +173,9 @@ DECL_HANDLER(delete_atom); DECL_HANDLER(find_atom); DECL_HANDLER(get_atom_name); +DECL_HANDLER(get_msg_queue); +DECL_HANDLER(wake_queue); +DECL_HANDLER(wait_input_idle); #ifdef WANT_REQUEST_HANDLERS @@ -282,6 +285,9 @@ (req_handler)req_delete_atom, (req_handler)req_find_atom, (req_handler)req_get_atom_name, + (req_handler)req_get_msg_queue, + (req_handler)req_wake_queue, + (req_handler)req_wait_input_idle, }; #endif /* WANT_REQUEST_HANDLERS */
diff --git a/server/thread.c b/server/thread.c index f98982d..1899132 100644 --- a/server/thread.c +++ b/server/thread.c
@@ -34,14 +34,6 @@ /* thread queues */ -struct wait_queue_entry -{ - struct wait_queue_entry *next; - struct wait_queue_entry *prev; - struct object *obj; - struct thread *thread; -}; - struct thread_wait { int count; /* count of objects */ @@ -131,6 +123,7 @@ thread->mutex = NULL; thread->debug_ctx = NULL; thread->debug_event = NULL; + thread->queue = NULL; thread->info = NULL; thread->wait = NULL; thread->apc = NULL; @@ -196,6 +189,7 @@ else first_thread = thread->next; if (thread->apc) free( thread->apc ); if (thread->info) release_object( thread->info ); + if (thread->queue) release_object( thread->queue ); if (thread->buffer != (void *)-1) munmap( thread->buffer, MAX_REQUEST_LENGTH ); if (thread->pass_fd != -1) close( thread->pass_fd ); }
diff --git a/server/thread.h b/server/thread.h index 3340d5e..910c330 100644 --- a/server/thread.h +++ b/server/thread.h
@@ -22,6 +22,7 @@ struct debug_ctx; struct debug_event; struct startup_info; +struct msg_queue; enum run_state { @@ -41,6 +42,7 @@ struct mutex *mutex; /* list of currently owned mutexes */ struct debug_ctx *debug_ctx; /* debugger context if this thread is a debugger */ struct debug_event *debug_event; /* debug event being sent to debugger */ + struct msg_queue *queue; /* message queue */ struct startup_info*info; /* startup info for child process */ struct thread_wait *wait; /* current wait condition if sleeping */ struct thread_apc *apc; /* list of async procedure calls */
diff --git a/server/trace.c b/server/trace.c index 4ea9319..369fed0 100644 --- a/server/trace.c +++ b/server/trace.c
@@ -284,7 +284,8 @@ static void dump_init_process_done_request( const struct init_process_done_request *req ) { fprintf( stderr, " module=%p,", req->module ); - fprintf( stderr, " entry=%p", req->entry ); + fprintf( stderr, " entry=%p,", req->entry ); + fprintf( stderr, " gui=%d", req->gui ); } static void dump_init_process_done_reply( const struct init_process_done_request *req ) @@ -1333,6 +1334,32 @@ dump_unicode_string( req, req->name ); } +static void dump_get_msg_queue_request( const struct get_msg_queue_request *req ) +{ +} + +static void dump_get_msg_queue_reply( const struct get_msg_queue_request *req ) +{ + fprintf( stderr, " handle=%d", req->handle ); +} + +static void dump_wake_queue_request( const struct wake_queue_request *req ) +{ + fprintf( stderr, " handle=%d,", req->handle ); + fprintf( stderr, " bits=%08x", req->bits ); +} + +static void dump_wait_input_idle_request( const struct wait_input_idle_request *req ) +{ + fprintf( stderr, " handle=%d,", req->handle ); + fprintf( stderr, " timeout=%d", req->timeout ); +} + +static void dump_wait_input_idle_reply( const struct wait_input_idle_request *req ) +{ + fprintf( stderr, " event=%d", req->event ); +} + static const dump_func req_dumpers[REQ_NB_REQUESTS] = { (dump_func)dump_new_process_request, (dump_func)dump_wait_process_request, @@ -1437,6 +1464,9 @@ (dump_func)dump_delete_atom_request, (dump_func)dump_find_atom_request, (dump_func)dump_get_atom_name_request, + (dump_func)dump_get_msg_queue_request, + (dump_func)dump_wake_queue_request, + (dump_func)dump_wait_input_idle_request, }; static const dump_func reply_dumpers[REQ_NB_REQUESTS] = { @@ -1543,6 +1573,9 @@ (dump_func)0, (dump_func)dump_find_atom_reply, (dump_func)dump_get_atom_name_reply, + (dump_func)dump_get_msg_queue_reply, + (dump_func)0, + (dump_func)dump_wait_input_idle_reply, }; static const char * const req_names[REQ_NB_REQUESTS] = { @@ -1649,6 +1682,9 @@ "delete_atom", "find_atom", "get_atom_name", + "get_msg_queue", + "wake_queue", + "wait_input_idle", }; /* ### make_requests end ### */
diff --git a/windows/message.c b/windows/message.c index d2c1a67..2c42ad6 100644 --- a/windows/message.c +++ b/windows/message.c
@@ -23,7 +23,6 @@ #include "queue.h" #include "winproc.h" #include "task.h" -#include "process.h" #include "selectors.h" #include "thread.h" #include "options.h" @@ -31,9 +30,9 @@ #include "struct32.h" #include "debugtools.h" -DEFAULT_DEBUG_CHANNEL(msg) -DECLARE_DEBUG_CHANNEL(key) -DECLARE_DEBUG_CHANNEL(sendmsg) +DEFAULT_DEBUG_CHANNEL(msg); +DECLARE_DEBUG_CHANNEL(key); +DECLARE_DEBUG_CHANNEL(sendmsg); #define WM_NCMOUSEFIRST WM_NCMOUSEMOVE #define WM_NCMOUSELAST WM_NCMBUTTONDBLCLK @@ -1952,7 +1951,6 @@ DWORD i; HANDLE handles[MAXIMUM_WAIT_OBJECTS]; DWORD ret; - PDB * pdb = PROCESS_Current(); HQUEUE16 hQueue = GetFastQueue16(); MESSAGEQUEUE *msgQueue = (MESSAGEQUEUE *)QUEUE_Lock( hQueue ); @@ -1988,7 +1986,6 @@ /* * Check the handles in the list. */ - SetEvent ( pdb->idle_event ); ret = WaitForMultipleObjects(nCount, pHandles, fWaitAll, 5L); /* @@ -2020,18 +2017,11 @@ { /* Add the thread event to the handle list */ for (i = 0; i < nCount; i++) - handles[i] = pHandles[i]; - handles[nCount] = msgQueue->hEvent; - - if ( pdb->main_queue == INVALID_HANDLE_VALUE16 ) pdb->main_queue = hQueue; - if ( pdb->main_queue == hQueue ) SetEvent ( pdb->idle_event ); + handles[i] = pHandles[i]; + handles[nCount] = msgQueue->server_queue; ret = WaitForMultipleObjects( nCount+1, handles, fWaitAll, dwMilliseconds ); - if ( pdb->main_queue == hQueue ) ResetEvent ( pdb->idle_event ); - } - QUEUE_Unlock( msgQueue ); - return ret; }
diff --git a/windows/queue.c b/windows/queue.c index 67fabc5..f4705b2 100644 --- a/windows/queue.c +++ b/windows/queue.c
@@ -20,12 +20,12 @@ #include "hook.h" #include "heap.h" #include "thread.h" -#include "process.h" #include "debugtools.h" +#include "server.h" #include "spy.h" -DECLARE_DEBUG_CHANNEL(msg) -DECLARE_DEBUG_CHANNEL(sendmsg) +DECLARE_DEBUG_CHANNEL(msg); +DECLARE_DEBUG_CHANNEL(sendmsg); #define MAX_QUEUE_SIZE 120 /* Max. size of a message queue */ @@ -342,8 +342,8 @@ if ( --queue->lockCount == 0 ) { DeleteCriticalSection ( &queue->cSection ); - if (queue->hEvent) - CloseHandle( queue->hEvent ); + if (queue->server_queue) + CloseHandle( queue->server_queue ); GlobalFree16( queue->self ); } @@ -443,6 +443,7 @@ HQUEUE16 hQueue; MESSAGEQUEUE * msgQueue; TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() ); + struct get_msg_queue_request *req = get_req_buffer(); TRACE_(msg)("(): Creating message queue...\n"); @@ -454,6 +455,15 @@ if ( !msgQueue ) return 0; + if (server_call( REQ_GET_MSG_QUEUE )) + { + ERR_(msg)("Cannot get thread queue"); + GlobalFree16( hQueue ); + return 0; + } + msgQueue->server_queue = req->handle; + msgQueue->server_queue = ConvertToGlobalHandle( msgQueue->server_queue ); + msgQueue->self = hQueue; msgQueue->wakeBits = msgQueue->changeBits = 0; msgQueue->wWinVersion = pTask ? pTask->version : 0; @@ -461,22 +471,6 @@ InitializeCriticalSection( &msgQueue->cSection ); MakeCriticalSectionGlobal( &msgQueue->cSection ); - /* Create an Event object for waiting on message, used by win32 thread - only */ - if ( !THREAD_IsWin16( NtCurrentTeb() ) ) - { - msgQueue->hEvent = CreateEventA( NULL, FALSE, FALSE, NULL); - - if (msgQueue->hEvent == 0) - { - WARN_(msg)("CreateEventA is not able to create an event object"); - return 0; - } - msgQueue->hEvent = ConvertToGlobalHandle( msgQueue->hEvent ); - } - else - msgQueue->hEvent = 0; - msgQueue->lockCount = 1; msgQueue->magic = QUEUE_MAGIC; @@ -645,7 +639,10 @@ } else { - SetEvent( queue->hEvent ); + struct wake_queue_request *req = get_req_buffer(); + req->handle = queue->server_queue; + req->bits = bit; + server_call( REQ_WAKE_QUEUE ); } } } @@ -675,7 +672,6 @@ MESSAGEQUEUE *queue; DWORD curTime = 0; HQUEUE16 hQueue; - PDB * pdb; TRACE_(msg)("q %04x waiting for %04x\n", GetFastQueue16(), bits); @@ -685,8 +681,6 @@ hQueue = GetFastQueue16(); if (!(queue = (MESSAGEQUEUE *)QUEUE_Lock( hQueue ))) return 0; - pdb = PROCESS_Current(); - for (;;) { if (queue->changeBits & bits) @@ -724,22 +718,7 @@ ReleaseThunkLock( &dwlc ); } - - if ( pdb->main_queue == INVALID_HANDLE_VALUE16 ) - { - pdb->main_queue = hQueue; - } - if ( pdb->main_queue == hQueue ) - { - SetEvent ( pdb->idle_event ); - } - - WaitForSingleObject( queue->hEvent, timeout ); - - if ( pdb->main_queue == hQueue ) - { - ResetEvent ( pdb->idle_event ); - } + WaitForSingleObject( queue->server_queue, timeout ); if ( bHasWin16Lock ) { @@ -748,8 +727,6 @@ } else { - SetEvent ( pdb->idle_event ); - if ( timeout == INFINITE ) WaitEvent16( 0 ); /* win 16 thread, use WaitEvent */ else @@ -1522,34 +1499,21 @@ */ DWORD WINAPI WaitForInputIdle (HANDLE hProcess, DWORD dwTimeOut) { - PDB * pdb; - DWORD cur_time, ret, pid = MapProcessHandle ( hProcess ); + DWORD cur_time, ret; + HANDLE idle_event; + struct wait_input_idle_request *req = get_req_buffer(); - /* Check whether the calling process is a command line application */ - if (!THREAD_IsWin16(NtCurrentTeb() ) && - (PROCESS_Current()->flags & PDB32_CONSOLE_PROC)) - { - TRACE_(msg)("not a win32 GUI application!\n" ); - return 0; - } - - if (!(pdb = PROCESS_IdToPDB( pid ))) return 0; - - /* check whether we are waiting for a win32 process or the win16 subsystem */ - if ( pdb->flags & PDB32_WIN16_PROC ) { - if ( THREAD_IsWin16(NtCurrentTeb()) ) return 0; - } - else { /* target is win32 */ - if ( pdb->flags & PDB32_CONSOLE_PROC ) return 0; - if ( GetFastQueue16() == pdb->main_queue ) return 0; - } + req->handle = hProcess; + req->timeout = dwTimeOut; + if (server_call( REQ_WAIT_INPUT_IDLE )) return 0xffffffff; + if ((idle_event = req->event) == -1) return 0; /* no event to wait on */ cur_time = GetTickCount(); - TRACE_(msg)("waiting for %x\n", pdb->idle_event ); + TRACE_(msg)("waiting for %x\n", idle_event ); while ( dwTimeOut > GetTickCount() - cur_time || dwTimeOut == INFINITE ) { - ret = MsgWaitForMultipleObjects ( 1, &pdb->idle_event, FALSE, dwTimeOut, QS_SENDMESSAGE ); + ret = MsgWaitForMultipleObjects ( 1, &idle_event, FALSE, dwTimeOut, QS_SENDMESSAGE ); if ( ret == ( WAIT_OBJECT_0 + 1 )) { MESSAGEQUEUE * queue; if (!(queue = (MESSAGEQUEUE *)QUEUE_Lock( GetFastQueue16() ))) return 0xFFFFFFFF;
diff --git a/windows/user.c b/windows/user.c index c427c17..e77f20c 100644 --- a/windows/user.c +++ b/windows/user.c
@@ -210,9 +210,7 @@ WORD WINAPI UserSignalProc( UINT uCode, DWORD dwThreadOrProcessID, DWORD dwFlags, HMODULE16 hModule ) { - static HANDLE win16_idle_event; HINSTANCE16 hInst; - PDB * pdb; /* FIXME: Proper reaction to most signals still missing. */ @@ -239,32 +237,12 @@ break; case USIG_PROCESS_CREATE: - pdb = PROCESS_Current(); - - /* Create the idle event for the process. We have just one idle_event for all - win16 processes, while each win32 process has its own */ - - if ( pdb->flags & PDB32_WIN16_PROC ) - { - if (!win16_idle_event) - { - win16_idle_event = CreateEventA ( NULL, TRUE, FALSE, NULL ); - win16_idle_event = ConvertToGlobalHandle ( win16_idle_event ); - } - pdb->idle_event = win16_idle_event; - } - else { /* win32 process */ - pdb->idle_event = CreateEventA ( NULL, TRUE, FALSE, NULL ); - pdb->idle_event = ConvertToGlobalHandle ( pdb->idle_event ); - TRACE_(win)("created win32 idle event: %x\n", pdb->idle_event ); - } break; case USIG_PROCESS_INIT: case USIG_PROCESS_LOADED: break; case USIG_PROCESS_RUNNING: - SetEvent ( PROCESS_Current()->idle_event ); break; case USIG_PROCESS_EXIT: @@ -273,12 +251,6 @@ case USIG_PROCESS_DESTROY: hInst = ((TDB *)GlobalLock16( GetCurrentTask() ))->hInstance; USER_AppExit( hInst ); - - pdb = PROCESS_Current(); - if ( ! (pdb->flags & PDB32_WIN16_PROC) ) { - TRACE_(win)("destroying win32 idle event: %x\n", pdb->idle_event ); - CloseHandle ( pdb->idle_event ); - } break; default: