Synchronize with trunk r58606.
[reactos.git] / ntoskrnl / kd64 / kdinit.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/kd64/kdinit.c
5 * PURPOSE: KD64 Initialization Code
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 * Stefan Ginsberg (stefan.ginsberg@reactos.org)
8 */
9
10 /* INCLUDES ******************************************************************/
11
12 #include <ntoskrnl.h>
13 #define NDEBUG
14 #include <debug.h>
15
16 /* FUNCTIONS *****************************************************************/
17
18 VOID
19 NTAPI
20 KdUpdateDataBlock(VOID)
21 {
22 /* Update the KeUserCallbackDispatcher pointer */
23 KdDebuggerDataBlock.KeUserCallbackDispatcher =
24 (ULONG_PTR)KeUserCallbackDispatcher;
25 }
26
27 BOOLEAN
28 NTAPI
29 KdRegisterDebuggerDataBlock(IN ULONG Tag,
30 IN PDBGKD_DEBUG_DATA_HEADER64 DataHeader,
31 IN ULONG Size)
32 {
33 KIRQL OldIrql;
34 PLIST_ENTRY NextEntry;
35 PDBGKD_DEBUG_DATA_HEADER64 CurrentHeader;
36
37 /* Acquire the Data Lock */
38 KeAcquireSpinLock(&KdpDataSpinLock, &OldIrql);
39
40 /* Loop the debugger data list */
41 NextEntry = KdpDebuggerDataListHead.Flink;
42 while (NextEntry != &KdpDebuggerDataListHead)
43 {
44 /* Get the header for this entry */
45 CurrentHeader = CONTAINING_RECORD(NextEntry,
46 DBGKD_DEBUG_DATA_HEADER64,
47 List);
48
49 /* Move to the next one */
50 NextEntry = NextEntry->Flink;
51
52 /* Check if we already have this data block */
53 if ((CurrentHeader == DataHeader) || (CurrentHeader->OwnerTag == Tag))
54 {
55 /* Release the lock and fail */
56 KeReleaseSpinLock(&KdpDataSpinLock, OldIrql);
57 return FALSE;
58 }
59 }
60
61 /* Setup the header */
62 DataHeader->OwnerTag = Tag;
63 DataHeader->Size = Size;
64
65 /* Insert it into the list and release the lock */
66 InsertTailList(&KdpDebuggerDataListHead, (PLIST_ENTRY)&DataHeader->List);
67 KeReleaseSpinLock(&KdpDataSpinLock, OldIrql);
68 return TRUE;
69 }
70
71 BOOLEAN
72 NTAPI
73 KdInitSystem(IN ULONG BootPhase,
74 IN PLOADER_PARAMETER_BLOCK LoaderBlock)
75 {
76 BOOLEAN EnableKd, DisableKdAfterInit = FALSE, BlockEnable;
77 LPSTR CommandLine, DebugLine, DebugOptionStart, DebugOptionEnd;
78 STRING ImageName;
79 PLDR_DATA_TABLE_ENTRY LdrEntry;
80 PLIST_ENTRY NextEntry;
81 ULONG i, j, Length;
82 SIZE_T DebugOptionLength;
83 CHAR NameBuffer[256];
84 PWCHAR Name;
85
86 #if defined(__GNUC__)
87 /* Make gcc happy */
88 BlockEnable = FALSE;
89 #endif
90
91 /* Check if this is Phase 1 */
92 if (BootPhase)
93 {
94 /* Just query the performance counter */
95 KeQueryPerformanceCounter(&KdPerformanceCounterRate);
96 return TRUE;
97 }
98
99 /* Check if we already initialized once */
100 if (KdDebuggerEnabled) return TRUE;
101
102 /* Set the Debug Routine as the Stub for now */
103 KiDebugRoutine = KdpStub;
104
105 /* Disable break after symbol load for now */
106 KdBreakAfterSymbolLoad = FALSE;
107
108 /* Check if the Debugger Data Block was already initialized */
109 if (!KdpDebuggerDataListHead.Flink)
110 {
111 /* It wasn't...Initialize the KD Data Listhead */
112 InitializeListHead(&KdpDebuggerDataListHead);
113
114 /* Register the Debugger Data Block */
115 KdRegisterDebuggerDataBlock(KDBG_TAG,
116 &KdDebuggerDataBlock.Header,
117 sizeof(KdDebuggerDataBlock));
118
119 /* Fill out the KD Version Block */
120 KdVersionBlock.MajorVersion = (USHORT)((DBGKD_MAJOR_NT << 8) | (NtBuildNumber >> 28));
121 KdVersionBlock.MinorVersion = (USHORT)(NtBuildNumber & 0xFFFF);
122
123 #ifdef CONFIG_SMP
124 /* This is an MP Build */
125 KdVersionBlock.Flags |= DBGKD_VERS_FLAG_MP;
126 #endif
127
128 /* Save Pointers to Loaded Module List and Debugger Data */
129 KdVersionBlock.PsLoadedModuleList = (ULONG64)(LONG_PTR)&PsLoadedModuleList;
130 KdVersionBlock.DebuggerDataList = (ULONG64)(LONG_PTR)&KdpDebuggerDataListHead;
131
132 /* Set protocol limits */
133 KdVersionBlock.MaxStateChange = DbgKdMaximumStateChange -
134 DbgKdMinimumStateChange;
135 KdVersionBlock.MaxManipulate = DbgKdMaximumManipulate -
136 DbgKdMinimumManipulate;
137 KdVersionBlock.Unused[0] = 0;
138
139 /* Link us in the KPCR */
140 KeGetPcr()->KdVersionBlock = &KdVersionBlock;
141 }
142
143 /* Check if we have a loader block */
144 if (LoaderBlock)
145 {
146 /* Get the image entry */
147 LdrEntry = CONTAINING_RECORD(LoaderBlock->LoadOrderListHead.Flink,
148 LDR_DATA_TABLE_ENTRY,
149 InLoadOrderLinks);
150
151 /* Save the Kernel Base */
152 PsNtosImageBase = (ULONG_PTR)LdrEntry->DllBase;
153 KdVersionBlock.KernBase = (ULONG64)(LONG_PTR)LdrEntry->DllBase;
154
155 /* Check if we have a command line */
156 CommandLine = LoaderBlock->LoadOptions;
157 if (CommandLine)
158 {
159 /* Upcase it */
160 _strupr(CommandLine);
161
162 /* Assume we'll disable KD */
163 EnableKd = FALSE;
164
165 /* Check for CRASHDEBUG, NODEBUG and just DEBUG */
166 if (strstr(CommandLine, "CRASHDEBUG"))
167 {
168 /* Don't enable KD now, but allow it to be enabled later */
169 KdPitchDebugger = FALSE;
170 }
171 else if (strstr(CommandLine, "NODEBUG"))
172 {
173 /* Don't enable KD and don't let it be enabled later */
174 KdPitchDebugger = TRUE;
175 }
176 else if ((DebugLine = strstr(CommandLine, "DEBUG")) != NULL)
177 {
178 /* Enable KD */
179 EnableKd = TRUE;
180
181 /* Check if there are any options */
182 if (DebugLine[5] == '=')
183 {
184 /* Save pointers */
185 DebugOptionStart = DebugOptionEnd = &DebugLine[6];
186
187 /* Scan the string for debug options */
188 for (;;)
189 {
190 /* Loop until we reach the end of the string */
191 while (*DebugOptionEnd != ANSI_NULL)
192 {
193 /* Check if this is a comma, a space or a tab */
194 if ((*DebugOptionEnd == ',') ||
195 (*DebugOptionEnd == ' ') ||
196 (*DebugOptionEnd == '\t'))
197 {
198 /*
199 * We reached the end of the option or
200 * the end of the string, break out
201 */
202 break;
203 }
204 else
205 {
206 /* Move on to the next character */
207 DebugOptionEnd++;
208 }
209 }
210
211 /* Calculate the length of the current option */
212 DebugOptionLength = (DebugOptionEnd - DebugOptionStart);
213
214 /*
215 * Break out if we reached the last option
216 * or if there were no options at all
217 */
218 if (!DebugOptionLength) break;
219
220 /* Now check which option this is */
221 if ((DebugOptionLength == 10) &&
222 !(strncmp(DebugOptionStart, "AUTOENABLE", 10)))
223 {
224 /*
225 * Disable the debugger, but
226 * allow it to be reenabled
227 */
228 DisableKdAfterInit = TRUE;
229 BlockEnable = FALSE;
230 KdAutoEnableOnEvent = TRUE;
231 }
232 else if ((DebugOptionLength == 7) &&
233 !(strncmp(DebugOptionStart, "DISABLE", 7)))
234 {
235 /* Disable the debugger */
236 DisableKdAfterInit = TRUE;
237 BlockEnable = TRUE;
238 KdAutoEnableOnEvent = FALSE;
239 }
240 else if ((DebugOptionLength == 6) &&
241 !(strncmp(DebugOptionStart, "NOUMEX", 6)))
242 {
243 /* Ignore user mode exceptions */
244 KdIgnoreUmExceptions = TRUE;
245 }
246
247 /*
248 * If there are more options then
249 * the next character should be a comma
250 */
251 if (*DebugOptionEnd != ',')
252 {
253 /* It isn't, break out */
254 break;
255 }
256
257 /* Move on to the next option */
258 DebugOptionEnd++;
259 DebugOptionStart = DebugOptionEnd;
260 }
261 }
262 }
263 }
264 else
265 {
266 /* No command line options? Disable debugger by default */
267 KdPitchDebugger = TRUE;
268 EnableKd = FALSE;
269 }
270 }
271 else
272 {
273 /* Called from a bugcheck or a re-enable. Save the Kernel Base */
274 KdVersionBlock.KernBase = (ULONG64)(LONG_PTR)PsNtosImageBase;
275
276 /* Unconditionally enable KD */
277 EnableKd = TRUE;
278 }
279
280 /* Set the Kernel Base in the Data Block */
281 KdDebuggerDataBlock.KernBase = (ULONG_PTR)KdVersionBlock.KernBase;
282
283 /* Initialize the debugger if requested */
284 if ((EnableKd) && (NT_SUCCESS(KdDebuggerInitialize0(LoaderBlock))))
285 {
286 /* Now set our real KD routine */
287 KiDebugRoutine = KdpTrap;
288
289 /* Check if we've already initialized our structures */
290 if (!KdpDebuggerStructuresInitialized)
291 {
292 /* Set the Debug Switch Routine and Retries*/
293 KdpContext.KdpDefaultRetries = 20;
294 KiDebugSwitchRoutine = KdpSwitchProcessor;
295
296 /* Initialize the Time Slip DPC */
297 KeInitializeDpc(&KdpTimeSlipDpc, KdpTimeSlipDpcRoutine, NULL);
298 KeInitializeTimer(&KdpTimeSlipTimer);
299 ExInitializeWorkItem(&KdpTimeSlipWorkItem, KdpTimeSlipWork, NULL);
300
301 /* First-time initialization done! */
302 KdpDebuggerStructuresInitialized = TRUE;
303 }
304
305 /* Initialize the timer */
306 KdTimerStart.QuadPart = 0;
307
308 /* Officially enable KD */
309 KdPitchDebugger = FALSE;
310 KdDebuggerEnabled = TRUE;
311
312 /* Let user-mode know that it's enabled as well */
313 #undef KdDebuggerEnabled
314 SharedUserData->KdDebuggerEnabled = TRUE;
315 #define KdDebuggerEnabled _KdDebuggerEnabled
316
317 /* Check if the debugger should be disabled initially */
318 if (DisableKdAfterInit)
319 {
320 /* Disable it */
321 KdDisableDebuggerWithLock(FALSE);
322
323 /*
324 * Save the enable block state and return initialized
325 * (the debugger is active but disabled).
326 */
327 KdBlockEnable = BlockEnable;
328 return TRUE;
329 }
330
331 /* Check if we have a loader block */
332 if (LoaderBlock)
333 {
334 /* Loop boot images */
335 NextEntry = LoaderBlock->LoadOrderListHead.Flink;
336 i = 0;
337 while ((NextEntry != &LoaderBlock->LoadOrderListHead) && (i < 2))
338 {
339 /* Get the image entry */
340 LdrEntry = CONTAINING_RECORD(NextEntry,
341 LDR_DATA_TABLE_ENTRY,
342 InLoadOrderLinks);
343
344 /* Generate the image name */
345 Name = LdrEntry->FullDllName.Buffer;
346 Length = LdrEntry->FullDllName.Length / sizeof(WCHAR);
347 j = 0;
348 do
349 {
350 /* Do cheap Unicode to ANSI conversion */
351 NameBuffer[j++] = (CHAR)*Name++;
352 } while (j < Length);
353
354 /* Null-terminate */
355 NameBuffer[j] = ANSI_NULL;
356
357 /* Load symbols for image */
358 RtlInitString(&ImageName, NameBuffer);
359 DbgLoadImageSymbols(&ImageName,
360 LdrEntry->DllBase,
361 (ULONG_PTR)ZwCurrentProcess());
362
363 /* Go to the next entry */
364 NextEntry = NextEntry->Flink;
365 i++;
366 }
367 }
368
369 /* Check for incoming breakin and break on symbol load if we have it*/
370 KdBreakAfterSymbolLoad = KdPollBreakIn();
371 }
372 else
373 {
374 /* Disable debugger */
375 KdDebuggerNotPresent = TRUE;
376 }
377
378 /* Return initialized */
379 return TRUE;
380 }