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