scheduler/synchro.c

   1 /*
   2  * Win32 process and thread synchronisation
   3  *
   4  * Copyright 1997 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include <signal.h>
   9 #include <sys/time.h>
  10 #include <unistd.h>
  11 #include "heap.h"
  12 #include "file.h"  /* for DOSFS_UnixTimeToFileTime */
  13 #include "thread.h"
  14 #include "winerror.h"
  15 #include "server.h"
  16
  17
  18 /***********************************************************************
  19  *              get_timeout
  20  */
  21 inline static void get_timeout( struct timeval *when, int timeout )
  22 {
  23     gettimeofday( when, 0 );
  24     if (timeout)
  25     {
  26         long sec = timeout / 1000;
  27         if ((when->tv_usec += (timeout - 1000*sec) * 1000) >= 1000000)
  28         {
  29             when->tv_usec -= 1000000;
  30             when->tv_sec++;
  31         }
  32         when->tv_sec += sec;
  33     }
  34 }
  35
  36
  37 /***********************************************************************
  38  *              call_apcs
  39  *
  40  * Call outstanding APCs.
  41  */
  42 static void call_apcs( BOOL alertable )
  43 {
  44     FARPROC proc = NULL;
  45     FILETIME ft;
  46     void *args[4];
  47
  48     for (;;)
  49     {
  50         int type = APC_NONE;
  51         SERVER_START_REQ
  52         {
  53             struct get_apc_request *req = server_alloc_req( sizeof(*req), sizeof(args) );
  54             req->alertable = alertable;
  55             if (!server_call( REQ_GET_APC ))
  56             {
  57                 type = req->type;
  58                 proc = req->func;
  59                 memcpy( args, server_data_ptr(req), server_data_size(req) );
  60             }
  61         }
  62         SERVER_END_REQ;
  63
  64         switch(type)
  65         {
  66         case APC_NONE:
  67             return;  /* no more APCs */
  68         case APC_ASYNC:
  69             proc( &args[0] );
  70             break;
  71         case APC_USER:
  72             proc( args[0] );
  73             break;
  74         case APC_TIMER:
  75             /* convert sec/usec to NT time */
  76             DOSFS_UnixTimeToFileTime( (time_t)args[0], &ft, (DWORD)args[1] * 10 );
  77             proc( args[2], ft.dwLowDateTime, ft.dwHighDateTime );
  78             break;
  79         default:
  80             server_protocol_error( "get_apc_request: bad type %d\n", type );
  81             break;
  82         }
  83     }
  84 }
  85
  86 /***********************************************************************
  87  *              Sleep  (KERNEL32.679)
  88  */
  89 VOID WINAPI Sleep( DWORD timeout )
  90 {
  91     WaitForMultipleObjectsEx( 0, NULL, FALSE, timeout, FALSE );
  92 }
  93
  94 /******************************************************************************
  95  *              SleepEx   (KERNEL32.680)
  96  */
  97 DWORD WINAPI SleepEx( DWORD timeout, BOOL alertable )
  98 {
  99     DWORD ret = WaitForMultipleObjectsEx( 0, NULL, FALSE, timeout, alertable );
 100     if (ret != WAIT_IO_COMPLETION) ret = 0;
 101     return ret;
 102 }
 103
 104
 105 /***********************************************************************
 106  *           WaitForSingleObject   (KERNEL32.723)
 107  */
 108 DWORD WINAPI WaitForSingleObject( HANDLE handle, DWORD timeout )
 109 {
 110     return WaitForMultipleObjectsEx( 1, &handle, FALSE, timeout, FALSE );
 111 }
 112
 113
 114 /***********************************************************************
 115  *           WaitForSingleObjectEx   (KERNEL32.724)
 116  */
 117 DWORD WINAPI WaitForSingleObjectEx( HANDLE handle, DWORD timeout,
 118                                     BOOL alertable )
 119 {
 120     return WaitForMultipleObjectsEx( 1, &handle, FALSE, timeout, alertable );
 121 }
 122
 123
 124 /***********************************************************************
 125  *           WaitForMultipleObjects   (KERNEL32.721)
 126  */
 127 DWORD WINAPI WaitForMultipleObjects( DWORD count, const HANDLE *handles,
 128                                      BOOL wait_all, DWORD timeout )
 129 {
 130     return WaitForMultipleObjectsEx( count, handles, wait_all, timeout, FALSE );
 131 }
 132
 133
 134 /***********************************************************************
 135  *           WaitForMultipleObjectsEx   (KERNEL32.722)
 136  */
 137 DWORD WINAPI WaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
 138                                        BOOL wait_all, DWORD timeout,
 139                                        BOOL alertable )
 140 {
 141     int i, ret;
 142     struct timeval tv;
 143
 144     if (count > MAXIMUM_WAIT_OBJECTS)
 145     {
 146         SetLastError( ERROR_INVALID_PARAMETER );
 147         return WAIT_FAILED;
 148     }
 149
 150     if (timeout == INFINITE) tv.tv_sec = tv.tv_usec = 0;
 151     else get_timeout( &tv, timeout );
 152
 153     for (;;)
 154     {
 155         SERVER_START_REQ
 156         {
 157             struct select_request *req = server_alloc_req( sizeof(*req), count * sizeof(int) );
 158             int *data = server_data_ptr( req );
 159
 160             req->flags   = SELECT_INTERRUPTIBLE;
 161             req->sec     = tv.tv_sec;
 162             req->usec    = tv.tv_usec;
 163             for (i = 0; i < count; i++) data[i] = handles[i];
 164
 165             if (wait_all) req->flags |= SELECT_ALL;
 166             if (alertable) req->flags |= SELECT_ALERTABLE;
 167             if (timeout != INFINITE) req->flags |= SELECT_TIMEOUT;
 168
 169             server_call( REQ_SELECT );
 170             ret = req->signaled;
 171         }
 172         SERVER_END_REQ;
 173         if (ret != STATUS_USER_APC) break;
 174         call_apcs( alertable );
 175         if (alertable) break;
 176     }
 177     return ret;
 178 }
 179
 180
 181 /***********************************************************************
 182  *           WIN16_WaitForSingleObject   (KERNEL.460)
 183  */
 184 DWORD WINAPI WIN16_WaitForSingleObject( HANDLE handle, DWORD timeout )
 185 {
 186     DWORD retval, mutex_count;
 187
 188     ReleaseThunkLock( &mutex_count );
 189     retval = WaitForSingleObject( handle, timeout );
 190     RestoreThunkLock( mutex_count );
 191     return retval;
 192 }
 193
 194 /***********************************************************************
 195  *           WIN16_WaitForMultipleObjects   (KERNEL.461)
 196  */
 197 DWORD WINAPI WIN16_WaitForMultipleObjects( DWORD count, const HANDLE *handles,
 198                                            BOOL wait_all, DWORD timeout )
 199 {
 200     DWORD retval, mutex_count;
 201
 202     ReleaseThunkLock( &mutex_count );
 203     retval = WaitForMultipleObjects( count, handles, wait_all, timeout );
 204     RestoreThunkLock( mutex_count );
 205     return retval;
 206 }
 207
 208 /***********************************************************************
 209  *           WIN16_WaitForMultipleObjectsEx   (KERNEL.495)
 210  */
 211 DWORD WINAPI WIN16_WaitForMultipleObjectsEx( DWORD count,
 212                                              const HANDLE *handles,
 213                                              BOOL wait_all, DWORD timeout,
 214                                              BOOL alertable )
 215 {
 216     DWORD retval, mutex_count;
 217
 218     ReleaseThunkLock( &mutex_count );
 219     retval = WaitForMultipleObjectsEx( count, handles, wait_all, timeout, alertable );
 220     RestoreThunkLock( mutex_count );
 221     return retval;
 222 }
 223