physsect.c File Reference

#include "mi.h"

Go to the source code of this file.

Functions
ULONG	MaximumAlignment (ULONG)
ULONG	AggregatePages (PMMPTE, ULONG, 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 ULONG Pfn, IN ULONG Pages, OUT PULONG GranularityHint)

---

Function Documentation

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

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

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

ULONG MaximumAlignment (  IN ULONG  Offset  )

Definition at line 472 of file alpha/physsect.c. References GH1_PAGE_SIZE, GH2_PAGE_SIZE, GH3_PAGE_SIZE, Offset, and PAGE_SIZE. : 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   )  [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 43 of file alpha/physsect.c. : 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; ULONG PhysicalViewSize; ULONG Alignment; ULONG PagesToMap; ULONG 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_UNSAFE (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)MI_64K_ALIGN(SectionOffset->LowPart); StartingAddress = MiFindEmptyAddressRange (PhysicalViewSize, Alignment, (ULONG)ZeroBits); } except (EXCEPTION_EXECUTE_HANDLER) { return GetExceptionCode(); } EndingAddress = (PVOID)(((ULONG)StartingAddress + PhysicalViewSize - 1L) | (PAGE_SIZE - 1L)); StartingAddress = (PVOID)((ULONG)StartingAddress + (SectionOffset->LowPart & (X64K - 1))); if (ZeroBits > 0) { if (EndingAddress > (PVOID)((ULONG)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)MI_64K_ALIGN(SectionOffset->LowPart); StartingAddress = (PVOID)((ULONG)MI_64K_ALIGN(*CapturedBase) + (SectionOffset->LowPart & (X64K - 1))); EndingAddress = (PVOID)(((ULONG)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 // an 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)EndingAddress - (ULONG)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.Dirty = 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_UNSAFE (Process); *ReleasedWsMutex = TRUE; // // Update the current virtual size in the process header. // *CapturedViewSize = (ULONG)EndingAddress - (ULONG)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; }

---