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
  15 typedef struct
  16 {
  17     K32OBJ        header;
  18     THREAD_QUEUE  wait_queue;
  19     BOOL32        manual_reset;
  20     BOOL32        signaled;
  21 } EVENT;
  22
  23 static BOOL32 EVENT_Signaled( K32OBJ *obj, DWORD thread_id );
  24 static BOOL32 EVENT_Satisfied( K32OBJ *obj, DWORD thread_id );
  25 static void EVENT_AddWait( K32OBJ *obj, DWORD thread_id );
  26 static void EVENT_RemoveWait( K32OBJ *obj, DWORD thread_id );
  27 static void EVENT_Destroy( K32OBJ *obj );
  28
  29 const K32OBJ_OPS EVENT_Ops =
  30 {
  31     EVENT_Signaled,     /* signaled */
  32     EVENT_Satisfied,    /* satisfied */
  33     EVENT_AddWait,      /* add_wait */
  34     EVENT_RemoveWait,   /* remove_wait */
  35     NULL,               /* read */
  36     NULL,               /* write */
  37     EVENT_Destroy       /* destroy */
  38 };
  39
  40
  41 /***********************************************************************
  42  *           EVENT_Set
  43  *
  44  * Implementation of SetEvent. Used by ExitThread and ExitProcess.
  45  */
  46 void EVENT_Set( K32OBJ *obj )
  47 {
  48     EVENT *event = (EVENT *)obj;
  49     assert( obj->type == K32OBJ_EVENT );
  50     SYSTEM_LOCK();
  51     event->signaled = TRUE;
  52     SYNC_WakeUp( &event->wait_queue, event->manual_reset ? INFINITE32 : 1 );
  53     SYSTEM_UNLOCK();
  54 }
  55
  56 /***********************************************************************
  57  *           EVENT_Create
  58  *
  59  * Partial implementation of CreateEvent.
  60  * Used internally by processes and threads.
  61  */
  62 K32OBJ *EVENT_Create( BOOL32 manual_reset, BOOL32 initial_state )
  63 {
  64     EVENT *event;
  65
  66     SYSTEM_LOCK();
  67     if ((event = HeapAlloc( SystemHeap, 0, sizeof(*event) )))
  68     {
  69         event->header.type     = K32OBJ_EVENT;
  70         event->header.refcount = 1;
  71         event->wait_queue      = NULL;
  72         event->manual_reset    = manual_reset;
  73         event->signaled        = initial_state;
  74     }
  75     SYSTEM_UNLOCK();
  76     return event ? &event->header : NULL;
  77 }
  78
  79
  80 /***********************************************************************
  81  *           CreateEvent32A    (KERNEL32.156)
  82  */
  83 HANDLE32 WINAPI CreateEvent32A( SECURITY_ATTRIBUTES *sa, BOOL32 manual_reset,
  84                                 BOOL32 initial_state, LPCSTR name )
  85 {
  86     HANDLE32 handle;
  87     EVENT *event;
  88
  89     SYSTEM_LOCK();
  90     event = (EVENT *)K32OBJ_Create( K32OBJ_EVENT, sizeof(*event),
  91                                     name, EVENT_ALL_ACCESS, sa, &handle );
  92     if (event)
  93     {
  94         /* Finish initializing it */
  95         event->wait_queue   = NULL;
  96         event->manual_reset = manual_reset;
  97         event->signaled     = initial_state;
  98         K32OBJ_DecCount( &event->header );
  99     }
 100     SYSTEM_UNLOCK();
 101     return handle;
 102 }
 103
 104
 105 /***********************************************************************
 106  *           CreateEvent32W    (KERNEL32.157)
 107  */
 108 HANDLE32 WINAPI CreateEvent32W( SECURITY_ATTRIBUTES *sa, BOOL32 manual_reset,
 109                                 BOOL32 initial_state, LPCWSTR name )
 110 {
 111     LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
 112     HANDLE32 ret = CreateEvent32A( sa, manual_reset, initial_state, nameA );
 113     if (nameA) HeapFree( GetProcessHeap(), 0, nameA );
 114     return ret;
 115 }
 116
 117
 118 /***********************************************************************
 119  *           OpenEvent32A    (KERNEL32.536)
 120  */
 121 HANDLE32 WINAPI OpenEvent32A( DWORD access, BOOL32 inherit, LPCSTR name )
 122 {
 123     HANDLE32 handle = 0;
 124     K32OBJ *obj;
 125     SYSTEM_LOCK();
 126     if ((obj = K32OBJ_FindNameType( name, K32OBJ_EVENT )) != NULL)
 127     {
 128         handle = HANDLE_Alloc( PROCESS_Current(), obj, access, inherit );
 129         K32OBJ_DecCount( obj );
 130     }
 131     SYSTEM_UNLOCK();
 132     return handle;
 133 }
 134
 135
 136 /***********************************************************************
 137  *           OpenEvent32W    (KERNEL32.537)
 138  */
 139 HANDLE32 WINAPI OpenEvent32W( DWORD access, BOOL32 inherit, LPCWSTR name )
 140 {
 141     LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
 142     HANDLE32 ret = OpenEvent32A( access, inherit, nameA );
 143     if (nameA) HeapFree( GetProcessHeap(), 0, nameA );
 144     return ret;
 145 }
 146
 147
 148 /***********************************************************************
 149  *           PulseEvent    (KERNEL32.557)
 150  */
 151 BOOL32 WINAPI PulseEvent( HANDLE32 handle )
 152 {
 153     EVENT *event;
 154     SYSTEM_LOCK();
 155     if (!(event = (EVENT *)HANDLE_GetObjPtr(PROCESS_Current(), handle,
 156                                             K32OBJ_EVENT, EVENT_MODIFY_STATE)))
 157     {
 158         SYSTEM_UNLOCK();
 159         return FALSE;
 160     }
 161     event->signaled = TRUE;
 162     SYNC_WakeUp( &event->wait_queue, event->manual_reset ? INFINITE32 : 1 );
 163     event->signaled = FALSE;
 164     K32OBJ_DecCount( &event->header );
 165     SYSTEM_UNLOCK();
 166     return TRUE;
 167 }
 168
 169
 170 /***********************************************************************
 171  *           SetEvent    (KERNEL32.644)
 172  */
 173 BOOL32 WINAPI SetEvent( HANDLE32 handle )
 174 {
 175     EVENT *event;
 176     SYSTEM_LOCK();
 177     if (!(event = (EVENT *)HANDLE_GetObjPtr(PROCESS_Current(), handle,
 178                                             K32OBJ_EVENT, EVENT_MODIFY_STATE)))
 179     {
 180         SYSTEM_UNLOCK();
 181         return FALSE;
 182     }
 183     event->signaled = TRUE;
 184     SYNC_WakeUp( &event->wait_queue, event->manual_reset ? INFINITE32 : 1 );
 185     K32OBJ_DecCount( &event->header );
 186     SYSTEM_UNLOCK();
 187     return TRUE;
 188 }
 189
 190
 191 /***********************************************************************
 192  *           ResetEvent    (KERNEL32.586)
 193  */
 194 BOOL32 WINAPI ResetEvent( HANDLE32 handle )
 195 {
 196     EVENT *event;
 197     SYSTEM_LOCK();
 198     if (!(event = (EVENT *)HANDLE_GetObjPtr(PROCESS_Current(), handle,
 199                                             K32OBJ_EVENT, EVENT_MODIFY_STATE)))
 200     {
 201         SYSTEM_UNLOCK();
 202         return FALSE;
 203     }
 204     event->signaled = FALSE;
 205     K32OBJ_DecCount( &event->header );
 206     SYSTEM_UNLOCK();
 207     return TRUE;
 208 }
 209
 210
 211 /***********************************************************************
 212  *           EVENT_Signaled
 213  */
 214 static BOOL32 EVENT_Signaled( K32OBJ *obj, DWORD thread_id )
 215 {
 216     EVENT *event = (EVENT *)obj;
 217     assert( obj->type == K32OBJ_EVENT );
 218     return event->signaled;
 219 }
 220
 221
 222 /***********************************************************************
 223  *           EVENT_Satisfied
 224  *
 225  * Wait on this object has been satisfied.
 226  */
 227 static BOOL32 EVENT_Satisfied( K32OBJ *obj, DWORD thread_id )
 228 {
 229     EVENT *event = (EVENT *)obj;
 230     assert( obj->type == K32OBJ_EVENT );
 231     /* Reset if it's an auto-reset event */
 232     if (!event->manual_reset) event->signaled = FALSE;
 233     return FALSE;  /* Not abandoned */
 234 }
 235
 236
 237 /***********************************************************************
 238  *           EVENT_AddWait
 239  *
 240  * Add thread to object wait queue.
 241  */
 242 static void EVENT_AddWait( K32OBJ *obj, DWORD thread_id )
 243 {
 244     EVENT *event = (EVENT *)obj;
 245     assert( obj->type == K32OBJ_EVENT );
 246     THREAD_AddQueue( &event->wait_queue, THREAD_ID_TO_THDB(thread_id) );
 247 }
 248
 249
 250 /***********************************************************************
 251  *           EVENT_RemoveWait
 252  *
 253  * Remove thread from object wait queue.
 254  */
 255 static void EVENT_RemoveWait( K32OBJ *obj, DWORD thread_id )
 256 {
 257     EVENT *event = (EVENT *)obj;
 258     assert( obj->type == K32OBJ_EVENT );
 259     THREAD_RemoveQueue( &event->wait_queue, THREAD_ID_TO_THDB(thread_id) );
 260 }
 261
 262
 263 /***********************************************************************
 264  *           EVENT_Destroy
 265  */
 266 static void EVENT_Destroy( K32OBJ *obj )
 267 {
 268     EVENT *event = (EVENT *)obj;
 269     assert( obj->type == K32OBJ_EVENT );
 270     /* There cannot be any thread on the list since the ref count is 0 */
 271     assert( event->wait_queue == NULL );
 272     obj->type = K32OBJ_UNKNOWN;
 273     HeapFree( SystemHeap, 0, event );
 274 }