--- /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 <rsshared.h>
+#include <cflog.h>
+#include <commsdattypesv1_1.h> // for initialising CommsDat
+#include "c32Exe.h"
+using namespace RootServer;
+
+#include <comms-infras/commsdebugutility.h>
+
+
+__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<TCommsBufPoolCreateInfo> 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 <CC32RootServer*> (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 <CC32RootServer*> (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
+ }
+