TBool CMemoryMonitorSession::IsDataPaged(const RMessage2& aMessage)
{
RThread clientThread;
TInt err = aMessage.Client(clientThread);
TBool dataPaged = EFalse;
if(err == KErrNone)
{
RProcess processName;
err = clientThread.Process(processName);
if(err == KErrNone)
{
dataPaged = processName.DefaultDataPaged();
processName.Close();
clientThread.Close();
}
else
{
clientThread.Close();
PanicClient(aMessage, EPanicIllegalFunction);
}
}
else
{
PanicClient(aMessage, EPanicIllegalFunction);
}
return dataPaged;
}
void CWsTop::InitStaticsL()
{
iShuttingDown=EFalse;
// By default shell should be started.
TBool startShell = ETrue;
iCurrentFocusScreen = 0;
// The windows server has been invoked.
// This may have been from the system starter (via a
// start up rss file)
// This block looks for a "-NoShell" argument in the invocation.
// The existence of the argument means that shell does not need to be
// invoked from here because the new system starter
// is in charge, and it will do it if required.
_LIT(KNoShell,"-NOSHELL");
TInt argLen = User::CommandLineLength();
if(argLen)
{
HBufC* arg = HBufC::NewLC(argLen);
TPtr argPtr = arg->Des();
User::CommandLine(argPtr);
argPtr.UpperCase();
if(KErrNotFound != argPtr.Find(KNoShell))
{
// Don't start the shell. It will be started if required by
// the system starter.
startShell = EFalse;
}
CleanupStack::PopAndDestroy(arg);
}
TheActiveScheduler=new(ELeave) CWsActiveScheduler;
CActiveScheduler::Install(TheActiveScheduler);
// WsIniFile is already created (before E32Main's Loop)
_LIT(KWSERVIniFileVarLogEnable,"LOGENABLE");
TInt loggingLevel;
if (WsIniFile->FindVar(KWSERVIniFileVarLogEnable,loggingLevel))
{
EnableLogging(EDoNotReloadWsIni);
if (wsDebugLog)
{
wsDebugLog->SetLoggingLevel(loggingLevel);
}
}
_LIT(KWSERVIniFileVarFadeEnable,"FADEDISABLE");
iFadeEnabled = !WsIniFile->FindVar(KWSERVIniFileVarFadeEnable);
_LIT(KWSERVIniFileVarFinishEveryFlush,"FINISHEVERYFLUSH");
iFinishEveryFlush = WsIniFile->FindVar(KWSERVIniFileVarFinishEveryFlush);
_LIT(KWSERVIniFileVarSwitchOffEvent,"IGNORESWITCHOFFEVENT");
iIgnoreSwitchOffEvent = WsIniFile->FindVar(KWSERVIniFileVarSwitchOffEvent);
iPluginManager = CWsPluginManager::NewL(); // need to be constructed before iServer!
iServer=CWindowServer::NewL();
CClick::InitStaticsL();
RProcess wservProc;
if (!wservProc.DefaultDataPaged())
{
iServer->SetPinClientDescriptors(ETrue);
}
User::LeaveIfError(FbsStartup());
User::LeaveIfError(RFbsSession::Connect());
User::LeaveIfError(iTimer.CreateLocal());
TWindowServerEvent::InitStaticsL();
CWsClient::InitStaticsL();
//-------------------------------------------
User::LeaveIfError( HAL::Get( HAL::EDisplayNumberOfScreens, iNumberOfScreens ) ) ;
// Check that the INI file matches the HAL
WS_ASSERT_ALWAYS(WsIniFile->NumberOfScreens()<=iNumberOfScreens, EWsPanicScreenInformationError);
iScreens = new (ELeave) CArrayPtrFlat<CScreen>( iNumberOfScreens ) ; //
// now construct screens for as long as there is information
TInt ii ;
for ( ii = 0 ; ii < iNumberOfScreens ; ++ii )
{
InitScreenL( ii ) ;
}
//---------------------------------------------
iCurrentFocusScreen = (*iScreens)[0] ;
iServer->StartL();
CWsFontCache::CreateInstanceL();
CWsGc::InitStaticsL();
CPlaybackGc::InitStaticsL();
CWsSpriteBase::InitStaticsL();
CEventQueue::InitStaticsL();
//
CWsAnimDll::InitStaticsL();
//
TInt bootMode=0;
_LIT(KWSERVIniFileVarReboot,"REBOOT");
WsIniFile->FindVar(KWSERVIniFileVarReboot,bootMode);
if (bootMode>=0 && bootMode<=2)
iShellBootMode=bootMode;
//
CWsBackedUpWindow::StaticInitL();
CWsRedrawMsgWindow::StaticInitL();
//
TWsPointer::InitStaticsL();
iShellStarter=new (ELeave) CShellStarter;
iShellStarter->ConstructL();
_LIT(KPreProcess,"REMOVEFADINGONFOCUSGAIN");
CWsWindowGroup::SetFocusGainPreprocessing(WsIniFile->FindVar(KPreProcess));
_LIT(KAbsFade,"ABSOLUTEFADING");
CWsClientWindow::SetAbsoluteFading(WsIniFile->FindVar(KAbsFade));
//Set the focus policy
_LIT(KFocusPolicy,"MULTIFOCUSPOLICY");
if(WsIniFile->FindVar(KFocusPolicy))
{
iMultiFocusPolicy = ETrue;
}
RProcess::Rendezvous(KErrNone);
// Start the shell from here unless the 'NoShell' option has been
// received indicating that the system starter will start the shell directly.
if(startShell)
{
StartShell();
}
UserSvr::WsRegisterSwitchOnScreenHandling(ETrue);
iRenderOrientationTracker = CWsRenderOrienationTracker::NewL();
}
GLDEF_C TInt E32Main()
{
RTest test(_L("T_SVRPINNING...main"));
test.Title();
if (DPTest::Attributes() & DPTest::ERomPaging)
test.Printf(_L("Rom paging supported\n"));
if (DPTest::Attributes() & DPTest::ECodePaging)
test.Printf(_L("Code paging supported\n"));
if (DPTest::Attributes() & DPTest::EDataPaging)
{
test.Printf(_L("Data paging supported\n"));
gDataPagingSupport = ETrue;
}
// Determine the data paging attribute.
RProcess process; // Default to point to current process.
gProcessPaged = process.DefaultDataPaged();
test.Printf(_L("Process data paged %x\n"), gProcessPaged);
test.Start(_L("Test IPC message arguments pinning"));
test_KErrNone(HAL::Get(HAL::EMemoryPageSize, gPageSize));
gPageMask = gPageSize - 1;
test_Equal(KPageSize, gPageSize);
// Disable JIT as we are testing panics and don't want the emulator to hang.
TBool justInTime = User::JustInTime();
User::SetJustInTime(EFalse);
TBool exitFailure = EFalse;
for ( gServerPinningState = EServerDefault;
gServerPinningState < EServerSetPinningTooLate && !exitFailure;
gServerPinningState++)
{
// Create the server with the specified pinning mode.
switch (gServerPinningState)
{
case EServerDefault :
test.Next(_L("Test server with default pinning policy"));
break;
case EServerPinning :
test.Next(_L("Test server with pinning policy"));
break;
case EServerNotPinning :
test.Next(_L("Test server with not pinning policy"));
break;
}
test_KErrNone(gSem.CreateLocal(0));
test_KErrNone(gSem1.CreateLocal(0));
// Create the server thread it needs to have a unpaged stack and heap.
TThreadCreateInfo serverInfo(_L("Server Thread"), ServerThread, KDefaultStackSize, (TAny*)gServerPinningState);
serverInfo.SetPaging(TThreadCreateInfo::EUnpaged);
serverInfo.SetCreateHeap(KHeapMinSize, KHeapMaxSize);
RThread serverThread;
test_KErrNone(serverThread.Create(serverInfo));
TRequestStatus serverStat;
serverThread.Logon(serverStat);
serverThread.Resume();
// Wait for the server to start and then create a session to it.
gSem.Wait();
RSession session;
test_KErrNone(session.PublicCreateSession(_L("CTestServer"),5));
for ( TUint clientTest = CTestSession::ETestRdPinAll;
clientTest <= CTestSession::ETestPinDefault && !exitFailure;
clientTest++)
{
// Create the client thread it needs to have a paged stack and heap.
TThreadCreateInfo clientInfo(_L("Client Thread"), ClientThread, 10 * gPageSize, (TAny*)clientTest);
clientInfo.SetPaging(TThreadCreateInfo::EPaged);
clientInfo.SetCreateHeap(KHeapMinSize, KHeapMaxSize);
RThread clientThread;
test_KErrNone(clientThread.Create(clientInfo));
TRequestStatus clientStat;
clientThread.Logon(clientStat);
clientThread.Resume();
// Wait for the client thread to end.
User::WaitForRequest(clientStat);
// If all the descriptor arguments were not pinned then the client
// thread should have been panicked.
TBool expectPanic = (clientTest == CTestSession::ETestRdPinAll ||
clientTest == CTestSession::ETestWrPinAll ||
clientTest == CTestSession::ETestPinOOM )? 0 : 1;
expectPanic = !UpdateExpected(!expectPanic);
TInt exitReason = clientThread.ExitReason();
TInt exitType = clientThread.ExitType();
if (expectPanic)
{
if (exitType != EExitPanic ||
exitReason != EIllegalFunctionForRealtimeThread ||
clientThread.ExitCategory() != _L("KERN-EXEC"))
{
test.Printf(_L("Thread didn't panic as expected\n"));
exitFailure = ETrue;
}
}
else
{
if (exitType != EExitKill || exitReason != KErrNone)
{
test.Printf(_L("Thread didn't exit gracefully as expected\n"));
exitFailure = ETrue;
}
}
test(!exitFailure);
CLOSE_AND_WAIT(clientThread);
}
test.Next(_L("Test client sending message to closed server"));
TThreadCreateInfo clientInfo(_L("Client Thread"), ClientThread, 10 * gPageSize, (TAny*)CTestSession::ETestDeadServer);
clientInfo.SetPaging(TThreadCreateInfo::EPaged);
clientInfo.SetCreateHeap(KHeapMinSize, KHeapMaxSize);
RThread clientThread;
test_KErrNone(clientThread.Create(clientInfo));
TRequestStatus clientStat;
clientThread.Logon(clientStat);
clientThread.Resume();
gSem.Wait();
// Signal to stop ActiveScheduler and wait for server to stop.
session.PublicSendReceive(CTestSession::EStop, TIpcArgs());
session.Close();
User::WaitForRequest(serverStat);
if (serverThread.ExitType() != EExitKill)
{
test.Printf(_L("!!Server thread did something bizarre %d\n"), serverThread.ExitReason());
}
gSem1.Signal();
User::WaitForRequest(clientStat);
test_Equal(EExitKill, clientThread.ExitType());
test_Equal(KErrServerTerminated, clientThread.ExitReason());
CLOSE_AND_WAIT(clientThread);
CLOSE_AND_WAIT(serverThread);
CLOSE_AND_WAIT(gSem);
CLOSE_AND_WAIT(gSem1);
}
test.Next(_L("Test server setting pinning policy after server started"));
RThread serverThread;
test_KErrNone(serverThread.Create(_L("Server Thread"),ServerThread,KDefaultStackSize,KHeapMinSize,KHeapMaxSize, (TAny*)gServerPinningState));
TRequestStatus serverStat;
serverThread.Logon(serverStat);
serverThread.Resume();
// The server should have panicked with E32USER-CBase 106.
User::WaitForRequest(serverStat);
TInt exitReason = serverThread.ExitReason();
TInt exitType = serverThread.ExitType();
test_Equal(EExitPanic, exitType);
test_Equal(ECServer2InvalidSetPin, exitReason);
if (_L("E32USER-CBase") != serverThread.ExitCategory())
test(0);
CLOSE_AND_WAIT(serverThread);
test.End();
// Set JIT back to original state.
User::SetJustInTime(justInTime);
return (KErrNone);
}
