reactos/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 ULONG 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 }