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