* Sync up to trunk head (r65270).
[reactos.git] / ntoskrnl / kd64 / kdbreak.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/kd64/kdbreak.c
5 * PURPOSE: KD64 Breakpoint Support
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 ULONG
19 NTAPI
20 KdpAddBreakpoint(IN PVOID Address)
21 {
22 KD_BREAKPOINT_TYPE Content;
23 ULONG i;
24 NTSTATUS Status;
25
26 /* Loop current breakpoints */
27 for (i = 0; i < KD_BREAKPOINT_MAX; i++)
28 {
29 /* Check if the breakpoint is valid */
30 if ((KdpBreakpointTable[i].Flags & KdpBreakpointActive) &&
31 (KdpBreakpointTable[i].Address == Address))
32 {
33 /* Check if it's pending */
34 if ((KdpBreakpointTable[i].Flags & KdpBreakpointPending))
35 {
36 /* It's not pending anymore now */
37 KdpBreakpointTable[i].Flags &= ~KdpBreakpointPending;
38 return i + 1;
39 }
40 else
41 {
42 /* Fail */
43 return 0;
44 }
45 }
46 }
47
48 /* Find a free entry */
49 for (i = 0; i < KD_BREAKPOINT_MAX; i++) if (!(KdpBreakpointTable[i].Flags)) break;
50
51 /* Fail if no free entry was found */
52 if (i == KD_BREAKPOINT_MAX) return 0;
53
54 /* Save the old instruction */
55 Status = KdpCopyMemoryChunks((ULONG_PTR)Address,
56 &Content,
57 KD_BREAKPOINT_SIZE,
58 0,
59 MMDBG_COPY_UNSAFE,
60 NULL);
61
62 if (!NT_SUCCESS(Status))
63 {
64 /* TODO: Set it as a owed breakpoint */
65 KdpDprintf("Failed to set breakpoint at address 0x%p\n", Address);
66 return 0;
67 }
68
69 /* Write the entry */
70 KdpBreakpointTable[i].Address = Address;
71 KdpBreakpointTable[i].Content = Content;
72 KdpBreakpointTable[i].Flags = KdpBreakpointActive;
73
74 /* Write the breakpoint */
75 Status = KdpCopyMemoryChunks((ULONG_PTR)Address,
76 &KdpBreakpointInstruction,
77 KD_BREAKPOINT_SIZE,
78 0,
79 MMDBG_COPY_UNSAFE | MMDBG_COPY_WRITE,
80 NULL);
81 if (!NT_SUCCESS(Status))
82 {
83 /* This should never happen */
84 KdpDprintf("Unable to write breakpoint to address 0x%p\n", Address);
85 }
86
87 /* Return the breakpoint handle */
88 return i + 1;
89 }
90
91 BOOLEAN
92 NTAPI
93 KdpLowWriteContent(IN ULONG BpIndex)
94 {
95 NTSTATUS Status;
96
97 /* Make sure that the breakpoint is actually active */
98 if (KdpBreakpointTable[BpIndex].Flags & KdpBreakpointPending)
99 {
100 /* So we have a valid breakpoint, but it hasn't been used yet... */
101 KdpBreakpointTable[BpIndex].Flags &= ~KdpBreakpointPending;
102 return TRUE;
103 }
104
105 /* Is the original instruction a breakpoint anyway? */
106 if (KdpBreakpointTable[BpIndex].Content == KdpBreakpointInstruction)
107 {
108 /* Then leave it that way... */
109 return TRUE;
110 }
111
112 /* We have an active breakpoint with an instruction to bring back. Do it. */
113 Status = KdpCopyMemoryChunks((ULONG_PTR)KdpBreakpointTable[BpIndex].
114 Address,
115 &KdpBreakpointTable[BpIndex].Content,
116 KD_BREAKPOINT_SIZE,
117 0,
118 MMDBG_COPY_UNSAFE | MMDBG_COPY_WRITE,
119 NULL);
120 if (!NT_SUCCESS(Status))
121 {
122 /* TODO: Set it as a owed breakpoint */
123 KdpDprintf("Failed to delete breakpoint at address 0x%p\n",
124 KdpBreakpointTable[BpIndex].Address);
125 return FALSE;
126 }
127
128 /* Everything went fine, return */
129 return TRUE;
130 }
131
132 BOOLEAN
133 NTAPI
134 KdpLowRestoreBreakpoint(IN ULONG BpIndex)
135 {
136 NTSTATUS Status;
137
138 /* Were we not able to remove it earlier? */
139 if (KdpBreakpointTable[BpIndex].Flags & KdpBreakpointExpired)
140 {
141 /* Well then, we'll just re-use it and return success! */
142 KdpBreakpointTable[BpIndex].Flags &= ~KdpBreakpointExpired;
143 return TRUE;
144 }
145
146 /* Are we merely writing a breakpoint on top of another breakpoint? */
147 if (KdpBreakpointTable[BpIndex].Content == KdpBreakpointInstruction)
148 {
149 /* Nothing to do then... */
150 return TRUE;
151 }
152
153 /* Ok, we actually have to overwrite the instruction now */
154 Status = KdpCopyMemoryChunks((ULONG_PTR)KdpBreakpointTable[BpIndex].
155 Address,
156 &KdpBreakpointInstruction,
157 KD_BREAKPOINT_SIZE,
158 0,
159 MMDBG_COPY_UNSAFE | MMDBG_COPY_WRITE,
160 NULL);
161 if (!NT_SUCCESS(Status))
162 {
163 /* FIXME: Set it as a owed breakpoint */
164 KdpDprintf("Failed to restore breakpoint at address 0x%p\n",
165 KdpBreakpointTable[BpIndex].Address);
166 return FALSE;
167 }
168
169 /* Clear any possible previous pending flag and return success */
170 KdpBreakpointTable[BpIndex].Flags &= ~KdpBreakpointPending;
171 return TRUE;
172 }
173
174 BOOLEAN
175 NTAPI
176 KdpDeleteBreakpoint(IN ULONG BpEntry)
177 {
178 ULONG BpIndex = BpEntry - 1;
179
180 /* Check for invalid breakpoint entry */
181 if (!(BpEntry) || (BpEntry > KD_BREAKPOINT_MAX)) return FALSE;
182
183 /* If the specified breakpoint table entry is not valid, then return FALSE. */
184 if (!KdpBreakpointTable[BpIndex].Flags) return FALSE;
185
186 /* Check if the breakpoint is suspended */
187 if (KdpBreakpointTable[BpIndex].Flags & KdpBreakpointSuspended)
188 {
189 /* Check if breakpoint is not ...? */
190 if (!(KdpBreakpointTable[BpIndex].Flags & KdpBreakpointExpired))
191 {
192 /* Invalidate it and return success */
193 KdpBreakpointTable[BpIndex].Flags = 0;
194 return TRUE;
195 }
196 }
197
198 /* Restore original data, then invalidate it and return success */
199 if (KdpLowWriteContent(BpIndex)) KdpBreakpointTable[BpIndex].Flags = 0;
200 return TRUE;
201 }
202
203 BOOLEAN
204 NTAPI
205 KdpDeleteBreakpointRange(IN PVOID Base,
206 IN PVOID Limit)
207 {
208 ULONG BpIndex;
209 BOOLEAN Return = FALSE;
210
211 /* Loop the breakpoint table */
212 for (BpIndex = 0; BpIndex < KD_BREAKPOINT_MAX; BpIndex++)
213 {
214 /* Make sure that the breakpoint is active and matches the range. */
215 if ((KdpBreakpointTable[BpIndex].Flags & KdpBreakpointActive) &&
216 ((KdpBreakpointTable[BpIndex].Address >= Base) &&
217 (KdpBreakpointTable[BpIndex].Address <= Limit)))
218 {
219 /* Delete it */
220 Return = Return || KdpDeleteBreakpoint(BpIndex + 1);
221 }
222 }
223
224 /* Return to caller */
225 return Return;
226 }
227
228 VOID
229 NTAPI
230 KdpRestoreAllBreakpoints(VOID)
231 {
232 ULONG BpIndex;
233
234 /* No more suspended Breakpoints */
235 BreakpointsSuspended = FALSE;
236
237 /* Loop the breakpoints */
238 for (BpIndex = 0; BpIndex < KD_BREAKPOINT_MAX; BpIndex++)
239 {
240 /* Check if they are valid, suspended breakpoints */
241 if ((KdpBreakpointTable[BpIndex].Flags & KdpBreakpointActive) &&
242 (KdpBreakpointTable[BpIndex].Flags & KdpBreakpointSuspended))
243 {
244 /* Unsuspend them */
245 KdpBreakpointTable[BpIndex].Flags &= ~KdpBreakpointSuspended;
246 KdpLowRestoreBreakpoint(BpIndex);
247 }
248 }
249 }
250
251 VOID
252 NTAPI
253 KdpSuspendBreakPoint(IN ULONG BpEntry)
254 {
255 ULONG BpIndex = BpEntry - 1;
256
257 /* Check if this is a valid, unsuspended breakpoint */
258 if ((KdpBreakpointTable[BpIndex].Flags & KdpBreakpointActive) &&
259 !(KdpBreakpointTable[BpIndex].Flags & KdpBreakpointSuspended))
260 {
261 /* Suspend it */
262 KdpBreakpointTable[BpIndex].Flags |= KdpBreakpointSuspended;
263 KdpLowWriteContent(BpIndex);
264 }
265 }
266
267 VOID
268 NTAPI
269 KdpSuspendAllBreakPoints(VOID)
270 {
271 ULONG BpEntry;
272
273 /* Breakpoints are suspended */
274 BreakpointsSuspended = TRUE;
275
276 /* Loop every breakpoint */
277 for (BpEntry = 1; BpEntry <= KD_BREAKPOINT_MAX; BpEntry++)
278 {
279 /* Suspend it */
280 KdpSuspendBreakPoint(BpEntry);
281 }
282 }