FCL/sf/os/kernelhwsrv: comparison kernel/eka/euser/cbase/ub

equal deleted inserted replaced

--1:000000000000
+:a41df078684a
+// Copyright (c) 1995-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\euser\cbase\ub_svr.cpp
+//
+//
+#include "ub_std.h"
+//#define __DEBUG_IMAGE__ 1
+#if defined(__DEBUG_IMAGE__) && defined (__EPOC32__)
+#include "e32svr.h"
+#define __IF_DEBUG(t) {RDebug debug;debug.t;}
+#else
+#define __IF_DEBUG(t)
+#endif
+_LIT(KSessionPanicCategory,"CSession");
+_LIT(KServerPanicCategory,"CServer");
+/**
+Default constructor.
+This constructor is empty.
+*/
+EXPORT_C CSession2::CSession2()
+	{}
+/**
+Destructor.
+It frees resources prior to destruction of the object.
+Specifically, it removes this session object from the server
+active object’s list of sessions.
+*/
+EXPORT_C CSession2::~CSession2()
+	{
+	if (iLink.iNext)
+		iLink.Deque();
+	}
+/**
+Completes construction of this server-side client session object.
+The function is called by the server active object, the CServer2 derived
+class instance, when a client makes a connection request.
+The connection request results in the creation of this session object,
+followed by a call to this function.
+The default implementation is empty.
+@see CServer2::NewSessionL()
+*/
+EXPORT_C void CSession2::CreateL()
+	{
+	}
+/**
+Designates the (master or slave) server that is to service this session.
+This may be called from the NewSessionL() method of the CServer2-derived
+class or from the CreateL() method of the CSession2-derived class.
+It must not be called after CreateL() has finished, as this is the point
+at which the session binding become irrevocable.
+@see CServer::DoConnect()
+*/
+EXPORT_C void CSession2::SetServer(const CServer2* aServer)
+	{
+	ASSERT(iLink.iNext == NULL);
+	ASSERT(aServer);
+	iServer = aServer;
+	}
+/**
+Handles the situation when a call to CSession2::ServiceL(), which services
+a client request, leaves.
+Servers are active objects, and the call to CSession2::ServiceL() to handle
+a client request is executed as part of the server's active object RunL()
+function. If the RunL() leaves, the active object framework calls the active
+object's RunError() function. The server framework implements this as a call
+to ServiceError()
+The default behaviour of this function is to complete the message, using
+the leave value, if it has not already been completed.
+Servers can re-implement this as appropriate.
+@param aMessage The message containing the details of the client request that
+caused the leave.
+@param aError   The leave code.
+@see CActive::RunL()
+@see CActive::RunError()
+*/
+EXPORT_C void CSession2::ServiceError(const RMessage2& aMessage,TInt aError)
+	{
+	if(!aMessage.IsNull())
+		aMessage.Complete(aError);
+	}
+/**
+Called by a server when it receives a disconnect message for the session.
+This message is sent by the kernel when all client handles to the session have
+been closed.
+This method deletes the session object and completes the disconnect message.
+A derived session implementation may overide this virtual method if it needs to
+perform any asynchronous cleanup actions, these actions must end with a call to the
+base class implementation of this method, which will delete the session object
+and complete the disconnect message
+@param aMessage The disconnect message.
+@post 'this' session object has been deleted.
+*/
+EXPORT_C void CSession2::Disconnect(const RMessage2& aMessage)
+	{
+	delete this;
+	aMessage.Complete(0);
+	}
+/**
+Marks the start of resource count checking.
+It sets up a starting value for resource count checking.
+The function sets up a starting value for resource count checking by using
+the value returned by a call to CSession2::CountResources(), and is the value
+that will be used for comparison if CSession2::ResourceCountMarkEnd() is called
+at some later time.
+The client/server framework does not call this function (nor
+does it call CSession2::ResourceCountMarkEnd()), but is available for servers
+to use, if appropriate.
+@see CSession2::CountResources()
+@see CSession2::ResourceCountMarkEnd()
+*/
+EXPORT_C void CSession2::ResourceCountMarkStart()
+	{
+	iResourceCountMark=CountResources();
+	}
+/**
+Marks the end of resource count checking.
+The function takes the current resource count by
+calling CSession2::CountResources(), and compares it with the resource count
+value saved when CSession2::ResourceCountMarkStart() was called.
+If the resource counts differ, then the client thread is panicked (CSession 2)".
+The client/server framework does not call this function (nor does it call
+CSession2::ResourceCountMarkStart()), but the function is available for
+servers to use, if appropriate.
+@param aMessage Represents the details of the client request that is requesting
+this resource check.
+@see CSession2::CountResources()
+@see CSession2::ResourceCountMarkStart()
+*/
+EXPORT_C void CSession2::ResourceCountMarkEnd(const RMessage2& aMessage)
+	{
+	if (iResourceCountMark!=CountResources())
+		aMessage.Panic(KSessionPanicCategory,ESesFoundResCountHeaven);
+	}
+/**
+Gets the number of resources currently in use.
+Derived classes must provide a suitable implementation.
+The meaning of a resource depends on the design intent of the server.
+The default implementation panics the calling thread (CSession 1)
+before returning KErrGeneral.
+@return The current number of resources in use.
+@see CSession2::ResourceCountmarkStart()
+@see CSession2::ResourceCountmarkEnd()
+*/
+EXPORT_C TInt CSession2::CountResources()
+	{
+	User::Panic(KSessionPanicCategory,ESesCountResourcesNotImplemented);
+	return KErrGeneral;
+	}
+/**
+Extension function
+*/
+EXPORT_C TInt CSession2::Extension_(TUint aExtensionId, TAny*& a0, TAny* a1)
+	{
+	return CBase::Extension_(aExtensionId, a0, a1);
+	}
+/**
+Constructs the server object, specifying the server type and the active
+object priority.
+Derived classes must define and implement a constructor through which
+the priority can be specified. A typical implementation calls this server
+base class constructor through a constructor initialization list.
+@param aPriority The priority of this active object.
+@param aType     Indicates the type of session that the server creates.
+If not explicitly stated, then the server creates
+a session that is not sharable with other threads.
+*/
+EXPORT_C CServer2::CServer2(TInt aPriority, TServerType aType)
+	:	CActive(aPriority),
+		iSessionType((TUint8)aType),
+		iSessionQ(_FOFF(CSession2,iLink)),
+		iSessionIter(iSessionQ)
+	{
+	ASSERT(iSessionType == aType);
+	__ASSERT_COMPILE(EServerRole_Default == 0);
+	__ASSERT_COMPILE(EServerOpt_PinClientDescriptorsDefault == 0);
+	}
+/**
+Frees resources prior to destruction.
+Specifically, it cancels any outstanding request for messages, and
+deletes all server-side client session objects.
+*/
+EXPORT_C CServer2::~CServer2()
+	{
+	Cancel();
+	while (!iSessionQ.IsEmpty())
+		{
+		CSession2 *pS=iSessionQ.First();
+		pS->iLink.Deque();
+		pS->iLink.iNext=0;
+		delete pS;
+		}
+	iServer.Close();
+	}
+/**
+Sets whether the kernel will pin descriptors passed to this server in the context of the client
+thread.
+Setting this is one way of ensuring that the server will not take page faults when accessing client
+descriptors, which would otherwise happen if the data was paged out.
+This method overrides the default pinning policy of the server which is for the server
+to pin its client's descriptors if the process creating the server is not data paged.
+I.e. if CServer2::SetPinClientDescriptors() is not invoked on the server and
+RProcess::DefaultDataPaged() of the process creating the server returns EFalse,
+the server will pin its client's descriptors, otherwise the server will not pin its
+client's descriptors.
+This method must be called prior to starting the server by calling the Start() method.
+@param aPin	Set to ETrue for the server to pin its client's descriptors, set to
+			EFalse otherwise.
+@panic E32USER-CBase 106 When this method is invoked after the server has been started.
+@see CServer2::Start()
+@prototype
+*/
+EXPORT_C void CServer2::SetPinClientDescriptors(TBool aPin)
+	{
+	if (iServer.Handle() != KNullHandle)
+		{// Server already started so too late to make it a pinning one.
+		Panic(ECServer2InvalidSetPin);
+		}
+	iServerOpts &= ~EServerOpt_PinClientDescriptorsMask;
+	if (aPin)
+		iServerOpts |= EServerOpt_PinClientDescriptorsEnable;
+	else
+		iServerOpts |= EServerOpt_PinClientDescriptorsDisable;
+	}
+/**
+Assigns a role (master or slave) for this server.
+The master server is typically named, and receives all Connect messages
+from clients. It can hand off some sessions to be processed by one or
+more anonymous slave servers, each running in a separate thread.
+Both master and slave servers must call this function before calling
+Start(), in order to define their roles.  Once the server is started,
+its role cannot be changed.
+@panic E32USER-CBase-? When this method is invoked after the server has been started.
+@see CServer2::Start()
+@prototype
+*/
+EXPORT_C void CServer2::SetMaster(const CServer2* aServer)
+	{
+	// Roles can only be assigned before the call to Start()
+	ASSERT(Server().Handle() == KNullHandle);
+	if (aServer == NULL)
+		iServerRole = EServerRole_Standalone;
+	else if (aServer == this)
+		iServerRole = EServerRole_Master;
+	else
+		iServerRole = EServerRole_Slave;
+	}
+/**
+Adds the server with the specified name to the active scheduler,
+and issues the first request for messages.
+If KNullDesC is specified for the name, then an anonymous server will be created.
+To create a session to such a server, an overload of RSessionBase::CreateSession()
+which takes RServer2 object as a parameter can be used.
+@param aName The name of the server.
+KNullDesC, to create anonymous servers.
+@return KErrNone, if successful, otherwise one of the other system wide error codes.
+@capability ProtServ if aName starts with a '!' character
+*/
+EXPORT_C TInt CServer2::Start(const TDesC& aName)
+	{
+	TInt r = iServer.CreateGlobal(aName, iSessionType, iServerRole, iServerOpts);
+	if (r == KErrNone)
+		{
+		CActiveScheduler::Add(this);
+		ReStart();
+		}
+	return r;
+	}
+/**
+Adds the server with the specified name to the active scheduler,
+and issues the first request for messages, and leaves if the operation fails.
+If KNullDesC is specified for the name, then an anonymous server will be created.
+To create a session to such a server, the overload of RSessionBase::CreateSession()
+which takes an RServer2 object as a parameter can be used.
+@param aName The name of the server.
+KNullDesC, to create anonymous servers.
+@capability  ProtServ if aName starts with a '!' character
+*/
+EXPORT_C void CServer2::StartL(const TDesC& aName)
+	{
+	User::LeaveIfError(Start(aName));
+	}
+/**
+Implements the cancellation of any outstanding request for messages.
+*/
+EXPORT_C void CServer2::DoCancel()
+	{
+	iServer.Cancel();
+	}
+void CServer2::Connect(const RMessage2& aMessage)
+//
+// Handle a connect request. Ptr0()==Version.
+// NOTE: We don't want this to leave as that may kill the server
+//
+	{
+	if (aMessage.Session())
+		{
+		aMessage.Panic(KServerPanicCategory,ESessionAlreadyConnected);
+		return;
+		}
+	DoConnect(aMessage);
+	}
+//
+//This is all of the Leaving code for connection creation.
+//This is in a seperate function in an effort to force compilers to store aSession
+//on the stack which enables cleanup to perform correctly when a Leave occurs
+//
+void CServer2::DoConnectL(const RMessage2& aMessage,CSession2* volatile& aSession)
+	{
+	TVersion v;
+	*(TInt*)&v = aMessage.Int0();
+	aSession = NewSessionL(v, aMessage);
+	if (!aSession->iServer)
+		aSession->iServer = this;
+	aSession->CreateL();
+	iSessionQ.AddLast(*aSession);
+	Exec::SetSessionPtr(aMessage.Handle(), aSession);
+	}
+/**
+Handles the connect request from the client.  We trap Leaves, to ensure
+that existing sessions aren't affected by failure to create a new one.
+@param aMessage The Connect message sent by the client requesting the
+connection. aMessage.Ptr0() is the required Version.
+*/
+EXPORT_C void CServer2::DoConnect(const RMessage2& aMessage)
+	{
+	ASSERT(aMessage.Function() == RMessage2::EConnect);
+	ASSERT(aMessage.Session() == NULL);
+	ASSERT(!aMessage.IsNull());
+	CSession2* newSession = NULL;
+	TRAPD(err, DoConnectL(aMessage, newSession));
+	if (err != KErrNone)
+		{
+		// Connect failed
+		delete newSession;
+		aMessage.Complete(err);
+		}
+	else
+		{
+		ASSERT(newSession != NULL);
+		CServer2* sessionServer = const_cast<CServer2*>(newSession->Server());
+		ASSERT(sessionServer != NULL);
+		// The return value of Server() will be 'this', unless it was
+		// changed by a call to SetServer().
+		if (sessionServer == this)
+			{
+			// no SetServer() call, so just complete the Connect message
+			aMessage.Complete(err);
+			}
+		else
+			{
+			// Transfer the new Csession to the specified slave Cserver
+			newSession->iLink.Deque();
+			sessionServer->iSessionQ.AddLast(*newSession);
+			// Ask the kernel to transfer the DSession to the slave DServer.
+			// Note: this Exec call also completes the Connect message.
+			TInt msgHandle = aMessage.iHandle;
+			const_cast<TInt&>(aMessage.iHandle) = 0;
+			ASSERT(msgHandle);
+			Exec::TransferSession(msgHandle, sessionServer->Server().Handle());
+			}
+		}
+	ASSERT(aMessage.IsNull());
+	}
+/**
+Handles the situation where a call to CServer2::RunL(), leaves.
+This is the server active object's implementation of the active object
+framework's RunError() function.
+In practice, the leave can only be caused by a session's ServiceL() function,
+which is called from this RunL(); this error is reflected back to that session
+by calling its ServiceError() function.
+@param aError The leave code.
+@return KErrNone.
+@see CActive::RunL()
+@see CActive::RunError()
+@see CSession2::ServiceError()
+*/
+EXPORT_C TInt CServer2::RunError(TInt aError)
+	{
+	Message().Session()->ServiceError(Message(),aError);
+	if (!IsActive())
+		ReStart();
+	return KErrNone;
+	}
+/**
+Restarts the server.
+The function issues a request for messages.
+*/
+EXPORT_C void CServer2::ReStart()
+	{
+	iServer.Receive(iMessage,iStatus);
+	SetActive();
+	}
+#ifndef __CSERVER_MACHINE_CODED__
+/**
+Handles the receipt of a message.
+*/
+EXPORT_C void CServer2::RunL()
+	{
+	TInt fn = Message().Function();
+	if(fn>=0)
+		{
+		// Service the message
+		CSession2* session=Message().Session();
+		if(session)
+			session->ServiceL(Message());
+		else
+			NotConnected(Message());
+		}
+	else if(fn==RMessage2::EConnect)
+		{
+		Connect(Message());
+		}
+	else if(fn==RMessage2::EDisConnect)
+		{
+		Disconnect(Message());
+		}
+	else
+		{
+		BadMessage(Message());
+		}
+	// Queue reception of next message if it hasn't already been done
+	if(!IsActive())
+		ReStart();
+	}
+#endif
+void CServer2::Disconnect(const RMessage2& aMessage)
+//
+// Process a disconnect message
+//
+	{
+	CSession2* session=Message().Session();
+	if(!session)
+		{
+		// Session not created yet, so just complete message.
+		aMessage.Complete(0);
+		return;
+		}
+	session->Disconnect(aMessage);
+	}
+void CServer2::BadMessage(const RMessage2& aMessage)
+	{
+	aMessage.Panic(KServerPanicCategory,EBadMessageNumber);
+	}
+void CServer2::NotConnected(const RMessage2& aMessage)
+	{
+	aMessage.Panic(KServerPanicCategory,ESessionNotConnected);
+	}
+/**
+Extension function
+*/
+EXPORT_C TInt CServer2::Extension_(TUint aExtensionId, TAny*& a0, TAny* a1)
+	{
+	return CActive::Extension_(aExtensionId, a0, a1);
+	}