ntoskrnl/ex/profile.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel
   4  * FILE:            ntoskrnl/ex/profile.c
   5  * PURPOSE:         Support for Executive Profile Objects
   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, ExpInitializeProfileImplementation)
  18 #endif
  19
  20 #define TAG_PROFILE 'forP'
  21
  22 /* GLOBALS *******************************************************************/
  23
  24 POBJECT_TYPE ExProfileObjectType = NULL;
  25 KMUTEX ExpProfileMutex;
  26
  27 GENERIC_MAPPING ExpProfileMapping =
  28 {
  29     STANDARD_RIGHTS_READ    | PROFILE_CONTROL,
  30     STANDARD_RIGHTS_WRITE   | PROFILE_CONTROL,
  31     STANDARD_RIGHTS_EXECUTE | PROFILE_CONTROL,
  32     PROFILE_ALL_ACCESS
  33 };
  34
  35 /* FUNCTIONS *****************************************************************/
  36
  37 VOID
  38 NTAPI
  39 ExpDeleteProfile(PVOID ObjectBody)
  40 {
  41     PEPROFILE Profile;
  42     ULONG State;
  43
  44     /* Typecast the Object */
  45     Profile = ObjectBody;
  46
  47     /* Check if there if the Profile was started */
  48     if (Profile->LockedBufferAddress)
  49     {
  50         /* Stop the Profile */
  51         State = KeStopProfile(Profile->ProfileObject);
  52         ASSERT(State != FALSE);
  53
  54         /* Unmap the Locked Buffer */
  55         MmUnmapLockedPages(Profile->LockedBufferAddress, Profile->Mdl);
  56         MmUnlockPages(Profile->Mdl);
  57         IoFreeMdl(Profile->Mdl);
  58         ExFreePoolWithTag(Profile->ProfileObject, TAG_PROFILE);
  59     }
  60
  61     /* Check if a Process is associated and reference it */
  62     if (Profile->Process) ObDereferenceObject(Profile->Process);
  63 }
  64
  65 BOOLEAN
  66 INIT_FUNCTION
  67 NTAPI
  68 ExpInitializeProfileImplementation(VOID)
  69 {
  70     OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
  71     UNICODE_STRING Name;
  72     NTSTATUS Status;
  73     DPRINT("Creating Profile Object Type\n");
  74
  75     /* Initialize the Mutex to lock the States */
  76     KeInitializeMutex(&ExpProfileMutex, 64);
  77
  78     /* Create the Event Pair Object Type */
  79     RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
  80     RtlInitUnicodeString(&Name, L"Profile");
  81     ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
  82     ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KPROFILE);
  83     ObjectTypeInitializer.GenericMapping = ExpProfileMapping;
  84     ObjectTypeInitializer.PoolType = NonPagedPool;
  85     ObjectTypeInitializer.DeleteProcedure = ExpDeleteProfile;
  86     ObjectTypeInitializer.ValidAccessMask = PROFILE_ALL_ACCESS;
  87     ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
  88     Status = ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExProfileObjectType);
  89     if (!NT_SUCCESS(Status)) return FALSE;
  90     return TRUE;
  91 }
  92
  93 NTSTATUS
  94 NTAPI
  95 NtCreateProfile(OUT PHANDLE ProfileHandle,
  96                 IN HANDLE Process OPTIONAL,
  97                 IN PVOID RangeBase,
  98                 IN SIZE_T RangeSize,
  99                 IN ULONG BucketSize,
 100                 IN PVOID Buffer,
 101                 IN ULONG BufferSize,
 102                 IN KPROFILE_SOURCE ProfileSource,
 103                 IN KAFFINITY Affinity)
 104 {
 105     HANDLE hProfile;
 106     PEPROFILE Profile;
 107     PEPROCESS pProcess;
 108     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 109     OBJECT_ATTRIBUTES ObjectAttributes;
 110     NTSTATUS Status;
 111     ULONG Log2 = 0;
 112     ULONG_PTR Segment = 0;
 113     PAGED_CODE();
 114
 115     /* Easy way out */
 116     if(!BufferSize) return STATUS_INVALID_PARAMETER_7;
 117
 118     /* Check if this is a low-memory profile */
 119     if ((!BucketSize) && (RangeBase < (PVOID)(0x10000)))
 120     {
 121         /* Validate size */
 122         if (BufferSize < sizeof(ULONG)) return STATUS_INVALID_PARAMETER_7;
 123
 124         /* This will become a segmented profile object */
 125         Segment = (ULONG_PTR)RangeBase;
 126         RangeBase = 0;
 127
 128         /* Recalculate the bucket size */
 129         BucketSize = RangeSize / (BufferSize / sizeof(ULONG));
 130
 131         /* Convert it to log2 */
 132         BucketSize--;
 133         while (BucketSize >>= 1) Log2++;
 134         BucketSize += Log2 + 1;
 135     }
 136
 137     /* Validate bucket size */
 138     if ((BucketSize > 31) || (BucketSize < 2))
 139     {
 140         DPRINT1("Bucket size invalid\n");
 141         return STATUS_INVALID_PARAMETER;
 142     }
 143
 144     /* Make sure that the buckets can map the range */
 145     if ((RangeSize >> (BucketSize - 2)) > BufferSize)
 146     {
 147         DPRINT1("Bucket size too small\n");
 148         return STATUS_BUFFER_TOO_SMALL;
 149     }
 150
 151     /* Make sure that the range isn't too gigantic */
 152     if (((ULONG_PTR)RangeBase + RangeSize) < RangeSize)
 153     {
 154         DPRINT1("Range too big\n");
 155         return STATUS_BUFFER_OVERFLOW;
 156     }
 157
 158     /* Check if we were called from user-mode */
 159     if(PreviousMode != KernelMode)
 160     {
 161         /* Entry SEH */
 162         _SEH2_TRY
 163         {
 164             /* Make sure that the handle pointer is valid */
 165             ProbeForWriteHandle(ProfileHandle);
 166
 167             /* Check if the buffer is valid */
 168             ProbeForWrite(Buffer,
 169                           BufferSize,
 170                           sizeof(ULONG));
 171         }
 172         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 173         {
 174             /* Return the exception code */
 175             _SEH2_YIELD(return _SEH2_GetExceptionCode());
 176         }
 177         _SEH2_END;
 178     }
 179
 180     /* Check if a process was specified */
 181     if (Process)
 182     {
 183         /* Reference it */
 184         Status = ObReferenceObjectByHandle(Process,
 185                                            PROCESS_QUERY_INFORMATION,
 186                                            PsProcessType,
 187                                            PreviousMode,
 188                                            (PVOID*)&pProcess,
 189                                            NULL);
 190         if (!NT_SUCCESS(Status)) return(Status);
 191     }
 192     else
 193     {
 194         /* Segmented profile objects cannot be used system-wide */
 195         if (Segment) return STATUS_INVALID_PARAMETER;
 196
 197         /* No process was specified, which means a System-Wide Profile */
 198         pProcess = NULL;
 199
 200         /* For this, we need to check the Privilege */
 201         if(!SeSinglePrivilegeCheck(SeSystemProfilePrivilege, PreviousMode))
 202         {
 203             DPRINT1("NtCreateProfile: Caller requires the SeSystemProfilePrivilege privilege!\n");
 204             return STATUS_PRIVILEGE_NOT_HELD;
 205         }
 206     }
 207
 208     /* Create the object */
 209     InitializeObjectAttributes(&ObjectAttributes,
 210                                NULL,
 211                                0,
 212                                NULL,
 213                                NULL);
 214     Status = ObCreateObject(KernelMode,
 215                             ExProfileObjectType,
 216                             &ObjectAttributes,
 217                             PreviousMode,
 218                             NULL,
 219                             sizeof(EPROFILE),
 220                             0,
 221                             sizeof(EPROFILE) + sizeof(KPROFILE),
 222                             (PVOID*)&Profile);
 223     if (!NT_SUCCESS(Status))
 224     {
 225         /* Dereference the process object if it was specified */
 226         if (pProcess) ObDereferenceObject(pProcess);
 227
 228         /* Return Status */
 229         return Status;
 230     }
 231
 232     /* Initialize it */
 233     Profile->RangeBase = RangeBase;
 234     Profile->RangeSize = RangeSize;
 235     Profile->Buffer = Buffer;
 236     Profile->BufferSize = BufferSize;
 237     Profile->BucketSize = BucketSize;
 238     Profile->LockedBufferAddress = NULL;
 239     Profile->Segment = Segment;
 240     Profile->ProfileSource = ProfileSource;
 241     Profile->Affinity = Affinity;
 242     Profile->Process = pProcess;
 243
 244     /* Insert into the Object Tree */
 245     Status = ObInsertObject ((PVOID)Profile,
 246                              NULL,
 247                              PROFILE_CONTROL,
 248                              0,
 249                              NULL,
 250                              &hProfile);
 251
 252     /* Check for Success */
 253     if (!NT_SUCCESS(Status))
 254     {
 255         /* Dereference Process on failure */
 256         if (pProcess) ObDereferenceObject(pProcess);
 257         return Status;
 258     }
 259
 260     /* Enter SEH */
 261     _SEH2_TRY
 262     {
 263         /* Copy the created handle back to the caller*/
 264         *ProfileHandle = hProfile;
 265     }
 266     _SEH2_EXCEPT(ExSystemExceptionFilter())
 267     {
 268         Status = _SEH2_GetExceptionCode();
 269     }
 270     _SEH2_END;
 271
 272     /* Return Status */
 273     return Status;
 274 }
 275
 276 NTSTATUS
 277 NTAPI
 278 NtQueryPerformanceCounter(OUT PLARGE_INTEGER PerformanceCounter,
 279                           OUT PLARGE_INTEGER PerformanceFrequency OPTIONAL)
 280 {
 281     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 282     LARGE_INTEGER PerfFrequency;
 283     NTSTATUS Status = STATUS_SUCCESS;
 284
 285     /* Check if we were called from user-mode */
 286     if (PreviousMode != KernelMode)
 287     {
 288         /* Entry SEH Block */
 289         _SEH2_TRY
 290         {
 291             /* Make sure the counter and frequency are valid */
 292             ProbeForWriteLargeInteger(PerformanceCounter);
 293             if (PerformanceFrequency)
 294             {
 295                 ProbeForWriteLargeInteger(PerformanceFrequency);
 296             }
 297         }
 298         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 299         {
 300             /* Return the exception code */
 301             _SEH2_YIELD(return _SEH2_GetExceptionCode());
 302         }
 303         _SEH2_END;
 304     }
 305
 306     /* Enter a new SEH Block */
 307     _SEH2_TRY
 308     {
 309         /* Query the Kernel */
 310         *PerformanceCounter = KeQueryPerformanceCounter(&PerfFrequency);
 311
 312         /* Return Frequency if requested */
 313         if (PerformanceFrequency) *PerformanceFrequency = PerfFrequency;
 314     }
 315     _SEH2_EXCEPT(ExSystemExceptionFilter())
 316     {
 317         /* Get the exception code */
 318         Status = _SEH2_GetExceptionCode();
 319     }
 320     _SEH2_END;
 321
 322     /* Return status to caller */
 323     return Status;
 324 }
 325
 326 NTSTATUS
 327 NTAPI
 328 NtStartProfile(IN HANDLE ProfileHandle)
 329 {
 330     PEPROFILE Profile;
 331     PKPROFILE ProfileObject;
 332     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 333     PVOID TempLockedBufferAddress;
 334     NTSTATUS Status;
 335     PAGED_CODE();
 336
 337     /* Get the Object */
 338     Status = ObReferenceObjectByHandle(ProfileHandle,
 339                                        PROFILE_CONTROL,
 340                                        ExProfileObjectType,
 341                                        PreviousMode,
 342                                        (PVOID*)&Profile,
 343                                        NULL);
 344     if (!NT_SUCCESS(Status)) return(Status);
 345
 346     /* To avoid a Race, wait on the Mutex */
 347     KeWaitForSingleObject(&ExpProfileMutex,
 348                           Executive,
 349                           KernelMode,
 350                           FALSE,
 351                           NULL);
 352
 353     /* The Profile can still be enabled though, so handle that */
 354     if (Profile->LockedBufferAddress)
 355     {
 356         /* Release our lock, dereference and return */
 357         KeReleaseMutex(&ExpProfileMutex, FALSE);
 358         ObDereferenceObject(Profile);
 359         return STATUS_PROFILING_NOT_STOPPED;
 360     }
 361
 362     /* Allocate a Kernel Profile Object. */
 363     ProfileObject = ExAllocatePoolWithTag(NonPagedPool,
 364                                           sizeof(*ProfileObject),
 365                                           TAG_PROFILE);
 366     if (!ProfileObject)
 367     {
 368         /* Out of memory, fail */
 369         KeReleaseMutex(&ExpProfileMutex, FALSE);
 370         ObDereferenceObject(Profile);
 371         return STATUS_INSUFFICIENT_RESOURCES;
 372     }
 373
 374     /* Allocate the Mdl Structure */
 375     Profile->Mdl = IoAllocateMdl(Profile->Buffer, Profile->BufferSize, FALSE, FALSE, NULL);
 376
 377     /* Protect this in SEH as we might raise an exception */
 378     _SEH2_TRY
 379     {
 380         /* Probe and Lock for Write Access */
 381         MmProbeAndLockPages(Profile->Mdl, PreviousMode, IoWriteAccess);
 382     }
 383     _SEH2_EXCEPT(ExSystemExceptionFilter())
 384     {
 385         /* Release our lock, free the buffer, dereference and return */
 386         KeReleaseMutex(&ExpProfileMutex, FALSE);
 387         ObDereferenceObject(Profile);
 388         ExFreePoolWithTag(ProfileObject, TAG_PROFILE);
 389         _SEH2_YIELD(return _SEH2_GetExceptionCode());
 390     }
 391     _SEH2_END;
 392
 393     /* Map the pages */
 394     TempLockedBufferAddress = MmMapLockedPages(Profile->Mdl, KernelMode);
 395
 396     /* Initialize the Kernel Profile Object */
 397     Profile->ProfileObject = ProfileObject;
 398     KeInitializeProfile(ProfileObject,
 399                         &Profile->Process->Pcb,
 400                         Profile->RangeBase,
 401                         Profile->RangeSize,
 402                         Profile->BucketSize,
 403                         Profile->ProfileSource,
 404                         Profile->Affinity);
 405
 406     /* Start the Profiling */
 407     KeStartProfile(ProfileObject, TempLockedBufferAddress);
 408
 409     /* Now it's safe to save this */
 410     Profile->LockedBufferAddress = TempLockedBufferAddress;
 411
 412     /* Release mutex, dereference and return */
 413     KeReleaseMutex(&ExpProfileMutex, FALSE);
 414     ObDereferenceObject(Profile);
 415     return STATUS_SUCCESS;
 416 }
 417
 418 NTSTATUS
 419 NTAPI
 420 NtStopProfile(IN HANDLE ProfileHandle)
 421 {
 422     PEPROFILE Profile;
 423     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 424     NTSTATUS Status;
 425     PAGED_CODE();
 426
 427     /* Get the Object */
 428     Status = ObReferenceObjectByHandle(ProfileHandle,
 429                                        PROFILE_CONTROL,
 430                                        ExProfileObjectType,
 431                                        PreviousMode,
 432                                        (PVOID*)&Profile,
 433                                        NULL);
 434     if (!NT_SUCCESS(Status)) return(Status);
 435
 436     /* Get the Mutex */
 437     KeWaitForSingleObject(&ExpProfileMutex,
 438                           Executive,
 439                           KernelMode,
 440                           FALSE,
 441                           NULL);
 442
 443     /* Make sure the Profile Object is really Started */
 444     if (!Profile->LockedBufferAddress)
 445     {
 446         Status = STATUS_PROFILING_NOT_STARTED;
 447         goto Exit;
 448     }
 449
 450     /* Stop the Profile */
 451     KeStopProfile(Profile->ProfileObject);
 452
 453     /* Unlock the Buffer */
 454     MmUnmapLockedPages(Profile->LockedBufferAddress, Profile->Mdl);
 455     MmUnlockPages(Profile->Mdl);
 456     IoFreeMdl(Profile->Mdl);
 457     ExFreePoolWithTag(Profile->ProfileObject, TAG_PROFILE);
 458
 459     /* Clear the Locked Buffer pointer, meaning the Object is Stopped */
 460     Profile->LockedBufferAddress = NULL;
 461
 462 Exit:
 463     /* Release Mutex, Dereference and Return */
 464     KeReleaseMutex(&ExpProfileMutex, FALSE);
 465     ObDereferenceObject(Profile);
 466     return Status;
 467 }
 468
 469 NTSTATUS
 470 NTAPI
 471 NtQueryIntervalProfile(IN KPROFILE_SOURCE ProfileSource,
 472                        OUT PULONG Interval)
 473 {
 474     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
 475     ULONG ReturnInterval;
 476     NTSTATUS Status = STATUS_SUCCESS;
 477     PAGED_CODE();
 478
 479     /* Check if we were called from user-mode */
 480     if (PreviousMode != KernelMode)
 481     {
 482         /* Enter SEH Block */
 483         _SEH2_TRY
 484         {
 485             /* Validate interval */
 486             ProbeForWriteUlong(Interval);
 487         }
 488         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 489         {
 490             /* Return the exception code */
 491             _SEH2_YIELD(return _SEH2_GetExceptionCode());
 492         }
 493         _SEH2_END;
 494     }
 495
 496     /* Query the Interval */
 497     ReturnInterval = (ULONG)KeQueryIntervalProfile(ProfileSource);
 498
 499     /* Enter SEH block for return */
 500     _SEH2_TRY
 501     {
 502         /* Return the data */
 503         *Interval = ReturnInterval;
 504     }
 505     _SEH2_EXCEPT(ExSystemExceptionFilter())
 506     {
 507         /* Get the exception code */
 508         Status = _SEH2_GetExceptionCode();
 509     }
 510     _SEH2_END;
 511
 512     /* Return Success */
 513     return Status;
 514 }
 515
 516 NTSTATUS
 517 NTAPI
 518 NtSetIntervalProfile(IN ULONG Interval,
 519                      IN KPROFILE_SOURCE Source)
 520 {
 521     /* Let the Kernel do the job */
 522     KeSetIntervalProfile(Interval, Source);
 523
 524     /* Nothing can go wrong */
 525     return STATUS_SUCCESS;
 526 }