MCL/sf/os/kernelhwsrv: comparison kernel/eka/memmodel/epoc/flexible/mmu/mmu.cpp

equal deleted inserted replaced

-:538db54a451d
+:5d2844f35677
 //	TRACE(("%O mapping=0x%08x",TheCurrentThread,mapping));
 	TInt r = KErrNotFound;
 	if(mapping)
 		{
-		// Pinning mappings should not be found from within an address space.
-		__NK_ASSERT_DEBUG(!mapping->IsPinned());
 		MmuLock::Lock();
 		// check if we need to process page fault...
 		if(!Mmu::CheckPteTypePermissions(mapping->PteType(),aAccessPermissions) ||
 			mapInstanceCount != mapping->MapInstanceCount())
 			MmuLock::Unlock();
 			r = KErrAbort;
 			}
 		else
 			{
+			// Should not be able to take a fault on a pinned mapping if accessing it
+			// with the correct permissions.
+			__NK_ASSERT_DEBUG(!mapping->IsPinned());
 			// we do need to handle fault so is this a demand paging or page moving fault
 			DMemoryObject* memory = mapping->Memory();
 			if(!memory)
 				MmuLock::Unlock();
 			else
 	return aPinObject != NULL ? KErrNone : KErrNoMemory;
 	}
 TInt M::PinVirtualMemory(TVirtualPinObject* aPinObject, TLinAddr aStart, TUint aSize, DThread* aThread)
 	{
-	NKern::ThreadEnterCS();
+	__ASSERT_CRITICAL;
 	TUint offsetInMapping;
 	TUint mapInstanceCount;
 	DMemoryMapping* mapping = MM::FindMappingInThread(	(DMemModelThread*)aThread,
 														aStart,
 														aSize,
 															mapping, mapInstanceCount);
 				memory->Close();
 				}
 			}
 		mapping->Close();
 		}
-	NKern::ThreadLeaveCS();
 	return r;
 	}
 TInt M::CreateAndPinVirtualMemory(TVirtualPinObject*& aPinObject, TLinAddr aStart, TUint aSize)
 	{
+	__ASSERT_CRITICAL;
 	aPinObject = 0;
-	NKern::ThreadEnterCS();
 	TUint offsetInMapping;
 	TUint mapInstanceCount;
 	DMemoryMapping* mapping = MM::FindMappingInThread(	(DMemModelThread*)&Kern::CurrentThread(),
 														aStart,
 														aSize,
 					}
 				memory->Close();
 				}
 			}
 		mapping->Close();
 		}
-	NKern::ThreadLeaveCS();
 	return r;
 	}
 void M::UnpinVirtualMemory(TVirtualPinObject* aPinObject)
 	{
 			mapping->Unpin();
 		mapping->AsyncClose();
 		}
 	}
+//
+// Physical pinning
+//
 TInt M::CreatePhysicalPinObject(TPhysicalPinObject*& aPinObject)
 	{
 	aPinObject = (TPhysicalPinObject*)new DPhysicalPinMapping;
 	return aPinObject != NULL ? KErrNone : KErrNoMemory;
 	}
-//
-// Physical pinning
-//
 TInt M::PinPhysicalMemory(TPhysicalPinObject* aPinObject, TLinAddr aStart, TUint aSize, TBool aReadOnly,
 				TPhysAddr& aAddress, TPhysAddr* aPages, TUint32& aMapAttr, TUint& aColour, DThread* aThread)
 	{
-	NKern::ThreadEnterCS();
+	__ASSERT_CRITICAL;
 	TUint offsetInMapping;
 	TUint mapInstanceCount;
 	DMemoryMapping* mapping = MM::FindMappingInThread(	(DMemModelThread*)aThread,
 														aStart,
 														aSize,
 			{
 			MmuLock::Unlock();
 			}
 		mapping->Close();
 		}
-	NKern::ThreadLeaveCS();
 	aColour = (aStart >>KPageShift) & KPageColourMask;
 	return r;
 	}
 void M::UnpinPhysicalMemory(TPhysicalPinObject* aPinObject)
 			mapping->Unpin();
 		mapping->AsyncClose();
 		}
 	}
+//
+// Kernel map and pin.
+//
+TInt M::CreateKernelMapObject(TKernelMapObject*& aMapObject, TUint aMaxReserveSize)
+	{
+	DKernelPinMapping*  pinObject = new DKernelPinMapping();
+	aMapObject = (TKernelMapObject*) pinObject;
+	if (pinObject == NULL)
+		{
+		return KErrNoMemory;
+		}
+	// Ensure we reserve enough bytes for all possible alignments of the start and
+	// end of the region to map.
+	TUint reserveBytes = aMaxReserveSize? ((aMaxReserveSize + KPageMask) & ~KPageMask) + KPageSize : 0;
+	TInt r = pinObject->Construct(reserveBytes);
+	if (r != KErrNone)
+		{// Failed so delete the kernel mapping object.
+		pinObject->Close();
+		aMapObject = NULL;
+		}
+	return r;
+	}
+TInt M::MapAndPinMemory(TKernelMapObject* aMapObject, DThread* aThread, TLinAddr aStart,
+						TUint aSize, TUint aMapAttributes, TLinAddr& aKernelAddr, TPhysAddr* aPages)
+	{
+	__ASSERT_CRITICAL;
+	TUint offsetInMapping;
+	TUint mapInstanceCount;
+	DMemoryMapping* mapping = MM::FindMappingInThread(	(DMemModelThread*)aThread,
+														aStart,
+														aSize,
+														offsetInMapping,
+														mapInstanceCount);
+	TInt r = KErrBadDescriptor;
+	if (mapping)
+		{
+		DKernelPinMapping* kernelMap = (DKernelPinMapping*)aMapObject;
+		TInt count = (((aStart + aSize + KPageMask) & ~KPageMask) - (aStart & ~KPageMask)) >> KPageShift;
+		if (kernelMap->iReservePages && kernelMap->iReservePages < count)
+			{
+			mapping->Close();
+			return KErrArgument;
+			}
+		MmuLock::Lock();
+		DMemoryObject* memory = mapping->Memory();
+		if (mapInstanceCount == mapping->MapInstanceCount() && memory)
+			{
+			memory->Open();
+			MmuLock::Unlock();
+			TUint startInMemory = (offsetInMapping >> KPageShift) + mapping->iStartIndex;
+			TBool readOnly = aMapAttributes & Kern::EKernelMap_ReadOnly;
+			TMappingPermissions permissions =  readOnly ? ESupervisorReadOnly : ESupervisorReadWrite;
+			r = kernelMap->MapAndPin(memory, startInMemory, count, permissions);
+			if (r == KErrNone)
+				{
+				__NK_ASSERT_DEBUG(!kernelMap->IsUserMapping());
+				aKernelAddr = kernelMap->Base();
+				TPhysAddr contigAddr;	// Ignore this value as aPages will be populated
+										// whether the memory is contiguous or not.
+				r = kernelMap->PhysAddr(0, count, contigAddr, aPages);
+				if (r>=KErrNone)
+					{
+					r = KErrNone; //Do not report discontiguous memory in return value.
+					}
+				else
+					{
+					UnmapAndUnpinMemory((TKernelMapObject*)kernelMap);
+					}
+				}
+			memory->Close();
+			}
+		else // mapping has been reused or no memory...
+			{
+			MmuLock::Unlock();
+			}
+		mapping->Close();
+		}
+	return r;
+	}
+void M::UnmapAndUnpinMemory(TKernelMapObject* aMapObject)
+	{
+	DKernelPinMapping* mapping = (DKernelPinMapping*)aMapObject;
+	if (mapping->IsAttached())
+		mapping->UnmapAndUnpin();
+	}
+void M::DestroyKernelMapObject(TKernelMapObject*& aMapObject)
+	{
+	DKernelPinMapping* mapping = (DKernelPinMapping*)__e32_atomic_swp_ord_ptr(&aMapObject, 0);
+	if (mapping)
+		{
+		if (mapping->IsAttached())
+			mapping->UnmapAndUnpin();
+		mapping->AsyncClose();
+		}
+	}
 //
 // Cache sync operations
 //

changeset 14	5d2844f35677
parent 8	538db54a451d
child 20	597aaf25e343