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