scheduler/synchro.c

   1 /*
   2  * Win32 process and thread synchronisation
   3  *
   4  * Copyright 1997 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include "winbase.h"
  24 #include "winternl.h"
  25 #include "../kernel/kernel_private.h" /* FIXME: to be changed when moving file to dlls/kernel */
  26
  27
  28 /***********************************************************************
  29  *              Sleep  (KERNEL32.@)
  30  */
  31 VOID WINAPI Sleep( DWORD timeout )
  32 {
  33     WaitForMultipleObjectsEx( 0, NULL, FALSE, timeout, FALSE );
  34 }
  35
  36 /******************************************************************************
  37  *              SleepEx   (KERNEL32.@)
  38  */
  39 DWORD WINAPI SleepEx( DWORD timeout, BOOL alertable )
  40 {
  41     DWORD ret = WaitForMultipleObjectsEx( 0, NULL, FALSE, timeout, alertable );
  42     if (ret != WAIT_IO_COMPLETION) ret = 0;
  43     return ret;
  44 }
  45
  46
  47 /***********************************************************************
  48  *           WaitForSingleObject   (KERNEL32.@)
  49  */
  50 DWORD WINAPI WaitForSingleObject( HANDLE handle, DWORD timeout )
  51 {
  52     return WaitForMultipleObjectsEx( 1, &handle, FALSE, timeout, FALSE );
  53 }
  54
  55
  56 /***********************************************************************
  57  *           WaitForSingleObjectEx   (KERNEL32.@)
  58  */
  59 DWORD WINAPI WaitForSingleObjectEx( HANDLE handle, DWORD timeout,
  60                                     BOOL alertable )
  61 {
  62     return WaitForMultipleObjectsEx( 1, &handle, FALSE, timeout, alertable );
  63 }
  64
  65
  66 /***********************************************************************
  67  *           WaitForMultipleObjects   (KERNEL32.@)
  68  */
  69 DWORD WINAPI WaitForMultipleObjects( DWORD count, const HANDLE *handles,
  70                                      BOOL wait_all, DWORD timeout )
  71 {
  72     return WaitForMultipleObjectsEx( count, handles, wait_all, timeout, FALSE );
  73 }
  74
  75
  76 /***********************************************************************
  77  *           WaitForMultipleObjectsEx   (KERNEL32.@)
  78  */
  79 DWORD WINAPI WaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
  80                                        BOOL wait_all, DWORD timeout,
  81                                        BOOL alertable )
  82 {
  83     NTSTATUS status;
  84     HANDLE hloc[MAXIMUM_WAIT_OBJECTS];
  85     int i;
  86
  87     if (count >= MAXIMUM_WAIT_OBJECTS)
  88     {
  89         SetLastError(ERROR_INVALID_PARAMETER);
  90         return WAIT_FAILED;
  91     }
  92     for (i = 0; i < count; i++)
  93     {
  94         if ((handles[i] == (HANDLE)STD_INPUT_HANDLE) ||
  95             (handles[i] == (HANDLE)STD_OUTPUT_HANDLE) ||
  96             (handles[i] == (HANDLE)STD_ERROR_HANDLE))
  97             hloc[i] = GetStdHandle( (DWORD)handles[i] );
  98         else
  99             hloc[i] = handles[i];
 100
 101         /* yes, even screen buffer console handles are waitable, and are
 102          * handled as a handle to the console itself !!
 103          */
 104         if (is_console_handle(hloc[i]))
 105         {
 106             if (!VerifyConsoleIoHandle(hloc[i]))
 107             {
 108                 return FALSE;
 109             }
 110             hloc[i] = GetConsoleInputWaitHandle();
 111         }
 112     }
 113
 114     if (timeout == INFINITE)
 115     {
 116         status = NtWaitForMultipleObjects( count, hloc, wait_all, alertable, NULL );
 117     }
 118     else
 119     {
 120         LARGE_INTEGER time;
 121
 122         time.QuadPart = timeout * (ULONGLONG)10000;
 123         time.QuadPart = -time.QuadPart;
 124         status = NtWaitForMultipleObjects( count, hloc, wait_all, alertable, &time );
 125     }
 126
 127     if (HIWORD(status))  /* is it an error code? */
 128     {
 129         SetLastError( RtlNtStatusToDosError(status) );
 130         status = WAIT_FAILED;
 131     }
 132     return status;
 133 }
 134
 135
 136 /***********************************************************************
 137  *           WaitForSingleObject   (KERNEL.460)
 138  */
 139 DWORD WINAPI WaitForSingleObject16( HANDLE handle, DWORD timeout )
 140 {
 141     DWORD retval, mutex_count;
 142
 143     ReleaseThunkLock( &mutex_count );
 144     retval = WaitForSingleObject( handle, timeout );
 145     RestoreThunkLock( mutex_count );
 146     return retval;
 147 }
 148
 149 /***********************************************************************
 150  *           WaitForMultipleObjects   (KERNEL.461)
 151  */
 152 DWORD WINAPI WaitForMultipleObjects16( DWORD count, const HANDLE *handles,
 153                                        BOOL wait_all, DWORD timeout )
 154 {
 155     DWORD retval, mutex_count;
 156
 157     ReleaseThunkLock( &mutex_count );
 158     retval = WaitForMultipleObjectsEx( count, handles, wait_all, timeout, FALSE );
 159     RestoreThunkLock( mutex_count );
 160     return retval;
 161 }
 162
 163 /***********************************************************************
 164  *           WaitForMultipleObjectsEx   (KERNEL.495)
 165  */
 166 DWORD WINAPI WaitForMultipleObjectsEx16( DWORD count, const HANDLE *handles,
 167                                          BOOL wait_all, DWORD timeout, BOOL alertable )
 168 {
 169     DWORD retval, mutex_count;
 170
 171     ReleaseThunkLock( &mutex_count );
 172     retval = WaitForMultipleObjectsEx( count, handles, wait_all, timeout, alertable );
 173     RestoreThunkLock( mutex_count );
 174     return retval;
 175 }