xref: /reactos/ntoskrnl/ex/profile.c (revision 527f2f90) 
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 = (PEPROFILE)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     }
59 
60     /* Check if a Process is associated and reference it */
61     if (Profile->Process) ObDereferenceObject(Profile->Process);
62 }
63 
64 BOOLEAN
65 INIT_FUNCTION
66 NTAPI
67 ExpInitializeProfileImplementation(VOID)
68 {
69     OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
70     UNICODE_STRING Name;
71     NTSTATUS Status;
72     DPRINT("Creating Profile Object Type\n");
73 
74     /* Initialize the Mutex to lock the States */
75     KeInitializeMutex(&ExpProfileMutex, 64);
76 
77     /* Create the Event Pair Object Type */
78     RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
79     RtlInitUnicodeString(&Name, L"Profile");
80     ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
81     ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KPROFILE);
82     ObjectTypeInitializer.GenericMapping = ExpProfileMapping;
83     ObjectTypeInitializer.PoolType = NonPagedPool;
84     ObjectTypeInitializer.DeleteProcedure = ExpDeleteProfile;
85     ObjectTypeInitializer.ValidAccessMask = PROFILE_ALL_ACCESS;
86     ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
87     Status = ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExProfileObjectType);
88     if (!NT_SUCCESS(Status)) return FALSE;
89     return TRUE;
90 }
91 
92 NTSTATUS
93 NTAPI
94 NtCreateProfile(OUT PHANDLE ProfileHandle,
95                 IN HANDLE Process OPTIONAL,
96                 IN PVOID RangeBase,
97                 IN ULONG RangeSize,
98                 IN ULONG BucketSize,
99                 IN PVOID Buffer,
100                 IN ULONG BufferSize,
101                 IN KPROFILE_SOURCE ProfileSource,
102                 IN KAFFINITY Affinity)
103 {
104     HANDLE hProfile;
105     PEPROFILE Profile;
106     PEPROCESS pProcess;
107     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
108     OBJECT_ATTRIBUTES ObjectAttributes;
109     NTSTATUS Status;
110     ULONG Log2 = 0;
111     ULONG_PTR Segment = 0;
112     PAGED_CODE();
113 
114     /* Easy way out */
115     if(!BufferSize) return STATUS_INVALID_PARAMETER_7;
116 
117     /* Check if this is a low-memory profile */
118     if ((!BucketSize) && (RangeBase < (PVOID)(0x10000)))
119     {
120         /* Validate size */
121         if (BufferSize < sizeof(ULONG)) return STATUS_INVALID_PARAMETER_7;
122 
123         /* This will become a segmented profile object */
124         Segment = (ULONG_PTR)RangeBase;
125         RangeBase = 0;
126 
127         /* Recalculate the bucket size */
128         BucketSize = RangeSize / (BufferSize / sizeof(ULONG));
129 
130         /* Convert it to log2 */
131         BucketSize--;
132         while (BucketSize >>= 1) Log2++;
133         BucketSize += Log2 + 1;
134     }
135 
136     /* Validate bucket size */
137     if ((BucketSize > 31) || (BucketSize < 2))
138     {
139         DPRINT1("Bucket size invalid\n");
140         return STATUS_INVALID_PARAMETER;
141     }
142 
143     /* Make sure that the buckets can map the range */
144     if ((RangeSize >> (BucketSize - 2)) > BufferSize)
145     {
146         DPRINT1("Bucket size too small\n");
147         return STATUS_BUFFER_TOO_SMALL;
148     }
149 
150     /* Make sure that the range isn't too gigantic */
151     if (((ULONG_PTR)RangeBase + RangeSize) < RangeSize)
152     {
153         DPRINT1("Range too big\n");
154         return STATUS_BUFFER_OVERFLOW;
155     }
156 
157     /* Check if we were called from user-mode */
158     if(PreviousMode != KernelMode)
159     {
160         /* Entry SEH */
161         _SEH2_TRY
162         {
163             /* Make sure that the handle pointer is valid */
164             ProbeForWriteHandle(ProfileHandle);
165 
166             /* Check if the buffer is valid */
167             ProbeForWrite(Buffer,
168                           BufferSize,
169                           sizeof(ULONG));
170         }
171         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
172         {
173             /* Return the exception code */
174             _SEH2_YIELD(return _SEH2_GetExceptionCode());
175         }
176         _SEH2_END;
177     }
178 
179     /* Check if a process was specified */
180     if (Process)
181     {
182         /* Reference it */
183         Status = ObReferenceObjectByHandle(Process,
184                                            PROCESS_QUERY_INFORMATION,
185                                            PsProcessType,
186                                            PreviousMode,
187                                            (PVOID*)&pProcess,
188                                            NULL);
189         if (!NT_SUCCESS(Status)) return(Status);
190     }
191     else
192     {
193         /* Segmented profile objects cannot be used system-wide */
194         if (Segment) return STATUS_INVALID_PARAMETER;
195 
196         /* No process was specified, which means a System-Wide Profile */
197         pProcess = NULL;
198 
199         /* For this, we need to check the Privilege */
200         if(!SeSinglePrivilegeCheck(SeSystemProfilePrivilege, PreviousMode))
201         {
202             DPRINT1("NtCreateProfile: Caller requires the SeSystemProfilePrivilege privilege!\n");
203             return STATUS_PRIVILEGE_NOT_HELD;
204         }
205     }
206 
207     /* Create the object */
208     InitializeObjectAttributes(&ObjectAttributes,
209                                NULL,
210                                0,
211                                NULL,
212                                NULL);
213     Status = ObCreateObject(KernelMode,
214                             ExProfileObjectType,
215                             &ObjectAttributes,
216                             PreviousMode,
217                             NULL,
218                             sizeof(EPROFILE),
219                             0,
220                             sizeof(EPROFILE) + sizeof(KPROFILE),
221                             (PVOID*)&Profile);
222     if (!NT_SUCCESS(Status))
223     {
224         /* Dereference the process object if it was specified */
225         if (pProcess) ObDereferenceObject(pProcess);
226 
227         /* Return Status */
228         return Status;
229     }
230 
231     /* Initialize it */
232     Profile->RangeBase = RangeBase;
233     Profile->RangeSize = RangeSize;
234     Profile->Buffer = Buffer;
235     Profile->BufferSize = BufferSize;
236     Profile->BucketSize = BucketSize;
237     Profile->LockedBufferAddress = NULL;
238     Profile->Segment = Segment;
239     Profile->ProfileSource = ProfileSource;
240     Profile->Affinity = Affinity;
241     Profile->Process = pProcess;
242 
243     /* Insert into the Object Tree */
244     Status = ObInsertObject ((PVOID)Profile,
245                              NULL,
246                              PROFILE_CONTROL,
247                              0,
248                              NULL,
249                              &hProfile);
250     ObDereferenceObject(Profile);
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(EPROFILE),
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                         (PKPROCESS)Profile->Process,
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     ExFreePoolWithTag(Profile->ProfileObject, TAG_PROFILE);
457 
458     /* Clear the Locked Buffer pointer, meaning the Object is Stopped */
459     Profile->LockedBufferAddress = NULL;
460 
461 Exit:
462     /* Release Mutex, Dereference and Return */
463     KeReleaseMutex(&ExpProfileMutex, FALSE);
464     ObDereferenceObject(Profile);
465     return Status;
466 }
467 
468 NTSTATUS
469 NTAPI
470 NtQueryIntervalProfile(IN KPROFILE_SOURCE ProfileSource,
471                        OUT PULONG Interval)
472 {
473     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
474     ULONG ReturnInterval;
475     NTSTATUS Status = STATUS_SUCCESS;
476     PAGED_CODE();
477 
478     /* Check if we were called from user-mode */
479     if (PreviousMode != KernelMode)
480     {
481         /* Enter SEH Block */
482         _SEH2_TRY
483         {
484             /* Validate interval */
485             ProbeForWriteUlong(Interval);
486         }
487         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
488         {
489             /* Return the exception code */
490             _SEH2_YIELD(return _SEH2_GetExceptionCode());
491         }
492         _SEH2_END;
493     }
494 
495     /* Query the Interval */
496     ReturnInterval = (ULONG)KeQueryIntervalProfile(ProfileSource);
497 
498     /* Enter SEH block for return */
499     _SEH2_TRY
500     {
501         /* Return the data */
502         *Interval = ReturnInterval;
503     }
504     _SEH2_EXCEPT(ExSystemExceptionFilter())
505     {
506         /* Get the exception code */
507         Status = _SEH2_GetExceptionCode();
508     }
509     _SEH2_END;
510 
511     /* Return Success */
512     return Status;
513 }
514 
515 NTSTATUS
516 NTAPI
517 NtSetIntervalProfile(IN ULONG Interval,
518                      IN KPROFILE_SOURCE Source)
519 {
520     /* Let the Kernel do the job */
521     KeSetIntervalProfile(Interval, Source);
522 
523     /* Nothing can go wrong */
524     return STATUS_SUCCESS;
525 }
526