diff -r 000000000000 -r dfb7c4ff071f commsprocess/commsrootserverconfig/rootsrv/c32exe.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commsprocess/commsrootserverconfig/rootsrv/c32exe.cpp Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,366 @@ +// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "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: +// The Rootserver executeable. Runs the Rootserver from c32rootsrv.dll. +// +// + +/** + @file + @internalComponent +*/ + +#include +#include +#include // for initialising CommsDat +#include "c32Exe.h" +using namespace RootServer; + +#include + + +__CFLOG_STMT(_LIT8(KLogSubSysRS, "RootServer");) // subsystem name + +CCommsProviderModule* CC32ProviderModule::NewL(CRootServer* aRootServer, + const TRSStartModuleParams& aParams, + HBufC8* aIniData) + /** Creates a new instance of a CPM. + @param aRootServer The root server object + @param aParams The data used to load the module + @param aIniData The initialisation data for the module + */ + { + + CC32ProviderModule* pCPM = new (ELeave) CC32ProviderModule(); + CleanupStack::PushL(pCPM); + pCPM->ConstructL(aRootServer, aParams, aIniData); + CleanupStack::Pop(pCPM); + return pCPM; + } + +TInt CC32ProviderModule::CreateModuleThread(const TDesC& aName, TThreadFunction aOtherThreadFunction, + TInt aStackSize, RHeap* aHeap, TAny* aModuleArgs) + { + return iRCFThread.Create(aName, aOtherThreadFunction, aStackSize, aHeap, aModuleArgs); + } + +CRootServer* CC32RootServer::NewL(const TRootServerStartupInfo& aRootServerStartupInfo) + /** Create new rootserver instance. + This is the only way of instantiation + @internalComponent + @param aRootServerStartupInfo Information containing name of the server and priority of the server active object. + */ + { + CC32RootServer* pS=new (ELeave) CC32RootServer(aRootServerStartupInfo.iPriority); + CleanupStack::PushL(pS); + pS->iCommsProviderModuleCtorL = CC32ProviderModule::NewL; + pS->ConstructL(aRootServerStartupInfo); + // Now that we're guaranteed to be a singleton initialise CommsDat + __CFLOG(KLogSubSysRS, KLogCode, _L8("RunRootServer - Initializing Commsdat")); + CommsDat::CMDBSession* ptrCommsdatSession = NULL; + TRAPD(result, ptrCommsdatSession = CommsDat::CMDBSession::NewL(KCDVersion1_2)); + if (result == KErrNone) + { + result = ptrCommsdatSession->PublishProperties(); + if(result != KErrNone) + { + __CFLOG_1(KLogSubSysRS, KLogCode, _L8("RunRootServer - Error %d in CMDBSession::PublishProperties"), result); + } + delete ptrCommsdatSession; + } + else + { + __CFLOG_1(KLogSubSysRS, KLogCode, _L8("RunRootServer - Error %d creating Commsdat object"), result); + } + __CFLOG(KLogSubSysRS, KLogCode, _L8("RunRootServer - Commsdat initialized")); + + CleanupStack::Pop(pS); + return pS; + } + +CC32RootServer::~CC32RootServer() + { +#ifdef SYMBIAN_ZERO_COPY_NETWORKING + iCommsBufPond.Close(); +#else + delete iMBufManager; +#endif // SYMBIAN_ZERO_COPY_NETWORKING + } + +#ifdef _DEBUG +TInt CC32RootServer::RunError(TInt aError) + { + __CFLOG_1(KLogSubSysRS, KLogCode, _L8("CRootServer::RunError:%d" ), aError); + return aError; + } +#endif // _DEBUG + +TInt CC32RootServer::AdjustMBufPool(const TRSSetMBufMnr &aMBufParamsPckg) + /** Adjust the buffer pool size. + Doesn't actually adjust the pool, can only be called when there + is no pool instantiated. If a pool is already instantiated, returns KErrInUse. + @internalComponent + @param aBufPoolSize The new size of the buffer pool in bytes. + @return An error code + */ + { + const TRSSetMBufMnrContainer &mbufParams = aMBufParamsPckg(); + __CFLOG_2(KLogSubSysRS, KLogCode, _L8("CRootServer - AdjustMBufPool to %d Init and %d Max."), + mbufParams.iInitSize, mbufParams.iMaxSize); + + // Can't do this if it is already in use + if(CpmCount()>0) + return KErrInUse; +#ifndef SYMBIAN_ZERO_COPY_NETWORKING + if(iInitMBufPoolSize == mbufParams.iInitSize && iMaxMBufPoolSize == mbufParams.iMaxSize) + { + return KErrNone; + } + + // Finally register new size. + iInitMBufPoolSize = mbufParams.iInitSize; + iMaxMBufPoolSize = mbufParams.iMaxSize; + + // Delete MBufManager, it will be lazy loaded with new value when needed + if(iMBufManager!=NULL) + { + delete iMBufManager; + iMBufManager=NULL; + } +#endif // SYMBIAN_ZERO_COPY_NETWORKING + return KErrNone; + } + +TInt CC32RootServer::AdjustMBufSizeAllocInfo(const TRSAddMBufAllocInfo &aMBufParamsPckg) + /** Adjust (aka add) the mbuf size alloc info + @internalComponent + @param aBufPoolSize The new size of the buffer pool in bytes. + @return An error code + */ + { + const TRSAddMBufAllocInfoContainer &mBufAllocSizeInfo = aMBufParamsPckg(); + __CFLOG_4(KLogSubSysRS, KLogCode, _L8("CRootServer::AdjustMBufSizeAllocInfo() - mbufSize=%d initialAlloc=%d minGrowth=%d growthThreshold=%d"), + mBufAllocSizeInfo.iMBufSize, mBufAllocSizeInfo.iInitialAllocation, mBufAllocSizeInfo.iMinGrowth, mBufAllocSizeInfo.iGrowthThreshold); + + // store params - they will be retrieved set during the lazy load + return iMBufSizeAllocInfo.Append(mBufAllocSizeInfo); + } + +void CC32RootServer::LazyLoadL() + /** Instantiate the MBuf Manager. + If the MBufManager is not already running, then create a new + instance of it. + @internalComponent + */ + { +#ifdef SYMBIAN_ZERO_COPY_NETWORKING + if(TCommsBufPondTLSOp::Get().IsNull()) + { + __CFLOG_0(KLogSubSysRS, KLogCode, + _L8("CRootServer - Lazy loading CommsBuf Pond.")); + RArray bufPoolCreateInfoArray; + // configure the mbuf size allocation info + for (int i=0; i < iMBufSizeAllocInfo.Count(); i++) + { + TRSAddMBufAllocInfoContainer &allocInfo = iMBufSizeAllocInfo[i]; + __CFLOG_4(KLogSubSysRS, KLogCode, + _L8("CRootServer::LazyLoadMBufManagerL(); - about to add mbuf size alloc info - mbufSize=%d initialAlloc=%d minGrowth=%d growthThreshold=%d"), + allocInfo.iMBufSize, allocInfo.iInitialAllocation, + allocInfo.iMinGrowth, allocInfo.iGrowthThreshold); + TCommsBufPoolCreateInfo createInfo; + createInfo.iBufSize = allocInfo.iMBufSize; + createInfo.iInitialBufs = allocInfo.iInitialAllocation; + createInfo.iGrowByBufs = allocInfo.iMinGrowth; + createInfo.iMinFreeBufs = allocInfo.iGrowthThreshold; + createInfo.iCeiling = allocInfo.iPoolCeiling; + bufPoolCreateInfoArray.AppendL(createInfo); + } + User::LeaveIfError(iCommsBufPond.Open(bufPoolCreateInfoArray)); + } +#else + if(iMBufManager==NULL) + { + __CFLOG_2(KLogSubSysRS, KLogCode, + _L8("CRootServer - Lazy loading MBuf Manager. %d initial bytes - can grow to %d bytes."), + iInitMBufPoolSize,iMaxMBufPoolSize); + + iMBufManager = CMBufManager::NewL(iMaxMBufPoolSize, iMBufSizeAllocator); + + if (iMBufSizeAllocator) + { + // configure the mbuf size allocation info + for (int i=0; i < iMBufSizeAllocInfo.Count(); i++) + { + TRSAddMBufAllocInfoContainer &allocInfo = iMBufSizeAllocInfo[i]; + __CFLOG_4(KLogSubSysRS, KLogCode, + _L8("CRootServer::LazyLoadMBufManagerL(); - about to add mbuf size alloc info - mbufSize=%d initialAlloc=%d minGrowth=%d growthThreshold=%d"), + allocInfo.iMBufSize, allocInfo.iInitialAllocation, + allocInfo.iMinGrowth, allocInfo.iGrowthThreshold); + iMBufSizeAllocator->AddL(allocInfo.iMBufSize, allocInfo.iInitialAllocation, + allocInfo.iMinGrowth, allocInfo.iGrowthThreshold); + } + + iMBufSizeAllocator->Commit(); + } + iMBufSizeAllocInfo.Close(); + } + +#endif // SYMBIAN_ZERO_COPY_NETWORKING + } + + +TBool CC32RootServer::IsCallerConfigurator(const CRootServerSession* aSession, const RMessage2& aMessage) + /** If The Configurator has been determined then any other session asking isn't. Otherwise the + first configurator process to ask becomes The Configurator. Note that this would fail if The + Configurator opened a second session, but it doesn't (and it's internalTech) + */ + { + if(!iTheConfiguratorSession) + { + RThread client; + TInt err = aMessage.Client(client); + if(err == KErrNone) + { + static _LIT_SECURITY_POLICY_S1(configuratorPolicy, KUidC32StartProcess, ECapabilityProtServ); + if(configuratorPolicy.CheckPolicy(client)) + { + iTheConfiguratorSession = aSession; + } + client.Close(); + } + } + return iTheConfiguratorSession == aSession; + } + +void CC32RootServer::DisconnectSession(const CRootServerSession* aSession) + { + if(iTheConfiguratorSession == aSession) + { + iTheConfiguratorSession = NULL; + } + } + +CSession2* CC32RootServer::NewSessionL(const TVersion &aVersion, const RMessage2& /*aMessage*/) const + /** Create new session object. + @internalComponent + */ + { + __CFLOG(KLogSubSysRS, KLogCode,_L8("CC32RootServer - NewSession")); + + TVersion v(TVersion(KRS32MajorVersionNumber,KRS32MinorVersionNumber,KRS32BuildVersionNumber)); + TBool r = User::QueryVersionSupported(v, aVersion); + if (r==EFalse) + User::Leave(KErrNotSupported); + CC32RootServerSession* p = new(ELeave) CC32RootServerSession(this); + return p; + } + + +CC32RootServerSession::CC32RootServerSession(const CRootServer* aRootServer):CRootServerSession(aRootServer) + { + } + +CC32RootServerSession::~CC32RootServerSession() + { + } + +void CC32RootServerSession::ServiceL(const RMessage2& aMessage) + { + TInt result = KErrGeneral; + TBool completeNow = ETrue; + switch ((aMessage.Function())) + { + case RSSetMBufPoolSize: + result = SetMBufPoolSize(aMessage); + break; + + case RSAddMBufAllocInfo: + result = AddMBufAllocInfo(aMessage); + break; + + case RSIsCallerConfigurator: + result = IsCallerConfigurator(aMessage); + break; + + case RSDbgFailNextMbuf: + case RSDbgSetMbufPoolLimit: + case RSDbgCheckMbuf: + case RSDbgMbufFreeSpace: + case RSDbgMbufTotalSpace: + result = KErrNotSupported; + break; + + default: + CRootServerSession::ServiceL(aMessage); + completeNow = EFalse; + break; + } + + if(completeNow) + { + aMessage.Complete(result); + } + } + +TInt CC32RootServerSession::IsCallerConfigurator(const RMessage2& aMessage) + { + return (TInt) iRootServer->IsCallerConfigurator(this, aMessage); + } + +TInt CC32RootServerSession::SetMBufPoolSize(const RMessage2& aMessage) + { + // Do the dirty business and return the result + TInt ret; + TRSSetMBufMnr params; + ret = aMessage.Read(0,params); + if (ret != KErrNone) + { + return ret; + } + return (static_cast (iRootServer))->AdjustMBufPool(params); + } + +// set the mbuf size allocation information +TInt CC32RootServerSession::AddMBufAllocInfo(const RMessage2& aMessage) + { + TRSAddMBufAllocInfo params; + TInt ret = aMessage.Read(0, params); + if (ret != KErrNone) + { + return ret; + } + return (static_cast (iRootServer))->AdjustMBufSizeAllocInfo(params); + } + + +TInt E32Main() +/** Life starts here. ONly purpose is to run RunRootServer() from c32rootsrv.dll +*/ + { + __FLOG_DECLARATION_VARIABLE; + __FLOG_STMT( _LIT8( KRSLogSubSys, "RootServer" ) ); + __FLOG_STMT( _LIT8( KRSLogComp, "event" ) ); + __FLOG_OPEN( KRSLogSubSys, KRSLogComp ); + __FLOG( _L8("C32exe.exe - E32Main calling RunRootServer in DLL") ); + __FLOG_CLOSE; + + TRootServerStartupInfo info; + info.iPriority = CActive::EPriorityStandard; + info.iServerName = KRootServerName; + info.iRootServerCtor = CC32RootServer::NewL; + info.iDeathKey = KUidC32RootModuleDeathKey; + info.iLeakKey.iUid = KUidCommsModuleLeakCounter; + info.iProcessKey = KUidCommsProcess; + return RunRootServer(info); // Load Root Server. Blocks by starting the active scheduler + } +