ntoskrnl/ex/evtpair.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel
   4  * FILE:            ntoskrnl/ex/evtpair.c
   5  * PURPOSE:         Support for event pairs
   6  * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
   7  *                  Thomas Weidenmueller
   8  */
   9
  10 /* INCLUDES *****************************************************************/
  11
  12 #include <ntoskrnl.h>
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16 #if defined (ALLOC_PRAGMA)
  17 #pragma alloc_text(INIT, ExpInitializeEventPairImplementation)
  18 #endif
  19
  20 /* GLOBALS *******************************************************************/
  21
  22 POBJECT_TYPE ExEventPairObjectType = NULL;
  23
  24 GENERIC_MAPPING ExEventPairMapping =
  25 {
  26     STANDARD_RIGHTS_READ,
  27     STANDARD_RIGHTS_WRITE,
  28     STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE,
  29     EVENT_PAIR_ALL_ACCESS
  30 };
  31
  32 /* FUNCTIONS *****************************************************************/
  33
  34 VOID
  35 INIT_FUNCTION
  36 NTAPI
  37 ExpInitializeEventPairImplementation(VOID)
  38 {
  39     OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
  40     UNICODE_STRING Name;
  41     DPRINT("Creating Event Pair Object Type\n");
  42
  43     /* Create the Event Pair Object Type */
  44     RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
  45     RtlInitUnicodeString(&Name, L"EventPair");
  46     ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
  47     ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KEVENT_PAIR);
  48     ObjectTypeInitializer.GenericMapping = ExEventPairMapping;
  49     ObjectTypeInitializer.PoolType = NonPagedPool;
  50     ObjectTypeInitializer.ValidAccessMask = EVENT_PAIR_ALL_ACCESS;
  51     ObjectTypeInitializer.UseDefaultObject = TRUE;
  52     ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExEventPairObjectType);
  53 }
  54
  55 NTSTATUS
  56 NTAPI
  57 NtCreateEventPair(OUT PHANDLE EventPairHandle,
  58                   IN ACCESS_MASK DesiredAccess,
  59                   IN POBJECT_ATTRIBUTES ObjectAttributes)
  60 {
  61     PKEVENT_PAIR EventPair;
  62     HANDLE hEventPair;
  63     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
  64     NTSTATUS Status;
  65     PAGED_CODE();
  66     DPRINT("NtCreateEventPair: 0x%p\n", EventPairHandle);
  67
  68     /* Check if we were called from user-mode */
  69     if (PreviousMode != KernelMode)
  70     {
  71         /* Enter SEH Block */
  72         _SEH2_TRY
  73         {
  74             /* Check handle pointer */
  75             ProbeForWriteHandle(EventPairHandle);
  76         }
  77         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
  78         {
  79             /* Return the exception code */
  80             _SEH2_YIELD(return _SEH2_GetExceptionCode());
  81         }
  82         _SEH2_END;
  83     }
  84
  85     /* Create the Object */
  86     DPRINT("Creating EventPair\n");
  87     Status = ObCreateObject(PreviousMode,
  88                             ExEventPairObjectType,
  89                             ObjectAttributes,
  90                             PreviousMode,
  91                             NULL,
  92                             sizeof(KEVENT_PAIR),
  93                             0,
  94                             0,
  95                             (PVOID*)&EventPair);
  96
  97     /* Check for Success */
  98     if (NT_SUCCESS(Status))
  99     {
 100         /* Initalize the Event */
 101         DPRINT("Initializing EventPair\n");
 102         KeInitializeEventPair(EventPair);
 103
 104         /* Insert it */
 105         Status = ObInsertObject((PVOID)EventPair,
 106                                  NULL,
 107                                  DesiredAccess,
 108                                  0,
 109                                  NULL,
 110                                  &hEventPair);
 111
 112         /* Check for success */
 113         if (NT_SUCCESS(Status))
 114         {
 115             /* Enter SEH */
 116             _SEH2_TRY
 117             {
 118                 /* Return the handle */
 119                 *EventPairHandle = hEventPair;
 120             }
 121             _SEH2_EXCEPT(ExSystemExceptionFilter())
 122             {
 123                 /* Get the exception code */
 124                 Status = _SEH2_GetExceptionCode();
 125             }
 126             _SEH2_END;
 127         }
 128     }
 129
 130     /* Return Status */
 131     return Status;
 132 }
 133
 134 NTSTATUS
 135 NTAPI
 136 NtOpenEventPair(OUT PHANDLE EventPairHandle,
 137                 IN ACCESS_MASK DesiredAccess,
 138                 IN POBJECT_ATTRIBUTES ObjectAttributes)
 139 {
 140     HANDLE hEventPair;
 141     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 142     NTSTATUS Status;
 143     PAGED_CODE();
 144
 145     /* Check if we were called from user-mode */
 146     if (PreviousMode != KernelMode)
 147     {
 148         /* Enter SEH Block */
 149         _SEH2_TRY
 150         {
 151             /* Check handle pointer */
 152             ProbeForWriteHandle(EventPairHandle);
 153         }
 154         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 155         {
 156             /* Return the exception code */
 157             _SEH2_YIELD(return _SEH2_GetExceptionCode());
 158         }
 159         _SEH2_END;
 160     }
 161
 162     /* Open the Object */
 163     Status = ObOpenObjectByName(ObjectAttributes,
 164                                 ExEventPairObjectType,
 165                                 PreviousMode,
 166                                 NULL,
 167                                 DesiredAccess,
 168                                 NULL,
 169                                 &hEventPair);
 170
 171     /* Check for success */
 172     if (NT_SUCCESS(Status))
 173     {
 174         /* Enter SEH */
 175         _SEH2_TRY
 176         {
 177             /* Return the handle */
 178             *EventPairHandle = hEventPair;
 179         }
 180         _SEH2_EXCEPT(ExSystemExceptionFilter())
 181         {
 182             /* Get the exception code */
 183             Status = _SEH2_GetExceptionCode();
 184         }
 185         _SEH2_END;
 186     }
 187
 188     /* Return status */
 189     return Status;
 190 }
 191
 192 NTSTATUS
 193 NTAPI
 194 NtSetHighEventPair(IN HANDLE EventPairHandle)
 195 {
 196     PKEVENT_PAIR EventPair;
 197     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 198     NTSTATUS Status;
 199     PAGED_CODE();
 200     DPRINT("NtSetHighEventPair(EventPairHandle 0x%p)\n", EventPairHandle);
 201
 202     /* Open the Object */
 203     Status = ObReferenceObjectByHandle(EventPairHandle,
 204                                        SYNCHRONIZE,
 205                                        ExEventPairObjectType,
 206                                        PreviousMode,
 207                                        (PVOID*)&EventPair,
 208                                        NULL);
 209
 210     /* Check for Success */
 211     if(NT_SUCCESS(Status))
 212     {
 213         /* Set the Event */
 214         KeSetEvent(&EventPair->HighEvent, EVENT_INCREMENT, FALSE);
 215
 216         /* Dereference Object */
 217         ObDereferenceObject(EventPair);
 218     }
 219
 220     /* Return status */
 221     return Status;
 222 }
 223
 224 NTSTATUS
 225 NTAPI
 226 NtSetHighWaitLowEventPair(IN HANDLE EventPairHandle)
 227 {
 228     PKEVENT_PAIR EventPair;
 229     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 230     NTSTATUS Status;
 231     PAGED_CODE();
 232     DPRINT("NtSetHighWaitLowEventPair(Handle 0x%p)\n", EventPairHandle);
 233
 234     /* Open the Object */
 235     Status = ObReferenceObjectByHandle(EventPairHandle,
 236                                        SYNCHRONIZE,
 237                                        ExEventPairObjectType,
 238                                        PreviousMode,
 239                                        (PVOID*)&EventPair,
 240                                        NULL);
 241
 242     /* Check for Success */
 243     if(NT_SUCCESS(Status))
 244     {
 245         /* Set the Event */
 246         KeSetEvent(&EventPair->HighEvent, EVENT_INCREMENT, FALSE);
 247
 248         /* Wait for the Other one */
 249         KeWaitForSingleObject(&EventPair->LowEvent,
 250                               WrEventPair,
 251                               PreviousMode,
 252                               FALSE,
 253                               NULL);
 254
 255         /* Dereference Object */
 256         ObDereferenceObject(EventPair);
 257     }
 258
 259     /* Return status */
 260     return Status;
 261 }
 262
 263 NTSTATUS
 264 NTAPI
 265 NtSetLowEventPair(IN HANDLE EventPairHandle)
 266 {
 267     PKEVENT_PAIR EventPair;
 268     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 269     NTSTATUS Status;
 270     PAGED_CODE();
 271     DPRINT1("NtSetHighEventPair(EventPairHandle 0x%p)\n", EventPairHandle);
 272
 273     /* Open the Object */
 274     Status = ObReferenceObjectByHandle(EventPairHandle,
 275                                        SYNCHRONIZE,
 276                                        ExEventPairObjectType,
 277                                        PreviousMode,
 278                                        (PVOID*)&EventPair,
 279                                        NULL);
 280
 281     /* Check for Success */
 282     if(NT_SUCCESS(Status))
 283     {
 284         /* Set the Event */
 285         KeSetEvent(&EventPair->LowEvent, EVENT_INCREMENT, FALSE);
 286
 287         /* Dereference Object */
 288         ObDereferenceObject(EventPair);
 289     }
 290
 291     /* Return status */
 292     return Status;
 293 }
 294
 295 NTSTATUS
 296 NTAPI
 297 NtSetLowWaitHighEventPair(IN HANDLE EventPairHandle)
 298 {
 299     PKEVENT_PAIR EventPair;
 300     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 301     NTSTATUS Status;
 302     PAGED_CODE();
 303     DPRINT("NtSetHighWaitLowEventPair(Handle 0x%p)\n", EventPairHandle);
 304
 305     /* Open the Object */
 306     Status = ObReferenceObjectByHandle(EventPairHandle,
 307                                        SYNCHRONIZE,
 308                                        ExEventPairObjectType,
 309                                        PreviousMode,
 310                                        (PVOID*)&EventPair,
 311                                        NULL);
 312
 313     /* Check for Success */
 314     if(NT_SUCCESS(Status))
 315     {
 316         /* Set the Event */
 317         KeSetEvent(&EventPair->LowEvent, EVENT_INCREMENT, FALSE);
 318
 319         /* Wait for the Other one */
 320         KeWaitForSingleObject(&EventPair->HighEvent,
 321                               WrEventPair,
 322                               PreviousMode,
 323                               FALSE,
 324                               NULL);
 325
 326         /* Dereference Object */
 327         ObDereferenceObject(EventPair);
 328     }
 329
 330     /* Return status */
 331     return Status;
 332 }
 333
 334
 335 NTSTATUS
 336 NTAPI
 337 NtWaitLowEventPair(IN HANDLE EventPairHandle)
 338 {
 339     PKEVENT_PAIR EventPair;
 340     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 341     NTSTATUS Status;
 342     PAGED_CODE();
 343     DPRINT("NtSetHighWaitLowEventPair(Handle 0x%p)\n", EventPairHandle);
 344
 345     /* Open the Object */
 346     Status = ObReferenceObjectByHandle(EventPairHandle,
 347                                        SYNCHRONIZE,
 348                                        ExEventPairObjectType,
 349                                        PreviousMode,
 350                                        (PVOID*)&EventPair,
 351                                        NULL);
 352
 353     /* Check for Success */
 354     if(NT_SUCCESS(Status))
 355     {
 356         /* Wait for the Event */
 357         KeWaitForSingleObject(&EventPair->LowEvent,
 358                               WrEventPair,
 359                               PreviousMode,
 360                               FALSE,
 361                               NULL);
 362
 363         /* Dereference Object */
 364         ObDereferenceObject(EventPair);
 365     }
 366
 367     /* Return status */
 368     return Status;
 369 }
 370
 371 NTSTATUS
 372 NTAPI
 373 NtWaitHighEventPair(IN HANDLE EventPairHandle)
 374 {
 375     PKEVENT_PAIR EventPair;
 376     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 377     NTSTATUS Status;
 378
 379     PAGED_CODE();
 380     DPRINT("NtSetHighWaitLowEventPair(Handle 0x%p)\n", EventPairHandle);
 381
 382     /* Open the Object */
 383     Status = ObReferenceObjectByHandle(EventPairHandle,
 384                                        SYNCHRONIZE,
 385                                        ExEventPairObjectType,
 386                                        PreviousMode,
 387                                        (PVOID*)&EventPair,
 388                                        NULL);
 389
 390     /* Check for Success */
 391     if(NT_SUCCESS(Status))
 392     {
 393         /* Wait for the Event */
 394         KeWaitForSingleObject(&EventPair->HighEvent,
 395                               WrEventPair,
 396                               PreviousMode,
 397                               FALSE,
 398                               NULL);
 399
 400         /* Dereference Object */
 401         ObDereferenceObject(EventPair);
 402     }
 403
 404     /* Return status */
 405     return Status;
 406 }
 407
 408 /* EOF */