Can't get the kernel start-up code to work using VC8 compiler. It crashes while trying to run constructStatics. Maybe I will try my luck with GCC from MinGW, that should also make the Linux port much easier.
// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// e32\memmodel\epoc\moving\mprocess.cpp
//
//
#include "memmodel.h"
#include "cache_maintenance.h"
#include "mmboot.h"
#define iMState iWaitLink.iSpare1
_LIT(KDollarDat,"$DAT");
_LIT(KLitDllDollarData,"DLL$DATA");
/********************************************
* Process
********************************************/
void DMemModelProcess::Destruct()
{
NKern::LockSystem();
if (this==TheCurrentAddressSpace)
TheCurrentAddressSpace=NULL;
if (this==TheCurrentVMProcess)
TheCurrentVMProcess=NULL;
if (this==TheCurrentDataSectionProcess)
TheCurrentDataSectionProcess=NULL;
if (this==TheCompleteDataSectionProcess)
TheCompleteDataSectionProcess=NULL;
NKern::UnlockSystem();
DProcess::Destruct();
}
TInt DMemModelProcess::NewChunk(DChunk*& aChunk, SChunkCreateInfo& aInfo, TLinAddr& aRunAddr)
{
aChunk=NULL;
DMemModelChunk* pC=NULL;
TInt r=GetNewChunk(pC,aInfo);
if (r!=KErrNone)
{
if (pC)
pC->Close(NULL);
return r;
}
if (aInfo.iForceFixed || iAttributes & DMemModelProcess::EFixedAddress)
pC->iAttributes |= DMemModelChunk::EFixedAddress;
if (!aInfo.iGlobal && (iAttributes & DMemModelProcess::EPrivate)!=0)
pC->iAttributes |= DMemModelChunk::EPrivate;
if (pC->iChunkType==EDll || pC->iChunkType==EUserCode || pC->iChunkType==EUserSelfModCode || pC->iChunkType==EKernelCode)
pC->iAttributes |= (DMemModelChunk::EFixedAddress|DMemModelChunk::ECode);
pC->iOwningProcess=(aInfo.iGlobal)?NULL:this;
r=pC->Create(aInfo);
if (r==KErrNone && (aInfo.iOperations & SChunkCreateInfo::EAdjust))
{
if (aInfo.iRunAddress!=0)
pC->SetFixedAddress(aInfo.iRunAddress,aInfo.iPreallocated);
if (aInfo.iPreallocated==0)
{
if (pC->iAttributes & DChunk::EDisconnected)
{
r=pC->Commit(aInfo.iInitialBottom,aInfo.iInitialTop-aInfo.iInitialBottom);
}
else if (pC->iAttributes & DChunk::EDoubleEnded)
{
r=pC->AdjustDoubleEnded(aInfo.iInitialBottom,aInfo.iInitialTop);
}
else
{
r=pC->Adjust(aInfo.iInitialTop);
}
}
if (r==KErrNone && pC->iHomeRegionBase==0 && (pC->iAttributes&DMemModelChunk::EFixedAddress)!=0)
{
r=pC->Reserve(0);
aRunAddr=(TLinAddr)pC->Base();
}
}
if (r==KErrNone && (aInfo.iOperations & SChunkCreateInfo::EAdd))
{
if (pC->iAttributes & DMemModelChunk::ECode)
Mmu::Get().SyncCodeMappings();
if (pC->iChunkType!=EUserCode)
{
r=WaitProcessLock();
if (r==KErrNone)
{
r=AddChunk(pC,aRunAddr,EFalse);
SignalProcessLock();
}
}
else
aRunAddr=(TLinAddr)pC->Base(); // code chunks always fixed address
}
if (r==KErrNone)
{
pC->iDestroyedDfc = aInfo.iDestroyedDfc;
aChunk=(DChunk*)pC;
}
else
pC->Close(NULL); // NULL since chunk can't have been added to process
return r;
}
TInt DMemModelProcess::DoCreate(TBool aKernelProcess, TProcessCreateInfo& aInfo)
{
__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::DoCreate %O",this));
if (aKernelProcess)
iAttributes=ESupervisor|EFixedAddress|EPrivate;
else if (aInfo.iAttr & ECodeSegAttFixed)
iAttributes=EFixedAddress|EPrivate;
else
iAttributes=0;
if ((iAttributes & ESupervisor)==0 && (iAttributes & EFixedAddress)!=0)
{
CheckForFixedAccess();
}
return KErrNone;
}
TInt DMemModelProcess::CreateDataBssStackArea(TProcessCreateInfo& aInfo)
{
__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::CreateDataBssStackArea %O",this));
TInt dataBssSize=Mmu::RoundToPageSize(aInfo.iTotalDataSize);
TInt maxSize=dataBssSize+PP::MaxStackSpacePerProcess;
TBool fixed=(iAttributes & EFixedAddress);
__KTRACE_OPT(KPROC,Kern::Printf("DataBssSize=%x, chunk max size %x",dataBssSize,maxSize));
SChunkCreateInfo cinfo;
cinfo.iGlobal=EFalse;
cinfo.iAtt=TChunkCreate::EDisconnected;
cinfo.iForceFixed=EFalse;
cinfo.iOperations=SChunkCreateInfo::EAdjust|SChunkCreateInfo::EAdd;
cinfo.iType=EUserData;
cinfo.iMaxSize=maxSize;
cinfo.iInitialBottom=0;
cinfo.iInitialTop=dataBssSize;
cinfo.iPreallocated=0;
cinfo.iName.Set(KDollarDat);
cinfo.iOwner=this;
if (fixed && dataBssSize!=0 && aInfo.iCodeLoadAddress)
{
const TRomImageHeader& rih=*(const TRomImageHeader*)aInfo.iCodeLoadAddress;
cinfo.iRunAddress=rih.iDataBssLinearBase;
}
else
cinfo.iRunAddress=0;
TInt r=NewChunk((DChunk*&)iDataBssStackChunk,cinfo,iDataBssRunAddress);
return r;
}
TInt DMemModelProcess::AddChunk(DChunk* aChunk,TBool isReadOnly)
{
DMemModelChunk* pC=(DMemModelChunk*)aChunk;
TInt r=WaitProcessLock();
if (r==KErrNone)
{
TInt pos=0;
r=ChunkIndex(pC,pos);
TLinAddr dataSectionBase=0;
if (r==0) // Found the chunk in this process, just up its count
{
iChunks[pos].iAccessCount++;
__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::AddChunk %08x to %08x (Access count incremented to %d)",aChunk,this,iChunks[pos].iAccessCount));
SignalProcessLock();
return KErrNone;
}
r=AddChunk(pC,dataSectionBase,isReadOnly);
SignalProcessLock();
}
__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::AddChunk returns %d",r));
return r;
}
void FlushBeforeChunkMove(DMemModelChunk* aChunk)
{
Mmu& m = Mmu::Get();
TUint32 ff=Mmu::EFlushDMove|Mmu::EFlushDPermChg;
if (aChunk->iAttributes & DMemModelChunk::ECode) // assumption here that code chunks don't move
ff |= Mmu::EFlushIPermChg;
m.GenericFlush(ff);
}
TInt DMemModelProcess::AddChunk(DMemModelChunk* aChunk, TLinAddr& aDataSectionBase, TBool isReadOnly)
{
//
// Must hold the process $LOCK mutex before calling this
//
__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::AddChunk %08x to %08x (for first time)",aChunk,this));
TInt r=AllocateDataSectionBase(*((DMemModelChunk*)aChunk),(TUint&)aDataSectionBase);
if(r!=KErrNone)
return r;
if (iNumChunks==KMaxChunksInProcess)
return KErrOverflow; // too many chunks in the process
SChunkInfo *pC=iChunks;
SChunkInfo *pE=pC+iNumChunks-1;
NKern::LockSystem();
while(pE>=pC && TUint(pE->iDataSectionBase)>TUint(aDataSectionBase))
{
pE[1]=pE[0];
pE--;
}
pC=pE+1;
pC->iDataSectionBase=aDataSectionBase;
pC->isReadOnly=isReadOnly;
pC->iAccessCount=1;
pC->iChunk=aChunk;
iNumChunks++;
if(!(iAttributes&ESupervisor))
{
TInt attribs=aChunk->iAttributes;
if (!(attribs&DMemModelChunk::EFixedAddress))
{
iNumMovingChunks++;
iAttributes |= EMoving;
}
if (attribs&DMemModelChunk::EFixedAccess)
{
NKern::UnlockSystem();
AddFixedAccessChunk(aChunk);
goto done; // FINISHED
}
iAttributes |= EVariableAccess;
if (attribs & DMemModelChunk::ECode)
{
iNumNonFixedAccessCodeChunks++;
iAttributes |= EVariableCode;
}
if (++iNumNonFixedAccessChunks==1)
{
NKern::UnlockSystem();
DoAttributeChange(); // change process from fixed to variable access
NKern::LockSystem();
}
if (this!=TheCurrentThread->iOwningProcess)
{
// Adding chunk to another process
if (this==TheCurrentDataSectionProcess && !(attribs&DMemModelChunk::EFixedAddress))
TheCompleteDataSectionProcess=NULL; // just set partial state change flag and leave chunk alone
if (this==TheCurrentAddressSpace)
TheCurrentAddressSpace=NULL;
NKern::UnlockSystem();
goto done; // FINISHED
}
// Adding chunk to currently active user process
{
TheCurrentAddressSpace=NULL;
Mmu& m = Mmu::Get();
TUint32 ff=0; // flush flags
DMemModelChunk::TChunkState state=isReadOnly?DMemModelChunk::ERunningRO:DMemModelChunk::ERunningRW;
if (attribs&DMemModelChunk::EFixedAddress)
{
// Fixed address chunk, just change permissions
ff|=aChunk->ApplyTopLevelPermissions(state);
}
else if (this==TheCurrentDataSectionProcess)
{
// Moving chunk.
// This process is already in the data section, so just move the chunk down.
// Must do flushing first
TheCompleteDataSectionProcess=NULL;
FlushBeforeChunkMove(aChunk);
aChunk->MoveToRunAddress(aDataSectionBase,state); // idempotent
TheCompleteDataSectionProcess=this;
}
else if (iNumMovingChunks==1)
{
// The first moving chunk being added to a process with the data section occupied by another process.
// This is the problematic case - we must displace the other process from the data section.
// However we must allow preemption after each chunk is moved. Note that if a reschedule does
// occur the necessary chunk moves will have been done by the scheduler, so we can finish
// immediately.
// Must do cache flushing first
m.GenericFlush(Mmu::EFlushDMove);
if (TheCurrentDataSectionProcess)
{
if (TheCurrentDataSectionProcess->iAttributes & EVariableCode)
ff |= Mmu::EFlushIPermChg;
SChunkInfo* pOtherProcChunks=TheCurrentDataSectionProcess->iChunks;
SChunkInfo* pEndOtherProcChunks=pOtherProcChunks+TheCurrentDataSectionProcess->iNumChunks;
NKern::FlashSystem();
// if a reschedule occurs, TheCompleteDataSectionProcess will become equal to this
while (TheCompleteDataSectionProcess!=this && pOtherProcChunks<pEndOtherProcChunks)
{
DMemModelChunk *pChunk=pOtherProcChunks->iChunk;
pChunk->MoveToHomeSection();
++pOtherProcChunks;
TheCompleteDataSectionProcess=NULL;
NKern::FlashSystem();
}
}
if (TheCompleteDataSectionProcess!=this)
{
if (attribs & DMemModelChunk::ECode)
ff |= Mmu::EFlushIPermChg;
aChunk->MoveToRunAddress(aDataSectionBase,state);
TheCurrentDataSectionProcess=this;
TheCompleteDataSectionProcess=this;
}
}
TheCurrentAddressSpace=this;
TheCurrentVMProcess=this;
if (ff)
m.GenericFlush(ff);
}
}
NKern::UnlockSystem();
done:
__KTRACE_OPT(KPROC,Kern::Printf("Added array entry for %x",aDataSectionBase));
__KTRACE_OPT(KPROC,Kern::Printf("Chunks maxsize %x",pC->iChunk->MaxSize()));
__DEBUG_EVENT(EEventUpdateProcess, this);
return KErrNone;
}
TInt DMemModelProcess::AllocateDataSectionBase(DMemModelChunk& aChunk, TUint& aBase)
{
__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::AllocateDataSectionBase"));
aBase=0;
if ((aChunk.iAttributes & DMemModelChunk::EPrivate) && this!=aChunk.iOwningProcess)
return KErrAccessDenied;
if (aChunk.iAttributes & DMemModelChunk::EFixedAddress)
{
aBase=aChunk.iHomeRegionBase;
return KErrNone;
}
Mmu& m = Mmu::Get();
TLinAddr base=0;
TLinAddr maxBase=0;
switch (aChunk.iChunkType)
{
case EUserData:
base=m.iDataSectionBase;
maxBase=m.iDllDataBase;
break;
case EUserCode:
case EUserSelfModCode:
MM::Panic(MM::EUserCodeNotFixed);
break;
case EDllData:
aBase=m.iDllDataBase;
return KErrNone;
default:
__KTRACE_OPT(KPANIC,Kern::Printf("DMemModelProcess::AllocateDataSectionBase BadChunkType %d",aChunk.iChunkType));
return KErrAccessDenied;
}
TLinAddr lastBase=base;
SChunkInfo *pS=iChunks;
SChunkInfo *pE=pS+iNumChunks;
while (pS<pE)
{
TLinAddr thisBase=pS->iDataSectionBase;
__KTRACE_OPT(KPROC,Kern::Printf("Chunk already at %x",thisBase));
if (thisBase>=maxBase)
break;
if (thisBase>=base) // Within the range we are allocating
{
TInt gap=thisBase-lastBase;
if (gap>=aChunk.MaxSize())
break;
lastBase=thisBase+pS->iChunk->MaxSize();
}
pS++;
}
if (lastBase+aChunk.MaxSize()>maxBase)
{
__KTRACE_OPT(KPROC,Kern::Printf("ERROR - none allocated, out of memory"));
return KErrNoMemory;
}
aBase=lastBase;
__KTRACE_OPT(KPROC,Kern::Printf("User allocated %x",aBase));
return KErrNone;
}
TUint8* DMemModelProcess::DataSectionBase(DMemModelChunk* aChunk)
{
// this can't be called after $LOCK is deleted
Kern::MutexWait(*iProcessLock);
TInt pos=0;
TInt r=ChunkIndex(aChunk,pos);
if (r==0) // Found the chunk
{
TUint8* answer=((TUint8*)iChunks[pos].iDataSectionBase);
__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::DataSectionBase %x",answer));
Kern::MutexSignal(*iProcessLock);
return answer;
}
__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::DataSectionBase chunk %08x not present in %08x",aChunk,this));
Kern::MutexSignal(*iProcessLock);
return(NULL);
}
void DMemModelProcess::DoRemoveChunk(TInt aIndex)
{
// Must be called with process $LOCK mutex held
__DEBUG_EVENT(EEventUpdateProcess, this);
DMemModelChunk* chunk = iChunks[aIndex].iChunk;
Mmu& m = Mmu::Get();
NKern::LockSystem();
TInt attribs=chunk->iAttributes;
__KTRACE_OPT(KPROC,Kern::Printf("Removing Chunk attribs=%08x, Process attribs=%08x",attribs,iAttributes));
if (!(attribs&DMemModelChunk::EFixedAccess))
{
// Must leave chunk in process chunk list until we have flushed the cache if necessary
if (this==TheCurrentVMProcess && (attribs&DMemModelChunk::EFixedAddress))
{
TUint32 ff=chunk->ApplyTopLevelPermissions(DMemModelChunk::ENotRunning);
m.GenericFlush(ff);
// the system must now remain locked until the chunk is removed from the process chunk list
}
if (this==TheCurrentDataSectionProcess && !(attribs&DMemModelChunk::EFixedAddress))
{
// must do cache flush first
FlushBeforeChunkMove(chunk); // preemptible, but on return cache is free of chunk data
chunk->MoveToHomeSection();
// the system must now remain locked until the chunk is removed from the process chunk list
}
}
// Remove the chunk from the process chunk list
SChunkInfo *pD=iChunks+aIndex;
SChunkInfo *pS=iChunks+aIndex+1;
SChunkInfo *pE=iChunks+iNumChunks;
while(pS<pE)
*pD++=*pS++;
iNumChunks--;
// Update the process attribute flags
if (!(attribs&DMemModelChunk::EFixedAddress))
{
if (--iNumMovingChunks==0)
iAttributes &= ~EMoving;
}
if (!(attribs&DMemModelChunk::EFixedAccess))
{
if ((attribs&DMemModelChunk::ECode) && --iNumNonFixedAccessCodeChunks==0)
iAttributes &= ~EVariableCode;
if (this==TheCurrentDataSectionProcess && !(iAttributes&EMoving))
{
TheCurrentDataSectionProcess=NULL;
TheCompleteDataSectionProcess=NULL;
}
if (--iNumNonFixedAccessChunks==0)
{
iAttributes &= ~EVariableAccess;
if (this==TheCurrentVMProcess)
{
TheCurrentVMProcess=NULL;
TheCurrentAddressSpace=NULL;
}
NKern::UnlockSystem();
DoAttributeChange(); // change process from variable to fixed access
}
else
NKern::UnlockSystem();
}
else
{
NKern::UnlockSystem();
RemoveFixedAccessChunk(chunk);
}
}
/**
Final chance for process to release resources during its death.
Called with process $LOCK mutex held (if it exists).
This mutex will not be released before it is deleted.
I.e. no other thread will ever hold the mutex again.
*/
void DMemModelProcess::FinalRelease()
{
// Clean up any left over chunks (such as SharedIo buffers)
while(iNumChunks)
DoRemoveChunk(0);
}
void DMemModelProcess::RemoveChunk(DMemModelChunk *aChunk)
{
// note that this can't be called after the process $LOCK mutex has been deleted
// since it can only be called by a thread in this process doing a handle close or
// dying, or by the process handles array being deleted due to the process dying,
// all of which happen before $LOCK is deleted.
__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::RemoveChunk %08x from %08x",aChunk,this));
Kern::MutexWait(*iProcessLock);
TInt pos=0;
TInt r=ChunkIndex(aChunk,pos);
__KTRACE_OPT(KPROC,if(r) Kern::Printf("Chunk lookup failed with %d",r));
if (r==0) // Found the chunk
{
__KTRACE_OPT(KPROC,Kern::Printf("Chunk access count %d",iChunks[pos].iAccessCount));
if (--iChunks[pos].iAccessCount==0)
DoRemoveChunk(pos);
}
Kern::MutexSignal(*iProcessLock);
}
TInt DMemModelProcess::ChunkIndex(DMemModelChunk* aChunk,TInt& aPos)
{
if (aChunk==NULL)
return(KErrNotFound);
TInt i=0;
SChunkInfo *pC=iChunks;
SChunkInfo *pE=pC+iNumChunks;
while(pC<pE && (pC->iChunk!=aChunk))
{
pC++;
i++;
}
if (pC==pE)
return KErrNotFound;
aPos=i;
return KErrNone;
}
void DMemModelProcess::RemoveDllData()
//
// Call with CodeSegLock held
//
{
Kern::SafeClose((DObject*&)iDllDataChunk, this);
}
TInt DMemModelProcess::CreateDllDataChunk()
//
// Call with CodeSegLock held
//
{
__KTRACE_OPT(KDLL,Kern::Printf("DMemModelProcess %O CreateDllDataChunk",this));
Mmu& m = Mmu::Get();
SChunkCreateInfo c;
c.iGlobal=EFalse;
c.iAtt=TChunkCreate::EDisconnected;
c.iForceFixed=EFalse;
c.iOperations=SChunkCreateInfo::EAdjust|SChunkCreateInfo::EAdd;
c.iRunAddress=0;
c.iPreallocated=0;
c.iType=EDllData;
c.iMaxSize=(iAttributes&EFixedAddress) ? 1 : m.iMaxDllDataSize; // minimal size for fixed processes
c.iName.Set(KLitDllDollarData);
c.iOwner=this;
c.iInitialBottom=0;
c.iInitialTop=0;
TLinAddr runAddr;
return NewChunk((DChunk*&)iDllDataChunk,c,runAddr);
}
void DMemModelProcess::FreeDllDataChunk()
{
iDllDataChunk->Close(this);
iDllDataChunk=NULL;
}
TInt DMemModelProcess::CommitDllData(TLinAddr aBase, TInt aSize)
{
__KTRACE_OPT(KDLL,Kern::Printf("DMemModelProcess %O CommitDllData %08x+%x",this,aBase,aSize));
TInt r=KErrNone;
if (!iDllDataChunk)
r=CreateDllDataChunk();
if (r==KErrNone)
{
Mmu& m = Mmu::Get();
TLinAddr dll_data_base=(iAttributes & EFixedAddress) ? (TLinAddr)iDllDataChunk->Base()
: TLinAddr(m.iDllDataBase);
TInt offset=aBase-dll_data_base;
__ASSERT_ALWAYS(TUint32(offset)<TUint32(iDllDataChunk->iMaxSize),MM::Panic(MM::ECommitInvalidDllDataAddress));
r=iDllDataChunk->Commit(offset, aSize);
if (r!=KErrNone && iDllDataChunk->iSize==0)
FreeDllDataChunk();
}
__KTRACE_OPT(KDLL,Kern::Printf("CommitDllData returns %d",r));
return r;
}
void DMemModelProcess::DecommitDllData(TLinAddr aBase, TInt aSize)
{
__KTRACE_OPT(KDLL,Kern::Printf("DMemModelProcess %O DecommitDllData %08x+%x",this,aBase,aSize));
Mmu& m = Mmu::Get();
TLinAddr dll_data_base=(iAttributes & EFixedAddress) ? (TLinAddr)iDllDataChunk->Base()
: TLinAddr(m.iDllDataBase);
TInt offset=aBase-dll_data_base;
TInt r=iDllDataChunk->Decommit(offset, aSize);
__ASSERT_ALWAYS(r==KErrNone,MM::Panic(MM::EDecommitInvalidDllDataAddress));
if (iDllDataChunk->iSize==0)
FreeDllDataChunk();
}
TInt DMemModelProcess::MapCodeSeg(DCodeSeg* aSeg)
{
DMemModelCodeSeg& seg=*(DMemModelCodeSeg*)aSeg;
__KTRACE_OPT(KDLL,Kern::Printf("Process %O MapCodeSeg %C", this, aSeg));
TBool kernel_only=( (seg.iAttr&(ECodeSegAttKernel|ECodeSegAttGlobal)) == ECodeSegAttKernel );
if (kernel_only && !(iAttributes&ESupervisor))
return KErrNotSupported;
if (seg.iAttr&ECodeSegAttKernel || seg.iDataAllocBase==-1)
return KErrNone; // no extra mappings needed for kernel code or code with fixed data address
TInt r=KErrNone;
if (seg.IsDll())
{
TInt total_data_size;
TLinAddr data_base;
seg.GetDataSizeAndBase(total_data_size, data_base);
if (r==KErrNone && total_data_size)
{
TInt size=Mmu::RoundToPageSize(total_data_size);
r=CommitDllData(data_base, size);
}
}
return r;
}
void DMemModelProcess::UnmapCodeSeg(DCodeSeg* aSeg)
{
DMemModelCodeSeg& seg=*(DMemModelCodeSeg*)aSeg;
__KTRACE_OPT(KDLL,Kern::Printf("Process %O UnmapCodeSeg %C", this, aSeg));
if (seg.iAttr&ECodeSegAttKernel || seg.iDataAllocBase==-1)
return; // no extra mappings needed for kernel code or code with fixed data address
if (seg.IsDll())
{
TInt total_data_size;
TLinAddr data_base;
seg.GetDataSizeAndBase(total_data_size, data_base);
if (total_data_size)
DecommitDllData(data_base, Mmu::RoundToPageSize(total_data_size));
}
}
TInt DMemModelProcess::NewShPool(DShPool*& /* aPool */, TShPoolCreateInfo& /* aInfo */)
{
return KErrNotSupported;
}
TInt DThread::RawRead(const TAny* aSrc, TAny* aDest, TInt aLength, TInt aFlags, TIpcExcTrap* aExcTrap)
//
// Read from the thread's process.
// aSrc is run address of memory to read. The memory is in aThread's address space.
// aDest is the address of destination. The memory is in the current process's address space.
// aExcTrap, exception trap object to be updated if the actual memory access is performed on another memory area. It happens
// when reading is performed in chunks or if home adress is read instead of the provided run address.
// Enter and return with system locked.
{
const TUint8* pS=(const TUint8*)aSrc;
TUint8* pD=(TUint8*)aDest;
const TUint8* pC=NULL;
TBool check=ETrue;
TBool suspect=EFalse;
DThread* pT=TheCurrentThread;
while (aLength)
{
if (check)
{
suspect=((aFlags & KCheckLocalAddress) && !MM::CurrentAddress(pT,pD,aLength,ETrue));
if (iMState==EDead)
return KErrDied;
pC=(const TUint8*)MM::CurrentAddress(this,pS,aLength,EFalse);
__KTRACE_OPT(KTHREAD2,Kern::Printf("DThread::RawRead %08x<-[%08x::%08x]%08x+%x",pD,this,pS,pC,aLength));
if (!pC)
return KErrBadDescriptor;
}
TInt len=Min(aLength,K::MaxMemCopyInOneGo);
if (aExcTrap)
{
aExcTrap->iSize = (len + 2*(sizeof(TInt32)-1));//+6 is for the worst case. We do not have to be precise here.
aExcTrap->iRemoteBase = (TLinAddr)pC & ~(sizeof(TInt32)-1);
if (aExcTrap->iLocalBase)
aExcTrap->iLocalBase = (TLinAddr)pD & ~(sizeof(TInt32)-1);
__KTRACE_OPT(KTHREAD2,Kern::Printf("DThread::RawRead exc. update: %08x %08x %08x",aExcTrap->iLocalBase,aExcTrap->iRemoteBase,aExcTrap->iSize));
}
#ifdef __DEMAND_PAGING__
XTRAP_PAGING_START(check);
CHECK_PAGING_SAFE;
#endif
suspect?(void)umemput(pD,pC,len):(void)memcpy(pD,pC,len);
#ifdef __DEMAND_PAGING__
XTRAP_PAGING_END;
if(check<0)
return check; // paging error caused by bad client (I.e. 'this' thread was bad)
if(check)
{
__KTRACE_OPT(KTHREAD2,Kern::Printf("DThread::RawRead paging trap, suspect %d, dest %08x, source %08x, length %d\n", suspect, pD, pC, len));
continue;
}
#endif
pD+=len;
pS+=len;
pC+=len;
aLength-=len;
if (aLength)
check=NKern::FlashSystem();
}
return KErrNone;
}
TInt DThread::RawWrite(const TAny* aDest, const TAny* aSrc, TInt aLength, TInt aFlags, DThread* aOriginatingThread, TIpcExcTrap* aExcTrap)
//
// Write to the thread's process.
// aDest is run address of memory to write. It resides in this thread's address space.
// aSrc is address of the source buffer. It resides in the current process's address space.
// aOriginatingThread is the thread on behalf of which this operation is performed (eg client of device driver).
// Enter and return with system locked
// aExcTrap, exception trap object to be updated if the actual memory access is performed on another memory area. It happens
// when reading is performed in chunks or if home adress is read instead of the provided run address.
//
{
TUint8* pD=(TUint8*)aDest;
const TUint8* pS=(const TUint8*)aSrc;
TUint8* pC=NULL;
TBool check=ETrue;
TBool suspect=EFalse;
DThread* pT=TheCurrentThread;
DThread* pO=aOriginatingThread;
if (!pO)
pO=pT;
DProcess* pF=K::TheFileServerProcess;
TBool special=(iOwningProcess==pF && pO->iOwningProcess==pF);
while (aLength)
{
if (check)
{
suspect=((aFlags & KCheckLocalAddress) && !MM::CurrentAddress(pT,pS,aLength,EFalse));
if (iMState==EDead)
return KErrDied;
pC=(TUint8*)MM::CurrentAddress(this,pD,aLength,ETrue);
__KTRACE_OPT(KTHREAD2,Kern::Printf("DThread::RawRead [%08x::%08x]%08x<-%08x+%x",this,pD,pC,pS,aLength));
if (!pC)
{
if (special)
pC=pD;
else
return KErrBadDescriptor;
}
}
TInt len=Min(aLength,K::MaxMemCopyInOneGo);
if (aExcTrap)
{
aExcTrap->iSize = (len + 2*(sizeof(TInt32)-1));//+6 is for the worst case. We do not have to be precise here.
aExcTrap->iRemoteBase = (TLinAddr)pC & ~(sizeof(TInt32)-1);
if (aExcTrap->iLocalBase)
aExcTrap->iLocalBase = (TLinAddr)pS & ~(sizeof(TInt32)-1);
__KTRACE_OPT(KTHREAD2,Kern::Printf("DThread::RawWrite exc. update %08x %08x %08x",aExcTrap->iLocalBase,aExcTrap->iRemoteBase,aExcTrap->iSize));
}
#ifdef __DEMAND_PAGING__
XTRAP_PAGING_START(check);
// Must check that it is safe to page, unless we are reading from unpaged ROM in which case
// we allow it. umemget does this anyway, so we just need to check if suspect is not set.
if (!suspect)
{
CHECK_PAGING_SAFE_RANGE((TLinAddr)aSrc, aLength);
CHECK_DATA_PAGING_SAFE_RANGE((TLinAddr)aDest, aLength);
}
#endif
suspect?(void)umemget(pC,pS,len):(void)memcpy(pC,pS,len);
#ifdef __DEMAND_PAGING__
XTRAP_PAGING_END
if(check<0)
return check; // paging error caused by bad client (I.e. 'this' thread was bad)
if(check)
{
__KTRACE_OPT(KTHREAD2,Kern::Printf("DThread::RawWrite paging trap, suspect %d, dest %08x, src %08x, length %d\n", suspect, pC, pD, len));
continue;
}
#endif
pD+=len;
pS+=len;
pC+=len;
aLength-=len;
if (aLength)
check=NKern::FlashSystem();
}
return KErrNone;
}
#ifdef __DEBUGGER_SUPPORT__
TInt CodeModifier::SafeWriteCode(DProcess* aProcess, TLinAddr aAddress, TInt aSize, TUint aValue, void* aOldValue)
{
//Set exception handler. Make sure the boundaries cover the worst case (aSize = 4)
TIpcExcTrap xt;
xt.iLocalBase=0;
xt.iRemoteBase=(TLinAddr)aAddress&~3; //word aligned.
xt.iSize=sizeof(TInt);
xt.iDir=1;
NKern::LockSystem();
TInt r=xt.Trap(NULL);
if (r==0)
{
r = WriteCode(aAddress, aSize, aValue, aOldValue);
xt.UnTrap();
}
NKern::UnlockSystem();
return r;
}
TInt CodeModifier::WriteCode(TLinAddr aAddress, TInt aSize, TUint aValue, void* aOldValue)
{
TUint userChunkBase = (TUint)MM::UserCodeChunk->Base();
TRomHeader romHeader = Epoc::RomHeader();
if (!((aAddress >= romHeader.iRomBase ) && (aAddress < (romHeader.iRomBase + romHeader.iUncompressedSize)))) //if not in ROM
if ( (aAddress<userChunkBase) || (aAddress) > (userChunkBase+MM::UserCodeChunk->MaxSize()) ) //and not in non-XIP code
return KErrBadDescriptor;
// if page was moved by defrag there may be a cache line with the
// wrong, old physical address, so we must invalidate this first.
InternalCache::Invalidate(KCacheSelectD, (TLinAddr)aAddress, 4);
//Copy data and clean/invalidate caches with interrupts disabled.
TInt irq=NKern::DisableAllInterrupts();
switch(aSize)
{
case 1:
*(TUint8*) aOldValue = *(TUint8*)aAddress;
*(TUint8*) aAddress = (TUint8)aValue;
break;
case 2:
*(TUint16*) aOldValue = *(TUint16*)aAddress;
*(TUint16*) aAddress = (TUint16)aValue;
break;
default://It is 4 otherwise
*(TUint32*) aOldValue = *(TUint32*)aAddress;
*(TUint32*) aAddress = (TUint32)aValue;
break;
};
CacheMaintenance::CodeChanged(aAddress, aSize, CacheMaintenance::ECodeModifier);
NKern::RestoreInterrupts(irq);
return KErrNone;
}
#endif //__DEBUGGER_SUPPORT__
TInt DThread::ReadAndParseDesHeader(const TAny* aSrc, TDesHeader& aDest)
//
// Read the header of a remote descriptor.
// Enter and return with system locked
//
{
TInt r=KErrBadDescriptor;
DThread* thread = TheCurrentThread;
TRawDesHeader& header = (TRawDesHeader&)aDest;
#ifdef __DEMAND_PAGING__
retry:
TInt pagingFault;
XTRAP_PAGING_START(pagingFault);
CHECK_PAGING_SAFE;
thread->iIpcClient = this;
#endif
const TUint32* pS=(const TUint32*)MM::CurrentAddress(this,aSrc,sizeof(TDesC8),EFalse);
if (pS && KErrNone==Kern::SafeRead(pS,&header[0],sizeof(TUint32)))
{
TInt type=header[0]>>KShiftDesType8;
static const TUint8 LengthLookup[16]={4,8,12,8,12,0,0,0,0,0,0,0,0,0,0,0};
TInt len=LengthLookup[type];
if(len>(TInt)sizeof(TUint32))
{
if(KErrNone==Kern::SafeRead(pS+1,&header[1],len-sizeof(TUint32)))
r = type;
// else, bad descriptor
}
else if(len)
r = type;
// else, bad descriptor
}
#ifdef __DEMAND_PAGING__
thread->iIpcClient = NULL;
XTRAP_PAGING_END;
if(pagingFault<0)
return pagingFault; // paging error caused by bad client (I.e. 'this' thread was bad)
if(pagingFault)
goto retry;
#endif
return K::ParseDesHeader(aSrc, header, aDest);
}
DMemModelChunk* ChunkFromAddress(DThread* aThread, const TAny* aAddress)
{
DMemModelProcess* pP = (DMemModelProcess*)aThread->iOwningProcess;
DMemModelProcess::SChunkInfo* pS=pP->iChunks;
DMemModelProcess::SChunkInfo* pC=pS+pP->iNumChunks;
while(--pC>=pS && TUint(pC->iDataSectionBase)>TUint(aAddress)) {};
if(pC<pS)
return 0;
return pC->iChunk;
}
/**
Open a shared chunk in which a remote address range is located.
*/
DChunk* DThread::OpenSharedChunk(const TAny* aAddress, TBool aWrite, TInt& aOffset)
{
NKern::LockSystem();
DMemModelProcess* pP = (DMemModelProcess*)iOwningProcess;
DMemModelProcess::SChunkInfo* pS=pP->iChunks;
DMemModelProcess::SChunkInfo* pC=pS+pP->iNumChunks;
while(--pC>=pS && TUint(pC->iDataSectionBase)>TUint(aAddress)) {};
if(pC>=pS)
{
DMemModelChunk* chunk = pC->iChunk;
if(chunk->iChunkType==ESharedKernelSingle || chunk->iChunkType==ESharedKernelMultiple)
{
TInt offset = (TInt)aAddress-(TInt)chunk->Base();
if(TUint(offset)<TUint(chunk->iMaxSize) && chunk->Open()==KErrNone)
{
aOffset = offset;
NKern::UnlockSystem();
return chunk;
}
}
}
NKern::UnlockSystem();
return 0;
}
TInt DThread::PrepareMemoryForDMA(const TAny* aLinAddr, TInt aSize, TPhysAddr* aPhysicalPageList)
{
if ((iOwningProcess->iAttributes & DMemModelProcess::EFixedAddress )==0)
return KErrNotSupported;
Mmu& m=(Mmu&)*MmuBase::TheMmu;
return m.PreparePagesForDMA((TLinAddr)aLinAddr, aSize, aPhysicalPageList);
}
TInt DThread::ReleaseMemoryFromDMA(const TAny* aLinAddr, TInt aSize, TPhysAddr* aPhysicalPageList)
{
if ((iOwningProcess->iAttributes & DMemModelProcess::EFixedAddress )==0)
return KErrNotSupported;
TInt pageCount = (((TInt)aLinAddr & KPageMask) + aSize + KPageMask) >> KPageShift;
Mmu& m=(Mmu&)*MmuBase::TheMmu;
return m.ReleasePagesFromDMA(aPhysicalPageList, pageCount);
}