[STORPORT] Fix x64 build
[reactos.git] / ntoskrnl / ke / profobj.c
1 /*
2 * COPYRIGHT: GPL - See COPYING in the top level directory
3 * PROJECT: ReactOS Kernel
4 * FILE: ntoskrnl/ke/profobj.c
5 * PURPOSE: Kernel Profiling
6 * PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
7 */
8
9 /* INCLUDES *****************************************************************/
10
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <debug.h>
14
15 /* GLOBALS *******************************************************************/
16
17 KIRQL KiProfileIrql = PROFILE_LEVEL;
18 LIST_ENTRY KiProfileListHead;
19 LIST_ENTRY KiProfileSourceListHead;
20 KSPIN_LOCK KiProfileLock;
21 ULONG KiProfileTimeInterval = 78125; /* Default resolution 7.8ms (sysinternals) */
22 ULONG KiProfileAlignmentFixupInterval;
23
24 /* FUNCTIONS *****************************************************************/
25
26 VOID
27 NTAPI
28 KeInitializeProfile(PKPROFILE Profile,
29 PKPROCESS Process,
30 PVOID ImageBase,
31 SIZE_T ImageSize,
32 ULONG BucketSize,
33 KPROFILE_SOURCE ProfileSource,
34 KAFFINITY Affinity)
35 {
36 /* Initialize the Header */
37 Profile->Type = ProfileObject;
38 Profile->Size = sizeof(KPROFILE);
39
40 /* Copy all the settings we were given */
41 Profile->Process = Process;
42 Profile->RangeBase = ImageBase;
43 Profile->BucketShift = BucketSize - 2; /* See ntinternals.net -- Alex */
44 Profile->RangeLimit = (PVOID)((ULONG_PTR)ImageBase + ImageSize);
45 Profile->Started = FALSE;
46 Profile->Source = ProfileSource;
47 Profile->Affinity = Affinity;
48 }
49
50 BOOLEAN
51 NTAPI
52 KeStartProfile(IN PKPROFILE Profile,
53 IN PVOID Buffer)
54 {
55 KIRQL OldIrql;
56 PKPROFILE_SOURCE_OBJECT SourceBuffer;
57 PKPROFILE_SOURCE_OBJECT CurrentSource;
58 BOOLEAN FreeBuffer = TRUE, SourceFound = FALSE, StartedProfile;
59 PKPROCESS ProfileProcess;
60 PLIST_ENTRY NextEntry;
61
62 /* Allocate a buffer first, before we raise IRQL */
63 SourceBuffer = ExAllocatePoolWithTag(NonPagedPool,
64 sizeof(KPROFILE_SOURCE_OBJECT),
65 'forP');
66 if (!SourceBuffer) return FALSE;
67 RtlZeroMemory(SourceBuffer, sizeof(KPROFILE_SOURCE_OBJECT));
68
69 /* Raise to profile IRQL and acquire the profile lock */
70 KeRaiseIrql(KiProfileIrql, &OldIrql);
71 KeAcquireSpinLockAtDpcLevel(&KiProfileLock);
72
73 /* Make sure it's not running */
74 if (!Profile->Started)
75 {
76 /* Set it as Started */
77 Profile->Buffer = Buffer;
78 Profile->Started = TRUE;
79 StartedProfile = TRUE;
80
81 /* Get the process, if any */
82 ProfileProcess = Profile->Process;
83
84 /* Check where we should insert it */
85 if (ProfileProcess)
86 {
87 /* Insert it into the Process List */
88 InsertTailList(&ProfileProcess->ProfileListHead, &Profile->ProfileListEntry);
89 }
90 else
91 {
92 /* Insert it into the Global List */
93 InsertTailList(&KiProfileListHead, &Profile->ProfileListEntry);
94 }
95
96 /* Start looping */
97 for (NextEntry = KiProfileSourceListHead.Flink;
98 NextEntry != &KiProfileSourceListHead;
99 NextEntry = NextEntry->Flink)
100 {
101 /* Get the entry */
102 CurrentSource = CONTAINING_RECORD(NextEntry,
103 KPROFILE_SOURCE_OBJECT,
104 ListEntry);
105
106 /* Check if it's the same as the one being requested now */
107 if (CurrentSource->Source == Profile->Source)
108 {
109 /* It is, break out */
110 SourceFound = TRUE;
111 break;
112 }
113 }
114
115 /* See if the loop found something */
116 if (!SourceFound)
117 {
118 /* Nothing found, use our allocated buffer */
119 CurrentSource = SourceBuffer;
120
121 /* Set up the Source Object */
122 CurrentSource->Source = Profile->Source;
123 InsertHeadList(&KiProfileSourceListHead, &CurrentSource->ListEntry);
124
125 /* Don't free the pool later on */
126 FreeBuffer = FALSE;
127 }
128 }
129 else
130 {
131 /* Already running so nothing to start */
132 StartedProfile = FALSE;
133 }
134
135 /* Release the profile lock */
136 KeReleaseSpinLockFromDpcLevel(&KiProfileLock);
137
138 /* Tell HAL to start the profile interrupt */
139 HalStartProfileInterrupt(Profile->Source);
140
141 /* Lower back to original IRQL */
142 KeLowerIrql(OldIrql);
143
144 /* Free the pool */
145 if (FreeBuffer) ExFreePoolWithTag(SourceBuffer, 'forP');
146
147 /* Return whether we could start the profile */
148 return StartedProfile;
149 }
150
151 BOOLEAN
152 NTAPI
153 KeStopProfile(IN PKPROFILE Profile)
154 {
155 KIRQL OldIrql;
156 PKPROFILE_SOURCE_OBJECT CurrentSource = NULL;
157 PLIST_ENTRY NextEntry;
158 BOOLEAN SourceFound = FALSE, StoppedProfile;
159
160 /* Raise to profile IRQL and acquire the profile lock */
161 KeRaiseIrql(KiProfileIrql, &OldIrql);
162 KeAcquireSpinLockAtDpcLevel(&KiProfileLock);
163
164 /* Make sure it's running */
165 if (Profile->Started)
166 {
167 /* Remove it from the list and disable */
168 RemoveEntryList(&Profile->ProfileListEntry);
169 Profile->Started = FALSE;
170 StoppedProfile = TRUE;
171
172 /* Start looping */
173 for (NextEntry = KiProfileSourceListHead.Flink;
174 NextEntry != &KiProfileSourceListHead;
175 NextEntry = NextEntry->Flink)
176 {
177 /* Get the entry */
178 CurrentSource = CONTAINING_RECORD(NextEntry,
179 KPROFILE_SOURCE_OBJECT,
180 ListEntry);
181
182 /* Check if this is the Source Object */
183 if (CurrentSource->Source == Profile->Source)
184 {
185 /* Remember we found one */
186 SourceFound = TRUE;
187
188 /* Remove it and break out */
189 RemoveEntryList(&CurrentSource->ListEntry);
190 break;
191 }
192 }
193
194 }
195 else
196 {
197 /* It wasn't! */
198 StoppedProfile = FALSE;
199 }
200
201 /* Release the profile lock */
202 KeReleaseSpinLockFromDpcLevel(&KiProfileLock);
203
204 /* Stop the profile interrupt */
205 HalStopProfileInterrupt(Profile->Source);
206
207 /* Lower back to original IRQL */
208 KeLowerIrql(OldIrql);
209
210 /* Free the Source Object */
211 if (SourceFound) ExFreePool(CurrentSource);
212
213 /* Return whether we could stop the profile */
214 return StoppedProfile;
215 }
216
217 ULONG
218 NTAPI
219 KeQueryIntervalProfile(IN KPROFILE_SOURCE ProfileSource)
220 {
221 HAL_PROFILE_SOURCE_INFORMATION ProfileSourceInformation;
222 ULONG ReturnLength, Interval;
223 NTSTATUS Status;
224
225 /* Check what profile this is */
226 if (ProfileSource == ProfileTime)
227 {
228 /* Return the time interval */
229 Interval = KiProfileTimeInterval;
230 }
231 else if (ProfileSource == ProfileAlignmentFixup)
232 {
233 /* Return the alignment interval */
234 Interval = KiProfileAlignmentFixupInterval;
235 }
236 else
237 {
238 /* Request it from HAL */
239 ProfileSourceInformation.Source = ProfileSource;
240 Status = HalQuerySystemInformation(HalProfileSourceInformation,
241 sizeof(HAL_PROFILE_SOURCE_INFORMATION),
242 &ProfileSourceInformation,
243 &ReturnLength);
244
245 /* Check if HAL handled it and supports this profile */
246 if (NT_SUCCESS(Status) && (ProfileSourceInformation.Supported))
247 {
248 /* Get the interval */
249 Interval = ProfileSourceInformation.Interval;
250 }
251 else
252 {
253 /* Unsupported or invalid source, fail */
254 Interval = 0;
255 }
256 }
257
258 /* Return the interval we got */
259 return Interval;
260 }
261
262 VOID
263 NTAPI
264 KeSetIntervalProfile(IN ULONG Interval,
265 IN KPROFILE_SOURCE ProfileSource)
266 {
267 HAL_PROFILE_SOURCE_INTERVAL ProfileSourceInterval;
268
269 /* Check what profile this is */
270 if (ProfileSource == ProfileTime)
271 {
272 /* Set the interval through HAL */
273 KiProfileTimeInterval = (ULONG)HalSetProfileInterval(Interval);
274 }
275 else if (ProfileSource == ProfileAlignmentFixup)
276 {
277 /* Set the alignment interval */
278 KiProfileAlignmentFixupInterval = Interval;
279 }
280 else
281 {
282 /* HAL handles any other interval */
283 ProfileSourceInterval.Source = ProfileSource;
284 ProfileSourceInterval.Interval = Interval;
285 HalSetSystemInformation(HalProfileSourceInterval,
286 sizeof(HAL_PROFILE_SOURCE_INTERVAL),
287 &ProfileSourceInterval);
288 }
289 }
290
291 /*
292 * @implemented
293 */
294 VOID
295 NTAPI
296 KeProfileInterrupt(IN PKTRAP_FRAME TrapFrame)
297 {
298 /* Called from HAL for Timer Profiling */
299 KeProfileInterruptWithSource(TrapFrame, ProfileTime);
300 }
301
302 VOID
303 NTAPI
304 KiParseProfileList(IN PKTRAP_FRAME TrapFrame,
305 IN KPROFILE_SOURCE Source,
306 IN PLIST_ENTRY ListHead)
307 {
308 PULONG BucketValue;
309 PKPROFILE Profile;
310 PLIST_ENTRY NextEntry;
311 ULONG_PTR ProgramCounter;
312
313 /* Get the Program Counter */
314 ProgramCounter = KeGetTrapFramePc(TrapFrame);
315
316 /* Loop the List */
317 for (NextEntry = ListHead->Flink;
318 NextEntry != ListHead;
319 NextEntry = NextEntry->Flink)
320 {
321 /* Get the entry */
322 Profile = CONTAINING_RECORD(NextEntry, KPROFILE, ProfileListEntry);
323
324 /* Check if the source is good, and if it's within the range */
325 if ((Profile->Source != Source) ||
326 (ProgramCounter < (ULONG_PTR)Profile->RangeBase) ||
327 (ProgramCounter > (ULONG_PTR)Profile->RangeLimit))
328 {
329 continue;
330 }
331
332 /* Get the Pointer to the Bucket Value representing this Program Counter */
333 BucketValue = (PULONG)((ULONG_PTR)Profile->Buffer +
334 (((ProgramCounter - (ULONG_PTR)Profile->RangeBase)
335 >> Profile->BucketShift) &~ 0x3));
336
337 /* Increment the value */
338 (*BucketValue)++;
339 }
340 }
341
342 /*
343 * @implemented
344 *
345 * Remarks:
346 * Called from HAL, this function looks up the process
347 * entries, finds the proper source object, verifies the
348 * ranges with the trapframe data, and inserts the information
349 * from the trap frame into the buffer, while using buckets and
350 * shifting like we specified. -- Alex
351 */
352 VOID
353 NTAPI
354 KeProfileInterruptWithSource(IN PKTRAP_FRAME TrapFrame,
355 IN KPROFILE_SOURCE Source)
356 {
357 PKPROCESS Process = KeGetCurrentThread()->ApcState.Process;
358
359 /* We have to parse 2 lists. Per-Process and System-Wide */
360 KiParseProfileList(TrapFrame, Source, &Process->ProfileListHead);
361 KiParseProfileList(TrapFrame, Source, &KiProfileListHead);
362 }
363
364 /*
365 * @implemented
366 */
367 VOID
368 NTAPI
369 KeSetProfileIrql(IN KIRQL ProfileIrql)
370 {
371 /* Set the IRQL at which Profiling will run */
372 KiProfileIrql = ProfileIrql;
373 }