hypermap.c File Reference

#include "mi.h"

Go to the source code of this file.

Functions
PVOID	MiMapPageInHyperSpace (IN ULONG PageFrameIndex, IN PKIRQL OldIrql)
PVOID	MiMapImageHeaderInHyperSpace (IN ULONG PageFrameIndex)
VOID	MiUnmapImageHeaderInHyperSpace (VOID)
PVOID	MiMapPageToZeroInHyperSpace (IN ULONG PageFrameIndex)

---

Function Documentation

PVOID MiMapImageHeaderInHyperSpace (  IN ULONG  PageFrameIndex  )

Definition at line 153 of file alpha/hypermap.c. References ASSERT, DbgPrint, Executive, FALSE, IMAGE_MAPPING_PTE, KeBugCheck(), KeEnterCriticalRegion, KeLeaveCriticalRegion, KernelMode, KeWaitForSingleObject(), LOCK_PFN, MiGetPteAddress, MiGetVirtualAddressMappedByPte, MmImageMappingPteEvent, MmWorkingSetList, NULL, _MMPTE::u, UNLOCK_PFN, UNLOCK_PFN_AND_THEN_WAIT, ValidPtePte, and _MMWSL::WaitingForImageMapping. : The physical address of the specified page is returned. Arguments: PageFrameIndex - Supplies the physical page number to map. Return Value: Returns the virtual address where the specified physical page was mapped. 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); }

PVOID MiMapPageInHyperSpace (  IN ULONG  PageFrameIndex, IN PKIRQL  OldIrql )

Definition at line 35 of file alpha/hypermap.c. References ASSERT, DbgPrint, FALSE, KeBugCheck(), KeFlushEntireTb(), KSEG0_BASE, LOCK_HYPERSPACE, MI_MAKING_MULTIPLE_PTES_INVALID, MiGetVirtualAddressMappedByPte, MM_PAGES_IN_KSEG0, MmFirstReservedMappingPte, NUMBER_OF_MAPPING_PTES, PAGE_SHIFT, TRUE, _MMPTE::u, and ValidPtePte. : This routine returns the physical address of the page. ************************************ * * * Returns with a spin lock held!!! * * * ************************************ Arguments: PageFrameIndex - Supplies the physical page number to map. Return Value: Returns the address where the requested page was mapped. RETURNS WITH THE HYPERSPACE SPIN LOCK HELD!!!! The routine MiUnmapHyperSpaceMap MUST be called to release the lock!!!! Environment: kernel mode. --*/ { PMMPTE PointerPte; MMPTE TempPte; ULONG offset; #if DBG if (PageFrameIndex == 0) { DbgPrint("attempt to map physical page 0 in hyper space\n"); KeBugCheck (MEMORY_MANAGEMENT); } #endif //DBG // // If the page is below 1GB physical, then it can be mapped via // KSEG0. // LOCK_HYPERSPACE (OldIrql); if (PageFrameIndex < MM_PAGES_IN_KSEG0) { return (PVOID)(KSEG0_BASE + (PageFrameIndex << PAGE_SHIFT)); } PointerPte = MmFirstReservedMappingPte; if (PointerPte->u.Hard.Valid == 1) { // // All the reserved PTEs have been used, make // them all invalid. // MI_MAKING_MULTIPLE_PTES_INVALID (FALSE); RtlZeroMemory (MmFirstReservedMappingPte, (NUMBER_OF_MAPPING_PTES + 1) * sizeof(MMPTE)); // // Use the page frame number field of the first PTE as an // offset into the available mapping PTEs. // PointerPte->u.Hard.PageFrameNumber = NUMBER_OF_MAPPING_PTES; // // Flush entire TB only on this processor. // KeFlushEntireTb (TRUE, FALSE); } // // Get offset to first free PTE. // offset = PointerPte->u.Hard.PageFrameNumber; // // Change offset for next time through. // PointerPte->u.Hard.PageFrameNumber = offset - 1; // // Point to free entry and make it valid. // PointerPte += offset; ASSERT (PointerPte->u.Hard.Valid == 0); TempPte = ValidPtePte; TempPte.u.Hard.PageFrameNumber = PageFrameIndex; *PointerPte = TempPte; // // Return the VA that map the page. // return MiGetVirtualAddressMappedByPte (PointerPte); }

PVOID MiMapPageToZeroInHyperSpace (  IN ULONG  PageFrameIndex  )

Definition at line 313 of file alpha/hypermap.c. References DbgPrint, FALSE, KeBugCheck(), KeFlushSingleTb(), KSEG0_BASE, MiGetPteAddress, MiGetVirtualAddressMappedByPte, MM_PAGES_IN_KSEG0, MM_PFN_LOCK_ASSERT, PAGE_SHIFT, TRUE, _MMPTE::u, ValidPtePte, and ZEROING_PAGE_PTE. 00319 : 00320 00321 This procedure maps the specified physical page into hyper space 00322 and returns the virtual address which maps the page. 00323 00324 NOTE: it maps it into the same location reserved for fork operations!! 00325 This is only to be used by the zeroing page thread. 00326 00327 00328 Arguments: 00329 00330 PageFrameIndex - Supplies the physical page number to map. 00331 00332 Return Value: 00333 00334 Returns the virtual address where the specified physical page was 00335 mapped. 00336 00337 Environment: 00338 00339 Must be holding the PFN lock. 00340 00341 --*/ 00342 00343 { 00344 MMPTE TempPte; 00345 PMMPTE PointerPte; 00346 PVOID MappedAddress; 00347 00348 #if DBG 00349 if (PageFrameIndex == 0) { 00350 DbgPrint("attempt to map physical page 0 in hyper space\n"); 00351 KeBugCheck (MEMORY_MANAGEMENT); 00352 } 00353 #endif //DBG 00354 00355 // 00356 // If the page is below 1GB physical then it can be mapped via 00357 // KSEG0. 00358 // 00359 00360 if (PageFrameIndex < MM_PAGES_IN_KSEG0) { 00361 return (PVOID)(KSEG0_BASE + (PageFrameIndex << PAGE_SHIFT)); 00362 } 00363 00364 MM_PFN_LOCK_ASSERT(); 00365 00366 PointerPte = MiGetPteAddress (ZEROING_PAGE_PTE); 00367 MappedAddress = MiGetVirtualAddressMappedByPte (PointerPte); 00368 00369 TempPte.u.Long = 0; 00370 00371 KeFlushSingleTb (MappedAddress, 00372 TRUE, 00373 FALSE, 00374 (PHARDWARE_PTE)PointerPte, TempPte.u.Hard); 00375 00376 TempPte = ValidPtePte; 00377 TempPte.u.Hard.PageFrameNumber = PageFrameIndex; 00378 00379 *PointerPte = TempPte; 00380 00381 return MappedAddress; 00382 } }

VOID MiUnmapImageHeaderInHyperSpace (  VOID   )

Definition at line 243 of file alpha/hypermap.c. : 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. On ALPHA, no action is required as the super-page address of the page was used. 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; }

---