1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
|
/*++
Copyright (c) 1989 Microsoft Corporation
Copyright (c) 1993 IBM Corporation
Module Name:
hypermap.c
Abstract:
This module contains the routines which map physical pages into
reserved PTEs within hyper space.
This module is machine dependent. This version is targetted
for PowerPC.
Author:
Lou Perazzoli (loup) 5-Apr-1989
Modified for PowerPC by Mark Mergen (mergen@watson.ibm.com) 11-Oct-1993
Revision History:
--*/
#include "mi.h"
PVOID
MiMapPageInHyperSpace (
IN ULONG PageFrameIndex,
IN PKIRQL OldIrql
)
/*++
Routine Description:
This routine maps the specified physical page into hyperspace
and returns the virtual address that maps the page.
************************************
* *
* Returns with a spin lock held!!! *
* *
************************************
Arguments:
PageFrameIndex - Supplies the physical page number to map.
Return Value:
Virtual address in hyperspace that maps the page.
RETURNS WITH THE HYPERSPACE SPIN LOCK HELD!!!!
The routine MiUnmapPageInHyperSpace MUST be called to release the lock!!!!
Environment:
Kernel mode.
--*/
{
ULONG i;
PMMPTE PointerPte;
MMPTE TempPte;
#if DBG
if (PageFrameIndex == 0) {
DbgPrint("attempt to map physical page 0 in hyper space\n");
KeBugCheck (MEMORY_MANAGEMENT);
}
#endif //DBG
//
// Find the proper location in hyper space and map the page there.
//
LOCK_HYPERSPACE(OldIrql);
PointerPte = MmFirstReservedMappingPte;
if (PointerPte->u.Hard.Valid == 1) {
//
// All the pages in reserved for mapping have been used,
// flush the TB and reinitialize the pages.
//
RtlZeroMemory ((PVOID)MmFirstReservedMappingPte,
(NUMBER_OF_MAPPING_PTES + 1) * sizeof(MMPTE));
PointerPte->u.Hard.PageFrameNumber = NUMBER_OF_MAPPING_PTES;
KeFlushEntireTb (TRUE, FALSE);
}
//
// Get the offset to the first free PTE.
//
i = PointerPte->u.Hard.PageFrameNumber;
//
// Change the offset for the next time through.
//
PointerPte->u.Hard.PageFrameNumber = i - 1;
//
// Point to the free entry and make it valid.
//
PointerPte += i;
ASSERT (PointerPte->u.Hard.Valid == 0);
TempPte = ValidPtePte;
TempPte.u.Hard.PageFrameNumber = PageFrameIndex;
*PointerPte = TempPte;
return MiGetVirtualAddressMappedByPte (PointerPte);
}
PVOID
MiMapImageHeaderInHyperSpace (
IN ULONG PageFrameIndex
)
/*++
Routine Description:
This routine maps the specified physical page into hyperspace
at the address reserved explicitly for image page header mapping
and returns the virtual address that maps the page. No other
hyperspace maps will affect this map. If another thread attempts
to map an image at the same time, it will be forced to wait until
this header is unmapped.
Arguments:
PageFrameIndex - Supplies the physical page number to map.
Return Value:
Virtual address in hyperspace that maps the page.
Environment:
Kernel mode.
--*/
{
MMPTE TempPte;
PMMPTE PointerPte;
KIRQL OldIrql;
#if DBG
if (PageFrameIndex == 0) {
DbgPrint("attempt to map physical page 0 in hyper space\n");
KeBugCheck (MEMORY_MANAGEMENT);
}
#endif //DBG
PointerPte = MiGetPteAddress (IMAGE_MAPPING_PTE);
LOCK_PFN (OldIrql);
while (PointerPte->u.Long != 0) {
//
// If there is no event specified, set one up.
//
if (MmWorkingSetList->WaitingForImageMapping == (PKEVENT)NULL) {
//
// Set the global event into the field and wait for it.
//
MmWorkingSetList->WaitingForImageMapping = &MmImageMappingPteEvent;
}
//
// Release the PFN lock and wait on the event in an
// atomic operation.
//
KeEnterCriticalRegion();
UNLOCK_PFN_AND_THEN_WAIT(OldIrql);
KeWaitForSingleObject(MmWorkingSetList->WaitingForImageMapping,
Executive,
KernelMode,
FALSE,
(PLARGE_INTEGER)NULL);
KeLeaveCriticalRegion();
LOCK_PFN (OldIrql);
}
ASSERT (PointerPte->u.Long == 0);
TempPte = ValidPtePte;
TempPte.u.Hard.PageFrameNumber = PageFrameIndex;
*PointerPte = TempPte;
UNLOCK_PFN (OldIrql);
return (PVOID)MiGetVirtualAddressMappedByPte (PointerPte);
}
VOID
MiUnmapImageHeaderInHyperSpace (
VOID
)
/*++
Routine Description:
This procedure unmaps the PTE reserved for mapping the image
header, flushes the TB, and, if the WaitingForImageMapping field
is not NULL, sets the specified event.
Arguments:
None.
Return Value:
None.
Environment:
Kernel mode.
--*/
{
MMPTE TempPte;
PMMPTE PointerPte;
KIRQL OldIrql;
PKEVENT Event;
PointerPte = MiGetPteAddress (IMAGE_MAPPING_PTE);
TempPte.u.Long = 0;
LOCK_PFN (OldIrql);
//
// Capture the current state of the event field and clear it out.
//
Event = MmWorkingSetList->WaitingForImageMapping;
MmWorkingSetList->WaitingForImageMapping = (PKEVENT)NULL;
ASSERT (PointerPte->u.Long != 0);
KeFlushSingleTb (IMAGE_MAPPING_PTE,
TRUE,
FALSE,
(PHARDWARE_PTE)PointerPte,
TempPte.u.Hard);
UNLOCK_PFN (OldIrql);
if (Event != (PKEVENT)NULL) {
//
// If there was an event specified, set the event.
//
KePulseEvent (Event, 0, FALSE);
}
return;
}
PVOID
MiMapPageToZeroInHyperSpace (
IN ULONG PageFrameIndex
)
/*++
Routine Description:
This procedure maps the specified physical page into hyper space
and returns the virtual address which maps the page.
NOTE: it maps it into the same location reserved for fork operations!!
This is only to be used by the zeroing page thread.
Arguments:
PageFrameIndex - Supplies the physical page number to map.
Return Value:
Returns the virtual address where the specified physical page was
mapped.
Environment:
Must be holding the PFN lock.
--*/
{
MMPTE TempPte;
PMMPTE PointerPte;
#if DBG
if (PageFrameIndex == 0) {
DbgPrint("attempt to map physical page 0 in hyper space\n");
KeBugCheck (MEMORY_MANAGEMENT);
}
#endif //DBG
PointerPte = MiGetPteAddress (ZEROING_PAGE_PTE);
TempPte.u.Long = 0;
KeFlushSingleTb (ZEROING_PAGE_PTE,
TRUE,
FALSE,
(PHARDWARE_PTE)PointerPte,
TempPte.u.Hard);
TempPte = ValidPtePte;
TempPte.u.Hard.PageFrameNumber = PageFrameIndex;
*PointerPte = TempPte;
return ZEROING_PAGE_PTE;
}
|
