ntoskrnl/ke/eventobj.c

   1 /*
   2  * PROJECT:         ReactOS Kernel
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            ntoskrnl/ke/event.c
   5  * PURPOSE:         Implements the Event Dispatcher Object
   6  * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include <ntoskrnl.h>
  12 #define NDEBUG
  13 #include <debug.h>
  14
  15 /* FUNCTIONS *****************************************************************/
  16
  17 /*
  18  * @implemented
  19  */
  20 VOID
  21 NTAPI
  22 KeClearEvent(IN PKEVENT Event)
  23 {
  24     ASSERT_EVENT(Event);
  25
  26     /* Reset Signal State */
  27     Event->Header.SignalState = FALSE;
  28 }
  29
  30 /*
  31  * @implemented
  32  */
  33 VOID
  34 NTAPI
  35 KeInitializeEvent(OUT PKEVENT Event,
  36                   IN EVENT_TYPE Type,
  37                   IN BOOLEAN State)
  38 {
  39     /* Initialize the Dispatcher Header */
  40     Event->Header.Type = Type;
  41     //Event->Header.Signalling = FALSE; // fails in kmtest
  42     Event->Header.Size = sizeof(KEVENT) / sizeof(ULONG);
  43     Event->Header.SignalState = State;
  44     InitializeListHead(&(Event->Header.WaitListHead));
  45 }
  46
  47 /*
  48  * @implemented
  49  */
  50 VOID
  51 NTAPI
  52 KeInitializeEventPair(IN PKEVENT_PAIR EventPair)
  53 {
  54     /* Initialize the Event Pair Type and Size */
  55     EventPair->Type = EventPairObject;
  56     EventPair->Size = sizeof(KEVENT_PAIR);
  57
  58     /* Initialize the two Events */
  59     KeInitializeEvent(&EventPair->LowEvent, SynchronizationEvent, FALSE);
  60     KeInitializeEvent(&EventPair->HighEvent, SynchronizationEvent, FALSE);
  61 }
  62
  63 /*
  64  * @implemented
  65  */
  66 LONG
  67 NTAPI
  68 KePulseEvent(IN PKEVENT Event,
  69              IN KPRIORITY Increment,
  70              IN BOOLEAN Wait)
  71 {
  72     KIRQL OldIrql;
  73     LONG PreviousState;
  74     PKTHREAD Thread;
  75     ASSERT_EVENT(Event);
  76     ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
  77
  78     /* Lock the Dispatcher Database */
  79     OldIrql = KiAcquireDispatcherLock();
  80
  81     /* Save the Old State */
  82     PreviousState = Event->Header.SignalState;
  83
  84     /* Check if we are non-signaled and we have stuff in the Wait Queue */
  85     if (!PreviousState && !IsListEmpty(&Event->Header.WaitListHead))
  86     {
  87         /* Set the Event to Signaled */
  88         Event->Header.SignalState = 1;
  89
  90         /* Wake the Event */
  91         KiWaitTest(&Event->Header, Increment);
  92     }
  93
  94     /* Unsignal it */
  95     Event->Header.SignalState = 0;
  96
  97     /* Check what wait state was requested */
  98     if (Wait == FALSE)
  99     {
 100         /* Wait not requested, release Dispatcher Database and return */
 101         KiReleaseDispatcherLock(OldIrql);
 102     }
 103     else
 104     {
 105         /* Return Locked and with a Wait */
 106         Thread = KeGetCurrentThread();
 107         Thread->WaitNext = TRUE;
 108         Thread->WaitIrql = OldIrql;
 109     }
 110
 111     /* Return the previous State */
 112     return PreviousState;
 113 }
 114
 115 /*
 116  * @implemented
 117  */
 118 LONG
 119 NTAPI
 120 KeReadStateEvent(IN PKEVENT Event)
 121 {
 122     ASSERT_EVENT(Event);
 123
 124     /* Return the Signal State */
 125     return Event->Header.SignalState;
 126 }
 127
 128 /*
 129  * @implemented
 130  */
 131 LONG
 132 NTAPI
 133 KeResetEvent(IN PKEVENT Event)
 134 {
 135     KIRQL OldIrql;
 136     LONG PreviousState;
 137     ASSERT_EVENT(Event);
 138     ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 139
 140     /* Lock the Dispatcher Database */
 141     OldIrql = KiAcquireDispatcherLock();
 142
 143     /* Save the Previous State */
 144     PreviousState = Event->Header.SignalState;
 145
 146     /* Set it to zero */
 147     Event->Header.SignalState = 0;
 148
 149     /* Release Dispatcher Database and return previous state */
 150     KiReleaseDispatcherLock(OldIrql);
 151     return PreviousState;
 152 }
 153
 154 /*
 155  * @implemented
 156  */
 157 LONG
 158 NTAPI
 159 KeSetEvent(IN PKEVENT Event,
 160            IN KPRIORITY Increment,
 161            IN BOOLEAN Wait)
 162 {
 163     KIRQL OldIrql;
 164     LONG PreviousState;
 165     PKTHREAD Thread;
 166     ASSERT_EVENT(Event);
 167     ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 168
 169     /*
 170      * Check if this is an signaled notification event without an upcoming wait.
 171      * In this case, we can immediately return TRUE, without locking.
 172      */
 173     if ((Event->Header.Type == EventNotificationObject) &&
 174         (Event->Header.SignalState == 1) &&
 175         !(Wait))
 176     {
 177         /* Return the signal state (TRUE/Signalled) */
 178         return TRUE;
 179     }
 180
 181     /* Lock the Dispathcer Database */
 182     OldIrql = KiAcquireDispatcherLock();
 183
 184     /* Save the Previous State */
 185     PreviousState = Event->Header.SignalState;
 186
 187     /* Set the Event to Signaled */
 188     Event->Header.SignalState = 1;
 189
 190     /* Check if the event just became signaled now, and it has waiters */
 191     if (!(PreviousState) && !(IsListEmpty(&Event->Header.WaitListHead)))
 192     {
 193         /* Check the type of event */
 194         if (Event->Header.Type == EventNotificationObject)
 195         {
 196             /* Unwait the thread */
 197             KxUnwaitThread(&Event->Header, Increment);
 198         }
 199         else
 200         {
 201             /* Otherwise unwait the thread and unsignal the event */
 202             KxUnwaitThreadForEvent(Event, Increment);
 203         }
 204     }
 205
 206     /* Check what wait state was requested */
 207     if (!Wait)
 208     {
 209         /* Wait not requested, release Dispatcher Database and return */
 210         KiReleaseDispatcherLock(OldIrql);
 211     }
 212     else
 213     {
 214         /* Return Locked and with a Wait */
 215         Thread = KeGetCurrentThread();
 216         Thread->WaitNext = TRUE;
 217         Thread->WaitIrql = OldIrql;
 218     }
 219
 220     /* Return the previous State */
 221     return PreviousState;
 222 }
 223
 224 /*
 225  * @implemented
 226  */
 227 VOID
 228 NTAPI
 229 KeSetEventBoostPriority(IN PKEVENT Event,
 230                         IN PKTHREAD *WaitingThread OPTIONAL)
 231 {
 232     KIRQL OldIrql;
 233     PKWAIT_BLOCK WaitBlock;
 234     PKTHREAD Thread = KeGetCurrentThread(), WaitThread;
 235     ASSERT(Event->Header.Type == EventSynchronizationObject);
 236     ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 237
 238     /* Acquire Dispatcher Database Lock */
 239     OldIrql = KiAcquireDispatcherLock();
 240
 241     /* Check if the list is empty */
 242     if (IsListEmpty(&Event->Header.WaitListHead))
 243     {
 244         /* Set the Event to Signaled */
 245         Event->Header.SignalState = 1;
 246
 247         /* Return */
 248         KiReleaseDispatcherLock(OldIrql);
 249         return;
 250     }
 251
 252     /* Get the Wait Block */
 253     WaitBlock = CONTAINING_RECORD(Event->Header.WaitListHead.Flink,
 254                                   KWAIT_BLOCK,
 255                                   WaitListEntry);
 256
 257     /* Check if this is a WaitAll */
 258     if (WaitBlock->WaitType == WaitAll)
 259     {
 260         /* Set the Event to Signaled */
 261         Event->Header.SignalState = 1;
 262
 263         /* Unwait the thread and unsignal the event */
 264         KxUnwaitThreadForEvent(Event, EVENT_INCREMENT);
 265     }
 266     else
 267     {
 268         /* Return waiting thread to caller */
 269         WaitThread = WaitBlock->Thread;
 270         if (WaitingThread) *WaitingThread = WaitThread;
 271
 272         /* Calculate new priority */
 273         Thread->Priority = KiComputeNewPriority(Thread, 0);
 274
 275         /* Unlink the waiting thread */
 276         KiUnlinkThread(WaitThread, STATUS_SUCCESS);
 277
 278         /* Request priority boosting */
 279         WaitThread->AdjustIncrement = Thread->Priority;
 280         WaitThread->AdjustReason = AdjustBoost;
 281
 282         /* Ready the thread */
 283         KiReadyThread(WaitThread);
 284     }
 285
 286     /* Release the Dispatcher Database Lock */
 287     KiReleaseDispatcherLock(OldIrql);
 288 }
 289
 290 /* EOF */