Check unix_pid again after attach.
[wine] / scheduler / synchro.c
1 /*
2  * Win32 process and thread synchronisation
3  *
4  * Copyright 1997 Alexandre Julliard
5  */
6
7 #include <assert.h>
8 #include <errno.h>
9 #include <signal.h>
10 #include <sys/time.h>
11 #include <sys/poll.h>
12 #include <unistd.h>
13 #include <string.h>
14
15 #include "file.h"  /* for DOSFS_UnixTimeToFileTime */
16 #include "thread.h"
17 #include "winerror.h"
18 #include "wine/server.h"
19
20
21 /***********************************************************************
22  *              get_timeout
23  */
24 inline static void get_timeout( struct timeval *when, int timeout )
25 {
26     gettimeofday( when, 0 );
27     if (timeout)
28     {
29         long sec = timeout / 1000;
30         if ((when->tv_usec += (timeout - 1000*sec) * 1000) >= 1000000)
31         {
32             when->tv_usec -= 1000000;
33             when->tv_sec++;
34         }
35         when->tv_sec += sec;
36     }
37 }
38
39 static void CALLBACK call_completion_routine(ULONG_PTR data)
40 {
41     async_private* ovp = (async_private*)data;
42
43     ovp->completion_func(ovp->lpOverlapped->Internal,
44                          ovp->lpOverlapped->InternalHigh,
45                          ovp->lpOverlapped);
46     ovp->completion_func=NULL;
47     HeapFree(GetProcessHeap(), 0, ovp);
48 }
49
50 void finish_async(async_private *ovp, DWORD status)
51 {
52     ovp->lpOverlapped->Internal=status;
53
54     /* call ReadFileEx/WriteFileEx's overlapped completion function */
55     if(ovp->completion_func)
56     {
57         QueueUserAPC(call_completion_routine,GetCurrentThread(),(ULONG_PTR)ovp);
58     }
59
60     /* remove it from the active list */
61     if(ovp->prev)
62         ovp->prev->next = ovp->next;
63     else
64         NtCurrentTeb()->pending_list = ovp->next;
65
66     if(ovp->next)
67         ovp->next->prev = ovp->prev;
68
69     ovp->next=NULL;
70     ovp->prev=NULL;
71
72     close(ovp->fd);
73     if(!ovp->completion_func) HeapFree(GetProcessHeap(), 0, ovp);
74 }
75
76 /***********************************************************************
77  *           check_async_list
78  *
79  * Process a status event from the server.
80  */
81 void WINAPI check_async_list(LPOVERLAPPED overlapped, DWORD status)
82 {
83     async_private *ovp;
84
85     /* fprintf(stderr,"overlapped %p status %x\n",overlapped,status); */
86
87     for(ovp = NtCurrentTeb()->pending_list; ovp; ovp = ovp->next)
88         if(ovp->lpOverlapped == overlapped)
89             break;
90
91     if(!ovp)
92             return;
93
94     if(status != STATUS_ALERTED)
95         ovp->lpOverlapped->Internal = status;
96
97     if(ovp->lpOverlapped->Internal==STATUS_PENDING)
98         {
99         ovp->func(ovp);
100         FILE_StartAsync(ovp->handle, ovp->lpOverlapped, ovp->type, 0, ovp->lpOverlapped->Internal);
101         }
102
103     if(ovp->lpOverlapped->Internal!=STATUS_PENDING)
104         finish_async(ovp,ovp->lpOverlapped->Internal);
105 }
106
107
108 /***********************************************************************
109  *              wait_reply
110  *
111  * Wait for a reply on the waiting pipe of the current thread.
112  */
113 static int wait_reply( void *cookie )
114 {
115     int signaled;
116     struct wake_up_reply reply;
117     for (;;)
118     {
119         int ret;
120         ret = read( NtCurrentTeb()->wait_fd[0], &reply, sizeof(reply) );
121         if (ret == sizeof(reply))
122         {
123             if (!reply.cookie) break;  /* thread got killed */
124             if (reply.cookie == cookie) return reply.signaled;
125             /* we stole another reply, wait for the real one */
126             signaled = wait_reply( cookie );
127             /* and now put the wrong one back in the pipe */
128             for (;;)
129             {
130                 ret = write( NtCurrentTeb()->wait_fd[1], &reply, sizeof(reply) );
131                 if (ret == sizeof(reply)) break;
132                 if (ret >= 0) server_protocol_error( "partial wakeup write %d\n", ret );
133                 if (errno == EINTR) continue;
134                 server_protocol_perror("wakeup write");
135             }
136             return signaled;
137         }
138         if (ret >= 0) server_protocol_error( "partial wakeup read %d\n", ret );
139         if (errno == EINTR) continue;
140         server_protocol_perror("wakeup read");
141     }
142     /* the server closed the connection; time to die... */
143     SYSDEPS_AbortThread(0);
144 }
145
146
147 /***********************************************************************
148  *              call_apcs
149  *
150  * Call outstanding APCs.
151  */
152 static void call_apcs( BOOL alertable )
153 {
154     FARPROC proc = NULL;
155     FILETIME ft;
156     void *args[4];
157
158     for (;;)
159     {
160         int type = APC_NONE;
161         SERVER_START_REQ( get_apc )
162         {
163             req->alertable = alertable;
164             wine_server_set_reply( req, args, sizeof(args) );
165             if (!wine_server_call( req ))
166             {
167                 type = reply->type;
168                 proc = reply->func;
169             }
170         }
171         SERVER_END_REQ;
172
173         switch(type)
174         {
175         case APC_NONE:
176             return;  /* no more APCs */
177         case APC_ASYNC:
178             proc( args[0], args[1]);
179             break;
180         case APC_USER:
181             proc( args[0] );
182             break;
183         case APC_TIMER:
184             /* convert sec/usec to NT time */
185             DOSFS_UnixTimeToFileTime( (time_t)args[0], &ft, (DWORD)args[1] * 10 );
186             proc( args[2], ft.dwLowDateTime, ft.dwHighDateTime );
187             break;
188         default:
189             server_protocol_error( "get_apc_request: bad type %d\n", type );
190             break;
191         }
192     }
193 }
194
195 /***********************************************************************
196  *              Sleep  (KERNEL32.@)
197  */
198 VOID WINAPI Sleep( DWORD timeout )
199 {
200     WaitForMultipleObjectsEx( 0, NULL, FALSE, timeout, FALSE );
201 }
202
203 /******************************************************************************
204  *              SleepEx   (KERNEL32.@)
205  */
206 DWORD WINAPI SleepEx( DWORD timeout, BOOL alertable )
207 {
208     DWORD ret = WaitForMultipleObjectsEx( 0, NULL, FALSE, timeout, alertable );
209     if (ret != WAIT_IO_COMPLETION) ret = 0;
210     return ret;
211 }
212
213
214 /***********************************************************************
215  *           WaitForSingleObject   (KERNEL32.@)
216  */
217 DWORD WINAPI WaitForSingleObject( HANDLE handle, DWORD timeout )
218 {
219     return WaitForMultipleObjectsEx( 1, &handle, FALSE, timeout, FALSE );
220 }
221
222
223 /***********************************************************************
224  *           WaitForSingleObjectEx   (KERNEL32.@)
225  */
226 DWORD WINAPI WaitForSingleObjectEx( HANDLE handle, DWORD timeout,
227                                     BOOL alertable )
228 {
229     return WaitForMultipleObjectsEx( 1, &handle, FALSE, timeout, alertable );
230 }
231
232
233 /***********************************************************************
234  *           WaitForMultipleObjects   (KERNEL32.@)
235  */
236 DWORD WINAPI WaitForMultipleObjects( DWORD count, const HANDLE *handles,
237                                      BOOL wait_all, DWORD timeout )
238 {
239     return WaitForMultipleObjectsEx( count, handles, wait_all, timeout, FALSE );
240 }
241
242
243 /***********************************************************************
244  *           WaitForMultipleObjectsEx   (KERNEL32.@)
245  */
246 DWORD WINAPI WaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
247                                        BOOL wait_all, DWORD timeout,
248                                        BOOL alertable )
249 {
250     int ret, cookie;
251     struct timeval tv;
252
253     if (count > MAXIMUM_WAIT_OBJECTS)
254     {
255         SetLastError( ERROR_INVALID_PARAMETER );
256         return WAIT_FAILED;
257     }
258
259     if (timeout == INFINITE) tv.tv_sec = tv.tv_usec = 0;
260     else get_timeout( &tv, timeout );
261
262     for (;;)
263     {
264         SERVER_START_REQ( select )
265         {
266             req->flags   = SELECT_INTERRUPTIBLE;
267             req->cookie  = &cookie;
268             req->sec     = tv.tv_sec;
269             req->usec    = tv.tv_usec;
270             wine_server_add_data( req, handles, count * sizeof(HANDLE) );
271
272             if (wait_all) req->flags |= SELECT_ALL;
273             if (alertable) req->flags |= SELECT_ALERTABLE;
274             if (timeout != INFINITE) req->flags |= SELECT_TIMEOUT;
275
276             ret = wine_server_call( req );
277         }
278         SERVER_END_REQ;
279         if (ret == STATUS_PENDING) ret = wait_reply( &cookie );
280         if (ret != STATUS_USER_APC) break;
281         call_apcs( alertable );
282         if (alertable) break;
283     }
284     if (HIWORD(ret))  /* is it an error code? */
285     {
286         SetLastError( RtlNtStatusToDosError(ret) );
287         ret = WAIT_FAILED;
288     }
289     return ret;
290 }
291
292
293 /***********************************************************************
294  *           WaitForSingleObject   (KERNEL.460)
295  */
296 DWORD WINAPI WaitForSingleObject16( HANDLE handle, DWORD timeout )
297 {
298     DWORD retval, mutex_count;
299
300     ReleaseThunkLock( &mutex_count );
301     retval = WaitForSingleObject( handle, timeout );
302     RestoreThunkLock( mutex_count );
303     return retval;
304 }
305
306 /***********************************************************************
307  *           WaitForMultipleObjects   (KERNEL.461)
308  */
309 DWORD WINAPI WaitForMultipleObjects16( DWORD count, const HANDLE *handles,
310                                        BOOL wait_all, DWORD timeout )
311 {
312     DWORD retval, mutex_count;
313
314     ReleaseThunkLock( &mutex_count );
315     retval = WaitForMultipleObjectsEx( count, handles, wait_all, timeout, FALSE );
316     RestoreThunkLock( mutex_count );
317     return retval;
318 }
319
320 /***********************************************************************
321  *           WaitForMultipleObjectsEx   (KERNEL.495)
322  */
323 DWORD WINAPI WaitForMultipleObjectsEx16( DWORD count, const HANDLE *handles,
324                                          BOOL wait_all, DWORD timeout, BOOL alertable )
325 {
326     DWORD retval, mutex_count;
327
328     ReleaseThunkLock( &mutex_count );
329     retval = WaitForMultipleObjectsEx( count, handles, wait_all, timeout, alertable );
330     RestoreThunkLock( mutex_count );
331     return retval;
332 }