ntoskrnl/ex/sem.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel
   4  * FILE:            ntoskrnl/ex/sem.c
   5  * PURPOSE:         Semaphore Implementation
   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, ExpInitializeSemaphoreImplementation)
  18 #endif
  19
  20 /* GLOBALS ******************************************************************/
  21
  22 POBJECT_TYPE ExSemaphoreObjectType;
  23
  24 GENERIC_MAPPING ExSemaphoreMapping =
  25 {
  26     STANDARD_RIGHTS_READ | SEMAPHORE_QUERY_STATE,
  27     STANDARD_RIGHTS_WRITE | SEMAPHORE_MODIFY_STATE,
  28     STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE,
  29     SEMAPHORE_ALL_ACCESS
  30 };
  31
  32 static const INFORMATION_CLASS_INFO ExSemaphoreInfoClass[] =
  33 {
  34      /* SemaphoreBasicInformation */
  35     IQS_SAME(SEMAPHORE_BASIC_INFORMATION, ULONG, ICIF_QUERY),
  36 };
  37
  38 /* FUNCTIONS *****************************************************************/
  39
  40 CODE_SEG("INIT")
  41 BOOLEAN
  42 NTAPI
  43 ExpInitializeSemaphoreImplementation(VOID)
  44 {
  45     OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
  46     UNICODE_STRING Name;
  47     NTSTATUS Status;
  48     DPRINT("Creating Semaphore Object Type\n");
  49
  50     /* Create the Event Pair Object Type */
  51     RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
  52     RtlInitUnicodeString(&Name, L"Semaphore");
  53     ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
  54     ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KSEMAPHORE);
  55     ObjectTypeInitializer.GenericMapping = ExSemaphoreMapping;
  56     ObjectTypeInitializer.PoolType = NonPagedPool;
  57     ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
  58     ObjectTypeInitializer.ValidAccessMask = SEMAPHORE_ALL_ACCESS;
  59     Status = ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExSemaphoreObjectType);
  60     if (!NT_SUCCESS(Status)) return FALSE;
  61     return TRUE;
  62 }
  63
  64 /*
  65  * @implemented
  66  */
  67 NTSTATUS
  68 NTAPI
  69 NtCreateSemaphore(OUT PHANDLE SemaphoreHandle,
  70                   IN ACCESS_MASK DesiredAccess,
  71                   IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
  72                   IN LONG InitialCount,
  73                   IN LONG MaximumCount)
  74 {
  75     PKSEMAPHORE Semaphore;
  76     HANDLE hSemaphore;
  77     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
  78     NTSTATUS Status;
  79     PAGED_CODE();
  80
  81     /* Check if we were called from user-mode */
  82     if (PreviousMode != KernelMode)
  83     {
  84         /* Enter SEH Block */
  85         _SEH2_TRY
  86         {
  87             /* Check handle pointer */
  88             ProbeForWriteHandle(SemaphoreHandle);
  89         }
  90         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
  91         {
  92             /* Return the exception code */
  93             _SEH2_YIELD(return _SEH2_GetExceptionCode());
  94         }
  95         _SEH2_END;
  96     }
  97
  98     /* Make sure the counts make sense */
  99     if ((MaximumCount <= 0) ||
 100         (InitialCount < 0) ||
 101         (InitialCount > MaximumCount))
 102     {
 103         DPRINT("Invalid Count Data!\n");
 104         return STATUS_INVALID_PARAMETER;
 105     }
 106
 107     /* Create the Semaphore Object */
 108     Status = ObCreateObject(PreviousMode,
 109                             ExSemaphoreObjectType,
 110                             ObjectAttributes,
 111                             PreviousMode,
 112                             NULL,
 113                             sizeof(KSEMAPHORE),
 114                             0,
 115                             0,
 116                             (PVOID*)&Semaphore);
 117
 118     /* Check for Success */
 119     if (NT_SUCCESS(Status))
 120     {
 121         /* Initialize it */
 122         KeInitializeSemaphore(Semaphore,
 123                               InitialCount,
 124                               MaximumCount);
 125
 126         /* Insert it into the Object Tree */
 127         Status = ObInsertObject((PVOID)Semaphore,
 128                                 NULL,
 129                                 DesiredAccess,
 130                                 0,
 131                                 NULL,
 132                                 &hSemaphore);
 133
 134         /* Check for success */
 135         if (NT_SUCCESS(Status))
 136         {
 137             /* Enter SEH Block for return */
 138             _SEH2_TRY
 139             {
 140                 /* Return the handle */
 141                 *SemaphoreHandle = hSemaphore;
 142             }
 143             _SEH2_EXCEPT(ExSystemExceptionFilter())
 144             {
 145                 /* Get the exception code */
 146                 Status = _SEH2_GetExceptionCode();
 147             }
 148             _SEH2_END;
 149         }
 150     }
 151
 152     /* Return Status */
 153     return Status;
 154 }
 155
 156 /*
 157  * @implemented
 158  */
 159 NTSTATUS
 160 NTAPI
 161 NtOpenSemaphore(OUT PHANDLE SemaphoreHandle,
 162                 IN ACCESS_MASK DesiredAccess,
 163                 IN POBJECT_ATTRIBUTES ObjectAttributes)
 164 {
 165     HANDLE hSemaphore;
 166     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 167     NTSTATUS Status;
 168     PAGED_CODE();
 169
 170     /* Check if we were called from user-mode */
 171     if (PreviousMode != KernelMode)
 172     {
 173         /* Enter SEH Block */
 174         _SEH2_TRY
 175         {
 176             /* Check handle pointer */
 177             ProbeForWriteHandle(SemaphoreHandle);
 178         }
 179         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 180         {
 181             /* Return the exception code */
 182             _SEH2_YIELD(return _SEH2_GetExceptionCode());
 183         }
 184         _SEH2_END;
 185     }
 186
 187     /* Open the Object */
 188     Status = ObOpenObjectByName(ObjectAttributes,
 189                                 ExSemaphoreObjectType,
 190                                 PreviousMode,
 191                                 NULL,
 192                                 DesiredAccess,
 193                                 NULL,
 194                                 &hSemaphore);
 195
 196     /* Check for success */
 197     if (NT_SUCCESS(Status))
 198     {
 199         /* Enter SEH Block for return */
 200         _SEH2_TRY
 201         {
 202             /* Return the handle */
 203             *SemaphoreHandle = hSemaphore;
 204         }
 205         _SEH2_EXCEPT(ExSystemExceptionFilter())
 206         {
 207             /* Get the exception code */
 208             Status = _SEH2_GetExceptionCode();
 209         }
 210         _SEH2_END;
 211     }
 212
 213     /* Return Status */
 214     return Status;
 215 }
 216
 217 /*
 218  * @implemented
 219  */
 220 NTSTATUS
 221 NTAPI
 222 NtQuerySemaphore(IN HANDLE SemaphoreHandle,
 223                  IN SEMAPHORE_INFORMATION_CLASS SemaphoreInformationClass,
 224                  OUT PVOID SemaphoreInformation,
 225                  IN ULONG SemaphoreInformationLength,
 226                  OUT PULONG ReturnLength OPTIONAL)
 227 {
 228     PKSEMAPHORE Semaphore;
 229     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 230     NTSTATUS Status;
 231     PAGED_CODE();
 232
 233     /* Check buffers and class validity */
 234     Status = DefaultQueryInfoBufferCheck(SemaphoreInformationClass,
 235                                          ExSemaphoreInfoClass,
 236                                          sizeof(ExSemaphoreInfoClass) /
 237                                          sizeof(ExSemaphoreInfoClass[0]),
 238                                          ICIF_PROBE_READ_WRITE,
 239                                          SemaphoreInformation,
 240                                          SemaphoreInformationLength,
 241                                          ReturnLength,
 242                                          NULL,
 243                                          PreviousMode);
 244     if (!NT_SUCCESS(Status))
 245     {
 246         /* Invalid buffers */
 247         DPRINT("NtQuerySemaphore() failed, Status: 0x%x\n", Status);
 248         return Status;
 249     }
 250
 251     /* Get the Object */
 252     Status = ObReferenceObjectByHandle(SemaphoreHandle,
 253                                        SEMAPHORE_QUERY_STATE,
 254                                        ExSemaphoreObjectType,
 255                                        PreviousMode,
 256                                        (PVOID*)&Semaphore,
 257                                        NULL);
 258
 259     /* Check for success */
 260     if (NT_SUCCESS(Status))
 261     {
 262         /* Entry SEH Block */
 263         _SEH2_TRY
 264         {
 265             PSEMAPHORE_BASIC_INFORMATION BasicInfo =
 266                 (PSEMAPHORE_BASIC_INFORMATION)SemaphoreInformation;
 267
 268             /* Return the basic information */
 269             BasicInfo->CurrentCount = KeReadStateSemaphore(Semaphore);
 270             BasicInfo->MaximumCount = Semaphore->Limit;
 271
 272             /* Return the length */
 273             if (ReturnLength) *ReturnLength = sizeof(*BasicInfo);
 274         }
 275         _SEH2_EXCEPT(ExSystemExceptionFilter())
 276         {
 277             /* Get the exception code */
 278             Status = _SEH2_GetExceptionCode();
 279         }
 280         _SEH2_END;
 281
 282         /* Dereference the Object */
 283         ObDereferenceObject(Semaphore);
 284    }
 285
 286    /* Return status */
 287    return Status;
 288 }
 289
 290 /*
 291  * @implemented
 292  */
 293 NTSTATUS
 294 NTAPI
 295 NtReleaseSemaphore(IN HANDLE SemaphoreHandle,
 296                    IN LONG ReleaseCount,
 297                    OUT PLONG PreviousCount OPTIONAL)
 298 {
 299     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 300     PKSEMAPHORE Semaphore;
 301     NTSTATUS Status;
 302     PAGED_CODE();
 303
 304     /* Check if we were called from user-mode */
 305     if ((PreviousCount) && (PreviousMode != KernelMode))
 306     {
 307         /* Entry SEH Block */
 308         _SEH2_TRY
 309         {
 310             /* Make sure the state pointer is valid */
 311             ProbeForWriteLong(PreviousCount);
 312          }
 313         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 314         {
 315             /* Return the exception code */
 316             _SEH2_YIELD(return _SEH2_GetExceptionCode());
 317         }
 318         _SEH2_END;
 319     }
 320
 321     /* Make sure count makes sense */
 322     if (ReleaseCount <= 0)
 323     {
 324         DPRINT("Invalid Release Count\n");
 325         return STATUS_INVALID_PARAMETER;
 326     }
 327
 328     /* Get the Object */
 329     Status = ObReferenceObjectByHandle(SemaphoreHandle,
 330                                        SEMAPHORE_MODIFY_STATE,
 331                                        ExSemaphoreObjectType,
 332                                        PreviousMode,
 333                                        (PVOID*)&Semaphore,
 334                                        NULL);
 335
 336     /* Check for success */
 337     if (NT_SUCCESS(Status))
 338     {
 339         /* Enter SEH Block */
 340         _SEH2_TRY
 341         {
 342             /* Release the semaphore */
 343             LONG PrevCount = KeReleaseSemaphore(Semaphore,
 344                                                 IO_NO_INCREMENT,
 345                                                 ReleaseCount,
 346                                                 FALSE);
 347
 348             /* Return the old count if requested */
 349             if (PreviousCount) *PreviousCount = PrevCount;
 350         }
 351         _SEH2_EXCEPT(ExSystemExceptionFilter())
 352         {
 353             /* Get the exception code */
 354             Status = _SEH2_GetExceptionCode();
 355         }
 356         _SEH2_END;
 357
 358         /* Dereference the Semaphore */
 359         ObDereferenceObject(Semaphore);
 360     }
 361
 362     /* Return Status */
 363     return Status;
 364 }
 365
 366 /* EOF */