[NTOS]: Implement MmDeleteTeb, VADs are now deleted/freed on thread exit as well...
[reactos.git] / reactos / ntoskrnl / kd / amd64 / kdmemsup.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Kernel
4 * FILE: ntoskrnl/kd/amd64/kdmemsup.c
5 * PURPOSE: Kernel Debugger Safe Memory Support
6 *
7 * PROGRAMMERS: arty
8 */
9
10 #include <ntoskrnl.h>
11 #define NDEBUG
12 #include <debug.h>
13
14 #define HIGH_PHYS_MASK 0x80000000
15 #define PAGE_TABLE_MASK 0x3ff
16 #define BIG_PAGE_SIZE (1<<22)
17 #define CR4_PAGE_SIZE_BIT 0x10
18 #define PDE_PRESENT_BIT 0x01
19 #define PDE_W_BIT 0x02
20 #define PDE_PWT_BIT 0x08
21 #define PDE_PCD_BIT 0x10
22 #define PDE_ACCESSED_BIT 0x20
23 #define PDE_DIRTY_BIT 0x40
24 #define PDE_PS_BIT 0x80
25
26 #define MI_KDBG_TMP_PAGE_1 (HYPER_SPACE + 0x400000 - PAGE_SIZE)
27 #define MI_KDBG_TMP_PAGE_0 (MI_KDBG_TMP_PAGE_1 - PAGE_SIZE)
28
29 /* VARIABLES ***************************************************************/
30
31 static BOOLEAN KdpPhysAccess = FALSE;
32
33 static
34 ULONG_PTR
35 KdpPhysMap(ULONG_PTR PhysAddr, LONG Len)
36 {
37 MMPTE TempPte;
38 PMMPTE PointerPte;
39 ULONG_PTR VirtAddr;
40
41 TempPte.u.Long = PDE_PRESENT_BIT | PDE_W_BIT | PDE_PWT_BIT |
42 PDE_PCD_BIT | PDE_ACCESSED_BIT | PDE_DIRTY_BIT;
43
44 if ((PhysAddr & (PAGE_SIZE - 1)) + Len > PAGE_SIZE)
45 {
46 TempPte.u.Hard.PageFrameNumber = (PhysAddr >> PAGE_SHIFT) + 1;
47 PointerPte = MiAddressToPte((PVOID)MI_KDBG_TMP_PAGE_1);
48 *PointerPte = TempPte;
49 VirtAddr = (ULONG_PTR)PointerPte << 10;
50 KeInvalidateTlbEntry((PVOID)VirtAddr);
51 }
52
53 TempPte.u.Hard.PageFrameNumber = PhysAddr >> PAGE_SHIFT;
54 PointerPte = MiAddressToPte((PVOID)MI_KDBG_TMP_PAGE_0);
55 *PointerPte = TempPte;
56 VirtAddr = (ULONG_PTR)PointerPte << 10;
57 KeInvalidateTlbEntry((PVOID)VirtAddr);
58
59 return VirtAddr + (PhysAddr & (PAGE_SIZE - 1));
60 }
61
62 static
63 ULONGLONG
64 KdpPhysRead(ULONG_PTR PhysAddr, LONG Len)
65 {
66 ULONG_PTR Addr;
67 ULONGLONG Result = 0;
68
69 Addr = KdpPhysMap(PhysAddr, Len);
70
71 switch (Len)
72 {
73 case 8:
74 Result = *((PULONGLONG)Addr);
75 break;
76 case 4:
77 Result = *((PULONG)Addr);
78 break;
79 case 2:
80 Result = *((PUSHORT)Addr);
81 break;
82 case 1:
83 Result = *((PUCHAR)Addr);
84 break;
85 }
86
87 return Result;
88 }
89
90 static
91 VOID
92 KdpPhysWrite(ULONG_PTR PhysAddr, LONG Len, ULONGLONG Value)
93 {
94 ULONG_PTR Addr;
95
96 Addr = KdpPhysMap(PhysAddr, Len);
97
98 switch (Len)
99 {
100 case 8:
101 *((PULONGLONG)Addr) = Value;
102 break;
103 case 4:
104 *((PULONG)Addr) = Value;
105 break;
106 case 2:
107 *((PUSHORT)Addr) = Value;
108 break;
109 case 1:
110 *((PUCHAR)Addr) = Value;
111 break;
112 }
113 }
114
115 BOOLEAN
116 NTAPI
117 KdpTranslateAddress(ULONG_PTR Addr, PULONG_PTR ResultAddr)
118 {
119 ULONG_PTR CR3Value = __readcr3();
120 ULONG_PTR CR4Value = __readcr4();
121 ULONG_PTR PageDirectory = (CR3Value & ~(PAGE_SIZE-1)) +
122 ((Addr >> 22) * sizeof(ULONG));
123 ULONG_PTR PageDirectoryEntry = KdpPhysRead(PageDirectory, sizeof(ULONG));
124
125 /* Not present -> fail */
126 if (!(PageDirectoryEntry & PDE_PRESENT_BIT))
127 {
128 return FALSE;
129 }
130
131 /* Big Page? */
132 if ((PageDirectoryEntry & PDE_PS_BIT) && (CR4Value & CR4_PAGE_SIZE_BIT))
133 {
134 *ResultAddr = (PageDirectoryEntry & ~(BIG_PAGE_SIZE-1)) +
135 (Addr & (BIG_PAGE_SIZE-1));
136 return TRUE;
137 }
138 else
139 {
140 ULONG_PTR PageTableAddr =
141 (PageDirectoryEntry & ~(PAGE_SIZE-1)) +
142 ((Addr >> PAGE_SHIFT) & PAGE_TABLE_MASK) * sizeof(ULONG);
143 ULONG_PTR PageTableEntry = KdpPhysRead(PageTableAddr, sizeof(ULONG));
144 if (PageTableEntry & PDE_PRESENT_BIT)
145 {
146 *ResultAddr = (PageTableEntry & ~(PAGE_SIZE-1)) +
147 (Addr & (PAGE_SIZE-1));
148 return TRUE;
149 }
150 }
151
152 return FALSE;
153 }
154
155 BOOLEAN
156 NTAPI
157 KdpSafeReadMemory(ULONG_PTR Addr, LONG Len, PVOID Value)
158 {
159 ULONG_PTR ResultPhysAddr;
160
161 if (!KdpPhysAccess)
162 {
163 memcpy(Value, (PVOID)Addr, Len);
164 return TRUE;
165 }
166
167 memset(Value, 0, Len);
168
169 if (!KdpTranslateAddress(Addr, &ResultPhysAddr))
170 return FALSE;
171
172 switch (Len)
173 {
174 case 8:
175 *((PULONGLONG)Value) = KdpPhysRead(ResultPhysAddr, Len);
176 break;
177 case 4:
178 *((PULONG)Value) = KdpPhysRead(ResultPhysAddr, Len);
179 break;
180 case 2:
181 *((PUSHORT)Value) = KdpPhysRead(ResultPhysAddr, Len);
182 break;
183 case 1:
184 *((PUCHAR)Value) = KdpPhysRead(ResultPhysAddr, Len);
185 break;
186 }
187
188 return TRUE;
189 }
190
191 BOOLEAN
192 NTAPI
193 KdpSafeWriteMemory(ULONG_PTR Addr, LONG Len, ULONGLONG Value)
194 {
195 ULONG_PTR ResultPhysAddr;
196
197 if (!KdpPhysAccess)
198 {
199 memcpy((PVOID)Addr, &Value, Len);
200 return TRUE;
201 }
202
203 if (!KdpTranslateAddress(Addr, &ResultPhysAddr))
204 return FALSE;
205
206 KdpPhysWrite(ResultPhysAddr, Len, Value);
207 return TRUE;
208 }
209
210 VOID
211 NTAPI
212 KdpEnableSafeMem(VOID)
213 {
214 KdpPhysAccess = TRUE;
215 }
216
217 /* EOF */