physsect.c File Reference

#include "mi.h"

Go to the source code of this file.

Functions
ULONG	MaximumAlignment (ULONG Offset)
ULONG	AggregatePages (PMMPTE, PFN_NUMBER, ULONG, PULONG)
NTSTATUS	MiMapViewOfPhysicalSection (IN PCONTROL_AREA ControlArea, IN PEPROCESS Process, IN PVOID *CapturedBase, IN PLARGE_INTEGER SectionOffset, IN PSIZE_T CapturedViewSize, IN ULONG ProtectionMask, IN ULONG_PTR ZeroBits, IN ULONG AllocationType, IN BOOLEAN WriteCombined, OUT PBOOLEAN ReleasedWsMutex)
ULONG	MaximumAlignment (IN ULONG Offset)
ULONG	AggregatePages (IN PMMPTE PointerPte, IN PFN_NUMBER Pfn, IN ULONG Pages, OUT PULONG GranularityHint)

---

Function Documentation

ULONG AggregatePages (  IN PMMPTE  PointerPte, IN PFN_NUMBER  Pfn, IN ULONG  Pages, OUT PULONG  GranularityHint )

Definition at line 522 of file axp64/physsect.c. References DbgPrint, GH0, GH1, GH1_PAGE_SIZE, GH2, GH2_PAGE_SIZE, GH3, GH3_PAGE_SIZE, MaximumAlignment(), MiGetVirtualAddressMappedByPte, PAGE_SHIFT, and PAGE_SIZE. Referenced by MiMapViewOfPhysicalSection(). 00530 : 00531 00532 This routine computes the number of standard size pages that can be 00533 aggregated into a single large page and returns the granularity hint 00534 for that size large page. 00535 00536 Arguments: 00537 00538 PointerPte - Supplies the PTE pointer for the starting virtual address 00539 of the mapping. 00540 Pfn - Supplies the starting page frame number of the memory to be 00541 mapped. 00542 Pages - Supplies the number of pages to map. 00543 00544 GranularityHint - Receives the granularity hint for the large page used 00545 to aggregate the standard pages. 00546 00547 Return Value: 00548 00549 The number of pages that can be aggregated together. 00550 00551 Environment: 00552 00553 --*/ 00554 { 00555 00556 ULONG MaxVirtualAlignment; 00557 ULONG MaxPhysicalAlignment; 00558 ULONG MaxPageAlignment; 00559 ULONG MaxAlignment; 00560 00561 // 00562 // Determine the largest page that will map a maximum of Pages. 00563 // The largest page must be both virtually and physically aligned 00564 // to the large page size boundary. 00565 // Determine the largest common alignment for the virtual and 00566 // physical addresses, factor in Pages, and then match to the 00567 // largest page size possible via the granularity hints. 00568 // 00569 00570 MaxVirtualAlignment = 00571 MaximumAlignment((ULONG)((ULONG_PTR)MiGetVirtualAddressMappedByPte(PointerPte))); 00572 00573 MaxPhysicalAlignment = MaximumAlignment( (ULONG)(Pfn << PAGE_SHIFT) ); 00574 00575 MaxPageAlignment = (ULONG)(Pages << PAGE_SHIFT); 00576 00577 #ifdef AGGREGATE_DBG 00578 00579 DbgPrint( "MM: Aggregate MaxVirtualAlign = %x\n", MaxVirtualAlignment ); 00580 DbgPrint( "MM: Aggregate MaxPhysicalAlign = %x\n", MaxPhysicalAlignment ); 00581 DbgPrint( "MM: Aggregate MaxPageAlign = %x\n", MaxPageAlignment ); 00582 00583 #endif //AGGREGATE_DBG 00584 // 00585 // Maximum alignment is the minimum of the virtual and physical alignments. 00586 // 00587 00588 MaxAlignment = (MaxVirtualAlignment > MaxPhysicalAlignment) ? 00589 MaxPhysicalAlignment : MaxVirtualAlignment; 00590 MaxAlignment = (MaxAlignment > MaxPageAlignment) ? 00591 MaxPageAlignment : MaxAlignment; 00592 00593 // 00594 // Convert MaxAlignment to granularity hint value 00595 // 00596 00597 if( (MaxAlignment & (GH3_PAGE_SIZE - 1)) == 0 ){ 00598 00599 *GranularityHint = GH3; 00600 00601 } else if( (MaxAlignment & (GH2_PAGE_SIZE - 1)) == 0 ){ 00602 00603 *GranularityHint = GH2; 00604 00605 } else if( (MaxAlignment & (GH1_PAGE_SIZE - 1)) == 0 ){ 00606 00607 *GranularityHint = GH1; 00608 00609 } else if( (MaxAlignment & (PAGE_SIZE - 1)) == 0 ){ 00610 00611 *GranularityHint = GH0; 00612 00613 } else { 00614 00615 *GranularityHint = GH0; 00616 00617 #if DBG 00618 00619 DbgPrint( "MM: Aggregate Physical pages - not page aligned\n" ); 00620 00621 #endif //DBG 00622 00623 } // end, if then elseif 00624 00625 // 00626 // Return number of pages aggregated. 00627 // 00628 00629 return( MaxAlignment >> PAGE_SHIFT ); 00630 00631 } }

ULONG AggregatePages (  PMMPTE  , PFN_NUMBER  , ULONG  , PULONG  )  [static]

ULONG MaximumAlignment (  IN ULONG  Offset  )

Definition at line 478 of file axp64/physsect.c. References GH1_PAGE_SIZE, GH2_PAGE_SIZE, GH3_PAGE_SIZE, Offset, and PAGE_SIZE. Referenced by AggregatePages(), and MiMapViewOfPhysicalSection(). : This routine returns the maximum granularity hint alignment boundary to which Offset is naturally aligned. Arguments: Offset - Supplies the address offset to check for alignment. Return Value: The number which represents the largest natural alignment of Offset. Environment: --*/ { if( (Offset & (GH3_PAGE_SIZE - 1)) == 0 ){ return GH3_PAGE_SIZE; } if( (Offset & (GH2_PAGE_SIZE - 1)) == 0 ){ return GH2_PAGE_SIZE; } if( (Offset & (GH1_PAGE_SIZE - 1)) == 0 ){ return GH1_PAGE_SIZE; } if( (Offset & (PAGE_SIZE - 1)) == 0 ){ return PAGE_SIZE; } return 0; }

ULONG MaximumAlignment (  ULONG  Offset  )  [static]

NTSTATUS MiMapViewOfPhysicalSection (  IN PCONTROL_AREA  ControlArea, IN PEPROCESS  Process, IN PVOID *  CapturedBase, IN PLARGE_INTEGER  SectionOffset, IN PSIZE_T  CapturedViewSize, IN ULONG  ProtectionMask, IN ULONG_PTR  ZeroBits, IN ULONG  AllocationType, IN BOOLEAN  WriteCombined, OUT PBOOLEAN  ReleasedWsMutex )

Definition at line 45 of file axp64/physsect.c. References AggregatePages(), ASSERT, _MMVAD::ControlArea, DbgPrint, _MMVAD::EndingVpn, _MI_PHYSICAL_VIEW::EndVa, ExAllocatePoolWithTag, EXCEPTION_EXECUTE_HANDLER, ExFreePool(), ExRaiseStatus(), FALSE, _MMVAD::FirstPrototypePte, L, _MMVAD::LastContiguousPte, _MI_PHYSICAL_VIEW::ListEntry, LOCK_AWE, LOCK_PFN, LOCK_PFN2, LOCK_WS, MaximumAlignment(), MI_64K_ALIGN, MI_CONVERT_PHYSICAL_BUS_TO_PFN, MI_GET_USED_PTES_FROM_HANDLE, MI_GET_USED_PTES_HANDLE, MI_INCREMENT_USED_PTES_BY_HANDLE, MI_MAKE_VALID_PTE, MI_PFN_ELEMENT, MI_PHYSICAL_VIEW_KEY, MI_SET_PTE_WRITE_COMBINE, MI_VA_TO_VPN, MiCheckForConflictingVad, MiFindEmptyAddressRange(), MiGetPdeAddress, MiGetPpeAddress, MiGetPteAddress, MiGetVirtualAddressMappedByPte, MiInsertVad(), MiIsPteOnPdeBoundary, MiIsPteOnPpeBoundary, MiMakePdeExistAndMakeValid(), MiMakePpeExistAndMakeValid, NonPagedPool, NULL, PAGE_SHIFT, PAGE_SIZE, _MMVAD::StartingVpn, _MI_PHYSICAL_VIEW::StartVa, TRUE, _MMPTE::u, _MMVAD::u, _MMPFN::u2, _MMVAD::u2, _MMVAD::u4, UNLOCK_AWE, UNLOCK_PFN, UNLOCK_PFN2, UNLOCK_WS, _MI_PHYSICAL_VIEW::Vad, and X64K. : This routine maps the specified physical section into the specified process's address space. Arguments: see MmMapViewOfSection above... ControlArea - Supplies the control area for the section. Process - Supplies the process pointer which is receiving the section. ProtectionMask - Supplies the initial page protection-mask. ReleasedWsMutex - Supplies FALSE, receives TRUE if the working set mutex is released. Return Value: Status of the map view operation. Environment: Kernel Mode, working set mutex and address creation mutex held. --*/ { PMMVAD Vad; PVOID StartingAddress; PVOID EndingAddress; KIRQL OldIrql; KIRQL OldIrql2; PMMPTE PointerPpe; PMMPTE PointerPde; PMMPTE PointerPte; PMMPTE LastPte; MMPTE TempPte; PMMPFN Pfn2; SIZE_T PhysicalViewSize; ULONG Alignment; ULONG PagesToMap; PFN_NUMBER NextPfn; PVOID UsedPageTableHandle; PVOID UsedPageDirectoryHandle; PMI_PHYSICAL_VIEW PhysicalView; // // Physical memory section. // #ifdef FIRSTDBG DbgPrint( "MM: Physsect CaptureBase = %x SectionOffset = %x\n", CapturedBase, SectionOffset->LowPart ); DbgPrint( "MM: Physsect Allocation Type = %x, MEM_LARGE_PAGES = %x\n", AllocationType, MEM_LARGE_PAGES ); #endif //FIRSTDBG // // Compute the alignment we require for the virtual mapping. // The default is 64K to match protection boundaries. // Larger page sizes are used if MEM_LARGE_PAGES is requested. // The Alpha AXP architecture supports granularity hints so that // larger pages can be defined in the following multiples of // PAGE_SIZE: // 8**(GH) * PAGE_SIZE, where GH element of {0,1,2,3} // Alignment = X64K; if( AllocationType & MEM_LARGE_PAGES ){ // // MaxAlignment is the maximum boundary alignment of the // SectionOffset (where the maximum boundary is one of the possible // granularity hints boundaries) // ULONG MaxAlignment = MaximumAlignment( SectionOffset->LowPart ); Alignment = (MaxAlignment > Alignment) ? MaxAlignment : Alignment; #ifdef FIRSTDBG DbgPrint( "MM: Alignment = %x, SectionOffset = %x\n", Alignment, SectionOffset->LowPart ); #endif //FIRSTDBG } LOCK_WS (Process); if (*CapturedBase == NULL) { // // Attempt to locate address space. This could raise an // exception. // try { // // Find a starting address on an alignment boundary. // PhysicalViewSize = (SectionOffset->LowPart + *CapturedViewSize) - (ULONG_PTR)MI_64K_ALIGN(SectionOffset->LowPart); StartingAddress = MiFindEmptyAddressRange (PhysicalViewSize, Alignment, (ULONG)ZeroBits); } except (EXCEPTION_EXECUTE_HANDLER) { return GetExceptionCode(); } EndingAddress = (PVOID)(((ULONG_PTR)StartingAddress + PhysicalViewSize - 1L) | (PAGE_SIZE - 1L)); StartingAddress = (PVOID)((ULONG_PTR)StartingAddress + (SectionOffset->LowPart & (X64K - 1))); if (ZeroBits > 0) { if (EndingAddress > (PVOID)((LONG_PTR)0xFFFFFFFF >> ZeroBits)) { return STATUS_NO_MEMORY; } } } else { // // Check to make sure the specified base address to ending address // is currently unused. // PhysicalViewSize = (SectionOffset->LowPart + *CapturedViewSize) - (ULONG_PTR)MI_64K_ALIGN(SectionOffset->LowPart); StartingAddress = (PVOID)((ULONG_PTR)MI_64K_ALIGN(*CapturedBase) + (SectionOffset->LowPart & (X64K - 1))); EndingAddress = (PVOID)(((ULONG_PTR)StartingAddress + *CapturedViewSize - 1L) | (PAGE_SIZE - 1L)); Vad = MiCheckForConflictingVad (StartingAddress, EndingAddress); if (Vad != (PMMVAD)NULL) { #if 0 MiDumpConflictingVad (StartingAddress, EndingAddress, Vad); #endif return STATUS_CONFLICTING_ADDRESSES; } } // // An unoccuppied address range has been found, build the virtual // address descriptor to describe this range. // // // Establish an exception handler and attempt to allocate // the pool and charge quota. Note that the InsertVad routine // will also charge quota which could raise an exception. // try { PhysicalView = (PMI_PHYSICAL_VIEW)ExAllocatePoolWithTag (NonPagedPool, sizeof(MI_PHYSICAL_VIEW), MI_PHYSICAL_VIEW_KEY); if (PhysicalView == NULL) { ExRaiseStatus (STATUS_INSUFFICIENT_RESOURCES); } Vad = (PMMVAD)ExAllocatePoolWithTag (NonPagedPool, sizeof(MMVAD), ' daV'); if (Vad == NULL) { ExRaiseStatus (STATUS_INSUFFICIENT_RESOURCES); } PhysicalView->Vad = Vad; PhysicalView->StartVa = StartingAddress; PhysicalView->EndVa = EndingAddress; Vad->StartingVpn = MI_VA_TO_VPN (StartingAddress); Vad->EndingVpn = MI_VA_TO_VPN (EndingAddress); Vad->ControlArea = ControlArea; Vad->u.LongFlags = 0; Vad->u2.VadFlags2.Inherit = ViewUnmap; Vad->u.VadFlags.PhysicalMapping = 1; Vad->u4.Banked = NULL; // Vad->u.VadFlags.ImageMap = 0; Vad->u.VadFlags.Protection = ProtectionMask; Vad->u2.VadFlags2.CopyOnWrite = 0; // Vad->u.VadFlags.LargePages = 0; Vad->FirstPrototypePte = (PMMPTE)(MI_CONVERT_PHYSICAL_BUS_TO_PFN(*SectionOffset)); // // Set the first prototype PTE field in the Vad. // Vad->LastContiguousPte = (PMMPTE)(MI_CONVERT_PHYSICAL_BUS_TO_PFN(*SectionOffset)); // // Insert the VAD. This could get an exception. // MiInsertVad (Vad); } except (EXCEPTION_EXECUTE_HANDLER) { if (PhysicalView != NULL) { ExFreePool (PhysicalView); } if (Vad != (PMMVAD)NULL) { // // The pool allocation suceeded, but the quota charge // in InsertVad failed, deallocate the pool and return // and error. // ExFreePool (Vad); return GetExceptionCode(); } return STATUS_INSUFFICIENT_RESOURCES; } // Increment the count of the number of views for the // section object. This requires the PFN mutex to be held. // LOCK_AWE (Process, OldIrql); LOCK_PFN2 (OldIrql2); InsertHeadList (&Process->PhysicalVadList, &PhysicalView->ListEntry); ControlArea->NumberOfMappedViews += 1; ControlArea->NumberOfUserReferences += 1; ASSERT (ControlArea->NumberOfSectionReferences != 0); UNLOCK_PFN2 (OldIrql2); UNLOCK_AWE (Process, OldIrql); // // Build the PTEs in the address space. // PointerPpe = MiGetPpeAddress (StartingAddress); PointerPde = MiGetPdeAddress (StartingAddress); PointerPte = MiGetPteAddress (StartingAddress); LastPte = MiGetPteAddress (EndingAddress); #if defined (_WIN64) MiMakePpeExistAndMakeValid (PointerPpe, Process, FALSE); if (PointerPde->u.Long == 0) { UsedPageDirectoryHandle = MI_GET_USED_PTES_HANDLE (PointerPte); ASSERT (MI_GET_USED_PTES_FROM_HANDLE (UsedPageDirectoryHandle) == 0); MI_INCREMENT_USED_PTES_BY_HANDLE (UsedPageDirectoryHandle); } #endif MiMakePdeExistAndMakeValid(PointerPde, Process, FALSE); Pfn2 = MI_PFN_ELEMENT(PointerPde->u.Hard.PageFrameNumber); PagesToMap = (ULONG)((((ULONG_PTR)EndingAddress - (ULONG_PTR)StartingAddress)) + (PAGE_SIZE-1) ) >> PAGE_SHIFT; NextPfn = MI_CONVERT_PHYSICAL_BUS_TO_PFN(*SectionOffset); #ifdef FIRSTDBG DbgPrint( "MM: Physsect, PagesToMap = %x NextPfn = %x\n", PagesToMap, NextPfn ); #endif //FIRSTDBG MI_MAKE_VALID_PTE (TempPte, NextPfn, ProtectionMask, PointerPte); if (WriteCombined == TRUE) { MI_SET_PTE_WRITE_COMBINE (TempPte); } if (TempPte.u.Hard.Write) { TempPte.u.Hard.FaultOnWrite = 1; } while (PointerPte <= LastPte) { ULONG PagesTogether; ULONG GranularityHint; // // Compute the number of pages that can be mapped together // if( AllocationType & MEM_LARGE_PAGES ){ PagesTogether = AggregatePages( PointerPte, NextPfn, PagesToMap, &GranularityHint ); } else { PagesTogether = 1; GranularityHint = 0; } #ifdef FIRSTDBG DbgPrint( "MM: Physsect PointerPte = %x, NextPfn = %x\n", PointerPte, NextPfn ); DbgPrint( "MM: Va = %x TempPte.Pfn = %x\n", MiGetVirtualAddressMappedByPte( PointerPte ), TempPte.u.Hard.PageFrameNumber ); DbgPrint( "MM: PagesToMap = %x\n", PagesToMap ); DbgPrint( "MM: PagesTogether = %x, GH = %x\n", PagesTogether, GranularityHint ); #endif //FIRSTDBG TempPte.u.Hard.GranularityHint = GranularityHint; NextPfn += PagesTogether; PagesToMap -= PagesTogether; UsedPageTableHandle = MI_GET_USED_PTES_HANDLE (MiGetVirtualAddressMappedByPte (PointerPte)); while( PagesTogether-- ){ if (MiIsPteOnPdeBoundary (PointerPte)) { PointerPde = MiGetPteAddress (PointerPte); if (MiIsPteOnPpeBoundary (PointerPte)) { PointerPpe = MiGetPteAddress (PointerPde); MiMakePpeExistAndMakeValid (PointerPpe, Process, FALSE); if (PointerPde->u.Long == 0) { UsedPageDirectoryHandle = MI_GET_USED_PTES_HANDLE (PointerPte); ASSERT (MI_GET_USED_PTES_FROM_HANDLE (UsedPageDirectoryHandle) == 0); MI_INCREMENT_USED_PTES_BY_HANDLE (UsedPageDirectoryHandle); } } MiMakePdeExistAndMakeValid (PointerPde, Process, FALSE); Pfn2 = MI_PFN_ELEMENT (PointerPde->u.Hard.PageFrameNumber); UsedPageTableHandle = MI_GET_USED_PTES_HANDLE (MiGetVirtualAddressMappedByPte (PointerPte)); } ASSERT( PointerPte->u.Long == 0 ); *PointerPte = TempPte; #if PFN_CONSISTENCY LOCK_PFN (OldIrql); #endif Pfn2->u2.ShareCount += 1; #if PFN_CONSISTENCY UNLOCK_PFN (OldIrql); #endif // // Increment the count of non-zero page table entries for this // page table and the number of private pages for the process. // MI_INCREMENT_USED_PTES_BY_HANDLE (UsedPageTableHandle); PointerPte += 1; TempPte.u.Hard.PageFrameNumber += 1; } // while (PagesTogether-- ) } // while (PointerPte <= LastPte) UNLOCK_WS (Process); *ReleasedWsMutex = TRUE; // // Update the current virtual size in the process header. // *CapturedViewSize = (ULONG)((ULONG_PTR)EndingAddress - (ULONG_PTR)StartingAddress + 1L); Process->VirtualSize += *CapturedViewSize; if (Process->VirtualSize > Process->PeakVirtualSize) { Process->PeakVirtualSize = Process->VirtualSize; } // // Translate the virtual address to a quasi-virtual address for // use by drivers that touch mapped devices. Note: the routine // HalCreateQva will not translate the StartingAddress if the // StartingAddress is within system memory address space. // // N.B. - It will not work to attempt map addresses that begin in // system memory and extend through i/o space. // *CapturedBase = HalCreateQva( *SectionOffset, StartingAddress ); return STATUS_SUCCESS; }

---