scheduler/event.c

   1 /*
   2  * Win32 events
   3  *
   4  * Copyright 1998 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include "windows.h"
   9 #include "winerror.h"
  10 #include "k32obj.h"
  11 #include "process.h"
  12 #include "thread.h"
  13 #include "heap.h"
  14 #include "syslevel.h"
  15 #include "server/request.h"
  16 #include "server.h"
  17
  18 typedef struct
  19 {
  20     K32OBJ        header;
  21     THREAD_QUEUE  wait_queue;
  22     BOOL32        manual_reset;
  23     BOOL32        signaled;
  24 } EVENT;
  25
  26 static BOOL32 EVENT_Signaled( K32OBJ *obj, DWORD thread_id );
  27 static BOOL32 EVENT_Satisfied( K32OBJ *obj, DWORD thread_id );
  28 static void EVENT_AddWait( K32OBJ *obj, DWORD thread_id );
  29 static void EVENT_RemoveWait( K32OBJ *obj, DWORD thread_id );
  30 static void EVENT_Destroy( K32OBJ *obj );
  31
  32 const K32OBJ_OPS EVENT_Ops =
  33 {
  34     EVENT_Signaled,     /* signaled */
  35     EVENT_Satisfied,    /* satisfied */
  36     EVENT_AddWait,      /* add_wait */
  37     EVENT_RemoveWait,   /* remove_wait */
  38     NULL,               /* read */
  39     NULL,               /* write */
  40     EVENT_Destroy       /* destroy */
  41 };
  42
  43
  44 /***********************************************************************
  45  *           EVENT_Set
  46  *
  47  * Implementation of SetEvent. Used by ExitThread and ExitProcess.
  48  */
  49 void EVENT_Set( K32OBJ *obj )
  50 {
  51     EVENT *event = (EVENT *)obj;
  52     assert( obj->type == K32OBJ_EVENT );
  53     SYSTEM_LOCK();
  54     event->signaled = TRUE;
  55     SYNC_WakeUp( &event->wait_queue, event->manual_reset ? INFINITE32 : 1 );
  56     SYSTEM_UNLOCK();
  57 }
  58
  59 /***********************************************************************
  60  *           EVENT_Create
  61  *
  62  * Partial implementation of CreateEvent.
  63  * Used internally by processes and threads.
  64  */
  65 K32OBJ *EVENT_Create( BOOL32 manual_reset, BOOL32 initial_state )
  66 {
  67     EVENT *event;
  68
  69     SYSTEM_LOCK();
  70     if ((event = HeapAlloc( SystemHeap, 0, sizeof(*event) )))
  71     {
  72         event->header.type     = K32OBJ_EVENT;
  73         event->header.refcount = 1;
  74         event->wait_queue      = NULL;
  75         event->manual_reset    = manual_reset;
  76         event->signaled        = initial_state;
  77     }
  78     SYSTEM_UNLOCK();
  79     return event ? &event->header : NULL;
  80 }
  81
  82
  83 /***********************************************************************
  84  *           CreateEvent32A    (KERNEL32.156)
  85  */
  86 HANDLE32 WINAPI CreateEvent32A( SECURITY_ATTRIBUTES *sa, BOOL32 manual_reset,
  87                                 BOOL32 initial_state, LPCSTR name )
  88 {
  89     struct create_event_request req;
  90     struct create_event_reply reply;
  91     int len = name ? strlen(name) + 1 : 0;
  92     HANDLE32 handle;
  93     EVENT *event;
  94
  95     req.manual_reset = manual_reset;
  96     req.initial_state = initial_state;
  97     req.inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
  98
  99     CLIENT_SendRequest( REQ_CREATE_EVENT, -1, 2, &req, sizeof(req), name, len );
 100     CLIENT_WaitReply( &len, NULL, 1, &reply, sizeof(reply) );
 101     CHECK_LEN( len, sizeof(reply) );
 102     if (reply.handle == -1) return NULL;
 103
 104     SYSTEM_LOCK();
 105     event = (EVENT *)K32OBJ_Create( K32OBJ_EVENT, sizeof(*event), name,
 106                                     reply.handle, EVENT_ALL_ACCESS, sa, &handle );
 107     if (event)
 108     {
 109         /* Finish initializing it */
 110         event->wait_queue   = NULL;
 111         event->manual_reset = manual_reset;
 112         event->signaled     = initial_state;
 113         K32OBJ_DecCount( &event->header );
 114     }
 115     SYSTEM_UNLOCK();
 116     return handle;
 117 }
 118
 119
 120 /***********************************************************************
 121  *           CreateEvent32W    (KERNEL32.157)
 122  */
 123 HANDLE32 WINAPI CreateEvent32W( SECURITY_ATTRIBUTES *sa, BOOL32 manual_reset,
 124                                 BOOL32 initial_state, LPCWSTR name )
 125 {
 126     LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
 127     HANDLE32 ret = CreateEvent32A( sa, manual_reset, initial_state, nameA );
 128     if (nameA) HeapFree( GetProcessHeap(), 0, nameA );
 129     return ret;
 130 }
 131
 132 /***********************************************************************
 133  *           WIN16_CreateEvent    (KERNEL.457)
 134  */
 135 HANDLE32 WINAPI WIN16_CreateEvent( BOOL32 manual_reset, BOOL32 initial_state )
 136 {
 137     return CreateEvent32A( NULL, manual_reset, initial_state, NULL );
 138 }
 139
 140
 141 /***********************************************************************
 142  *           OpenEvent32A    (KERNEL32.536)
 143  */
 144 HANDLE32 WINAPI OpenEvent32A( DWORD access, BOOL32 inherit, LPCSTR name )
 145 {
 146     HANDLE32 handle = 0;
 147     K32OBJ *obj;
 148     SYSTEM_LOCK();
 149     if ((obj = K32OBJ_FindNameType( name, K32OBJ_EVENT )) != NULL)
 150     {
 151         handle = HANDLE_Alloc( PROCESS_Current(), obj, access, inherit, -1 );
 152         K32OBJ_DecCount( obj );
 153     }
 154     SYSTEM_UNLOCK();
 155     return handle;
 156 }
 157
 158
 159 /***********************************************************************
 160  *           OpenEvent32W    (KERNEL32.537)
 161  */
 162 HANDLE32 WINAPI OpenEvent32W( DWORD access, BOOL32 inherit, LPCWSTR name )
 163 {
 164     LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
 165     HANDLE32 ret = OpenEvent32A( access, inherit, nameA );
 166     if (nameA) HeapFree( GetProcessHeap(), 0, nameA );
 167     return ret;
 168 }
 169
 170
 171 /***********************************************************************
 172  *           PulseEvent    (KERNEL32.557)
 173  */
 174 BOOL32 WINAPI PulseEvent( HANDLE32 handle )
 175 {
 176     struct event_op_request req;
 177     EVENT *event;
 178     SYSTEM_LOCK();
 179     if (!(event = (EVENT *)HANDLE_GetObjPtr(PROCESS_Current(), handle,
 180                                             K32OBJ_EVENT, EVENT_MODIFY_STATE,
 181                                             &req.handle )))
 182     {
 183         SYSTEM_UNLOCK();
 184         return FALSE;
 185     }
 186     if (req.handle != -1)
 187     {
 188         SYSTEM_UNLOCK();
 189         req.op = PULSE_EVENT;
 190         CLIENT_SendRequest( REQ_EVENT_OP, -1, 1, &req, sizeof(req) );
 191         return !CLIENT_WaitReply( NULL, NULL, 0 );
 192     }
 193     event->signaled = TRUE;
 194     SYNC_WakeUp( &event->wait_queue, event->manual_reset ? INFINITE32 : 1 );
 195     event->signaled = FALSE;
 196     K32OBJ_DecCount( &event->header );
 197     SYSTEM_UNLOCK();
 198     return TRUE;
 199 }
 200
 201
 202 /***********************************************************************
 203  *           SetEvent    (KERNEL32.644)
 204  */
 205 BOOL32 WINAPI SetEvent( HANDLE32 handle )
 206 {
 207     struct event_op_request req;
 208     EVENT *event;
 209     SYSTEM_LOCK();
 210     if (!(event = (EVENT *)HANDLE_GetObjPtr(PROCESS_Current(), handle,
 211                                             K32OBJ_EVENT, EVENT_MODIFY_STATE,
 212                                             &req.handle )))
 213     {
 214         SYSTEM_UNLOCK();
 215         return FALSE;
 216     }
 217     if (req.handle != -1)
 218     {
 219         SYSTEM_UNLOCK();
 220         req.op = SET_EVENT;
 221         CLIENT_SendRequest( REQ_EVENT_OP, -1, 1, &req, sizeof(req) );
 222         return !CLIENT_WaitReply( NULL, NULL, 0 );
 223     }
 224     event->signaled = TRUE;
 225     SYNC_WakeUp( &event->wait_queue, event->manual_reset ? INFINITE32 : 1 );
 226     K32OBJ_DecCount( &event->header );
 227     SYSTEM_UNLOCK();
 228     return TRUE;
 229 }
 230
 231
 232 /***********************************************************************
 233  *           ResetEvent    (KERNEL32.586)
 234  */
 235 BOOL32 WINAPI ResetEvent( HANDLE32 handle )
 236 {
 237     struct event_op_request req;
 238     EVENT *event;
 239     SYSTEM_LOCK();
 240     if (!(event = (EVENT *)HANDLE_GetObjPtr(PROCESS_Current(), handle,
 241                                             K32OBJ_EVENT, EVENT_MODIFY_STATE,
 242                                             &req.handle )))
 243     {
 244         SYSTEM_UNLOCK();
 245         return FALSE;
 246     }
 247     if (req.handle != -1)
 248     {
 249         SYSTEM_UNLOCK();
 250         req.op = RESET_EVENT;
 251         CLIENT_SendRequest( REQ_EVENT_OP, -1, 1, &req, sizeof(req) );
 252         return !CLIENT_WaitReply( NULL, NULL, 0 );
 253     }
 254     event->signaled = FALSE;
 255     K32OBJ_DecCount( &event->header );
 256     SYSTEM_UNLOCK();
 257     return TRUE;
 258 }
 259
 260
 261 /***********************************************************************
 262  *           EVENT_Signaled
 263  */
 264 static BOOL32 EVENT_Signaled( K32OBJ *obj, DWORD thread_id )
 265 {
 266     EVENT *event = (EVENT *)obj;
 267     assert( obj->type == K32OBJ_EVENT );
 268     return event->signaled;
 269 }
 270
 271
 272 /***********************************************************************
 273  *           EVENT_Satisfied
 274  *
 275  * Wait on this object has been satisfied.
 276  */
 277 static BOOL32 EVENT_Satisfied( K32OBJ *obj, DWORD thread_id )
 278 {
 279     EVENT *event = (EVENT *)obj;
 280     assert( obj->type == K32OBJ_EVENT );
 281     /* Reset if it's an auto-reset event */
 282     if (!event->manual_reset) event->signaled = FALSE;
 283     return FALSE;  /* Not abandoned */
 284 }
 285
 286
 287 /***********************************************************************
 288  *           EVENT_AddWait
 289  *
 290  * Add thread to object wait queue.
 291  */
 292 static void EVENT_AddWait( K32OBJ *obj, DWORD thread_id )
 293 {
 294     EVENT *event = (EVENT *)obj;
 295     assert( obj->type == K32OBJ_EVENT );
 296     THREAD_AddQueue( &event->wait_queue, THREAD_ID_TO_THDB(thread_id) );
 297 }
 298
 299
 300 /***********************************************************************
 301  *           EVENT_RemoveWait
 302  *
 303  * Remove thread from object wait queue.
 304  */
 305 static void EVENT_RemoveWait( K32OBJ *obj, DWORD thread_id )
 306 {
 307     EVENT *event = (EVENT *)obj;
 308     assert( obj->type == K32OBJ_EVENT );
 309     THREAD_RemoveQueue( &event->wait_queue, THREAD_ID_TO_THDB(thread_id) );
 310 }
 311
 312
 313 /***********************************************************************
 314  *           EVENT_Destroy
 315  */
 316 static void EVENT_Destroy( K32OBJ *obj )
 317 {
 318     EVENT *event = (EVENT *)obj;
 319     assert( obj->type == K32OBJ_EVENT );
 320     /* There cannot be any thread on the list since the ref count is 0 */
 321     assert( event->wait_queue == NULL );
 322     obj->type = K32OBJ_UNKNOWN;
 323     HeapFree( SystemHeap, 0, event );
 324 }
 325
 326
 327
 328
 329 /***********************************************************************
 330  * NOTE: The Win95 VWin32_Event routines given below are really low-level
 331  *       routines implemented directly by VWin32. The user-mode libraries
 332  *       implement Win32 synchronisation routines on top of these low-level
 333  *       primitives. We do it the other way around here :-)
 334  */
 335
 336 /***********************************************************************
 337  *       VWin32_EventCreate     (KERNEL.442)
 338  */
 339 HANDLE32 WINAPI VWin32_EventCreate(VOID)
 340 {
 341     return CreateEvent32A( NULL, FALSE, 0, NULL );
 342 }
 343
 344 /***********************************************************************
 345  *       VWin32_EventDestroy    (KERNEL.443)
 346  */
 347 VOID WINAPI VWin32_EventDestroy(HANDLE32 event)
 348 {
 349     CloseHandle( event );
 350 }
 351
 352 /***********************************************************************
 353  *       VWin32_EventWait       (KERNEL.450)
 354  */
 355 VOID WINAPI VWin32_EventWait(HANDLE32 event)
 356 {
 357     SYSLEVEL_ReleaseWin16Lock();
 358     WaitForSingleObject( event, INFINITE32 );
 359     SYSLEVEL_RestoreWin16Lock();
 360 }
 361
 362 /***********************************************************************
 363  *       VWin32_EventSet        (KERNEL.451)
 364  */
 365 VOID WINAPI VWin32_EventSet(HANDLE32 event)
 366 {
 367     SetEvent( event );
 368 }
 369