MCL/sf/os/kernelhwsrv: comparison kernel/eka/kernel/sproperty.cpp

equal deleted inserted replaced

-:bbf8bed59bcb
+:2bb754abd467
 inline DProcess* CurProcess()
 	{
 	return TheCurrentThread->iOwningProcess;
 	}
+// Used by a thread to schedule cancelation of Subscribe request in Supervisor thread.
+class TCancelQ: public SDblQueLink
+{
+public:
+TPropertySubsRequest* iPropSubRequest;//The request to be cancelled, can be NULL
+NFastSemaphore iFSemaphore;//Semafore to be signalled by Supervisor thread after the request is cancelled.
+};
 class TProperty
 	{
 public:
 	static TInt Init();
 		}
 	static void CompleteRequest(TPropertySubsRequest*, TInt aReason);
 	static void CompleteQue(SDblQue* aQue, TInt aReason);
 	static void CompleteDfc(TAny* aQue);
+	static void CompleteDfcByKErrPermissionDenied(TAny* aQue);
+	static void CompleteDfcByKErrNotFound(TAny* aQue);
+	static void CompleteCancellationQDfc(TAny* aQue);
 	static TUint Hash(TUint aCategory, TUint aKey);
 	static TProperty** Lookup(TUint aCategory, TUint aKey);
 	static TInt LookupOrCreate(TUint aCategory, TUint aKey, TProperty**);
 	TAny* operator new(TUint aSize) __NO_THROW
 		return DoCheckSetRights(aProcess);
 		}
 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
-	enum { KCompletionDfcPriority = 2 };
+	enum { KCancellationDfcPriority = 1, KCompletionDfcPriority = 2  };
 	static TDfc		CompletionDfc;
-	// subscriptions to be completed by the DFC
+	static TDfc		CompletionDfcPermissionDenied;
-	static SDblQue	CompletionQue;		// protected by the system lock
+	static TDfc		CompletionDfcNotFound;
+	static TDfc		CancellationDfc;
+	// subscriptions to be completed by the DFCs, protected by system lock
+	static SDblQue	CompletionQue; // to be completed by KerrNone
+	static SDblQue	CompletionQuePermissionDenied;
+	static SDblQue	CompletionQueNotFound;
+	static SDblQue	CancellationQue;
 	static DMutex*	FeatureLock;			///< Order KMutexOrdPubSub
 	// hash table collision lists
 	enum { KHashTableLimit = 32 };	// must be power of 2
 	SDblQue	iPendingQue;	// pending subscriptions - protected by the system lock
 	};
+// Completion/Cancelation DFCs and their corresponding queues.
+// All subscribe requests are completed in Supervisor thread.
 TDfc		TProperty::CompletionDfc(TProperty::CompleteDfc, &TProperty::CompletionQue, KCompletionDfcPriority);
 SDblQue		TProperty::CompletionQue;
+TDfc		TProperty::CompletionDfcPermissionDenied(TProperty::CompleteDfcByKErrPermissionDenied, &TProperty::CompletionQuePermissionDenied, KCompletionDfcPriority);
+SDblQue		TProperty::CompletionQuePermissionDenied;
+TDfc		TProperty::CompletionDfcNotFound(TProperty::CompleteDfcByKErrNotFound, &TProperty::CompletionQueNotFound, KCompletionDfcPriority);
+SDblQue		TProperty::CompletionQueNotFound;
+TDfc		TProperty::CancellationDfc(TProperty::CompleteCancellationQDfc, &TProperty::CancellationQue, KCancellationDfcPriority);
+SDblQue		TProperty::CancellationQue;
 DMutex*		TProperty::FeatureLock;
 TProperty*	TProperty::Table[KHashTableLimit];
 #ifdef __DEMAND_PAGING__
 DMutex*		TProperty::PagingLockMutex;
 	{ // static
 	TInt r = Kern::MutexCreate(FeatureLock, KPubSubMutexName, KMutexOrdPubSub);
 	if (r != KErrNone)
 		return r;
 	CompletionDfc.SetDfcQ(K::SvMsgQ);
+	CompletionDfcPermissionDenied.SetDfcQ(K::SvMsgQ);
+	CompletionDfcNotFound.SetDfcQ(K::SvMsgQ);
+	CancellationDfc.SetDfcQ(K::SvMsgQ);
 #ifdef __DEMAND_PAGING__
 	r = Kern::MutexCreate(PagingLockMutex, KPubSubMutexName2, KMutexOrdPubSub2);
 	if (r != KErrNone)
 		return r;
 	//	'localCompletionQue' for entries that will be completed
 	// We move entries one by one dropping and reacquiring the system lock on each
 	// iteration; we get (move) always the first 'iPendingQue' entry until the
 	// queue becomes empty.
 	//
-	SDblQue localPendingQue;	// protected by the system lock
-	SDblQue localCompletionQue;	// protected by the system lock
+	SDblQue localPendingQue;    // Will hold requests with sufficient capabilities.
+	TInt accessDeniedCounter = 0;// Will count requests with no sufficient capabilities.
 	NKern::LockSystem();
 	while (!iPendingQue.IsEmpty())
 		{
 		TPropertySubsRequest* subs = (TPropertySubsRequest*) iPendingQue.GetFirst();
 		DProcess* process = subs->iProcess;
 		subs->iProcess = NULL;
 		if (process && !CheckGetRights(process, __PLATSEC_DIAGNOSTIC_STRING("Checked whilst trying to Subscribe to a Publish and Subscribe Property")))
 			{ // Check fails - will complete the subscription with an error
-			localCompletionQue.Add(subs);
+			CompletionQuePermissionDenied.Add(subs);
+			accessDeniedCounter++;
 			}
 		else
 			{ // Check OK - will leave in the pending queue
 			localPendingQue.Add(subs);
 			}
 	iType = (TUint8) aInfo->iType;
 	NKern::UnlockSystem();
 	// Now the property can be accessed by other threads.
 	Use();
 	Unlock();
-	// Now we can complete requests.
-	CompleteQue(&localCompletionQue, KErrPermissionDenied);
+	// Schedule DFC to complete requests of those with insufficient capabilities.
+	if (accessDeniedCounter)
+		CompletionDfcPermissionDenied.Enque();
 	return KErrNone;
 	}
 // Called in CS
 TInt TProperty::Attach(TUint aCategory, TUint aKey, TProperty** aProp)
 	// Remember that iType is the tag of iBuf and iValue union
 	TBuf* buf = (iType != RProperty::EInt) ? iBuf : NULL;
 	SetNotDefined();
 	// Down from here nobody can access the property value
-	// We don't want to complete requests holding the feature lock.
+	// Move all pending requests to completion queue (to be completed by KErrNotFound).
-	SDblQue localQue;
+	TBool pendingQueEmpty = iPendingQue.IsEmpty();
-	localQue.MoveFrom(&iPendingQue);
+	if(!pendingQueEmpty)
+		CompletionQueNotFound.MoveFrom(&iPendingQue);
 	NKern::UnlockSystem();
 	iBuf = NULL;
 	iValue = 0;
 	delete buf;
 	Release();
 	// '*this' may do not exist any more
 	Unlock();
-	 // Now we can complete.
-	CompleteQue(&localQue, KErrNotFound);
+	 // Schedule Svc Dfc to complete all requests from CompletionQueNotFound.
+	if (!pendingQueEmpty)
+		CompletionDfcNotFound.Enque();
 	return KErrNone;
 	}
 // Enter feature locked.
 // Return feature locked.
 	if (defined)
 		{ // property is defined - check access now
 		aSubs->iProcess = NULL;
 		if (aProcess && !CheckGetRights(aProcess,__PLATSEC_DIAGNOSTIC_STRING("Checked whilst trying to Subscribe to a Publish and Subscribe Property")))
 			{
-			NKern::ThreadEnterCS();
+			CompletionQuePermissionDenied.Add(aSubs);
-			CompleteRequest(aSubs, KErrPermissionDenied);
+			CompletionDfcPermissionDenied.Enque(SYSTEM_LOCK);
-			NKern::ThreadLeaveCS();
 			return KErrNone;
 			}
 		}
 	else
 		{ // will check when defined
 // Enter system locked.
 // Return system unlocked.
 void TProperty::Cancel(TPropertySubsRequest* aSubs)
 	{
 	__ASSERT_SYSTEM_LOCK;
-	if (!aSubs->iNext)
-		{ // not pending - silently return
+	// This is set if the request is about to be completed (in SVC thread). In that case, a 'dummy' CancelationDFC
-		NKern::UnlockSystem();
+	// will be scheduled here. This will just ensure that we don't return from Cancel before ongoing completion has finished.
+	TBool scheduledForCompletition = (TInt)(aSubs->iProcess) & TPropertySubsRequest::KScheduledForCompletion;
+	if (!aSubs->iNext && !scheduledForCompletition)
+		{ // Neither in any queue nor scheduled for completion.
+		  // The request is not active - silently return.
+		NKern::UnlockSystem();
 		return;
 		}
-	aSubs->Deque();
-	aSubs->iNext = NULL;
+	if (aSubs->iNext)
-	aSubs->iProcess = NULL;
+		{
-	NKern::ThreadEnterCS();
+		// Take it out from the current queue. It is usually pending queue of a property but could
-	CompleteRequest(aSubs, KErrCancel);
+		// also be one of the completion queues.
-	NKern::ThreadLeaveCS();
+		aSubs->Deque();
+		aSubs->iNext = NULL;
+		}
+	// Set process to NULL (leave KScheduledForCompletion bit as it is)
+	aSubs->iProcess = (DProcess*)((TInt)aSubs->iProcess & ~TPropertySubsRequest::KProcessPtrMask);
+	if (&Kern::CurrentThread() == K::SvThread)
+		{   // Complete the request immediatelly if already running in supervisor thread...
+		if (!scheduledForCompletition)
+			CompleteRequest(aSubs, KErrCancel); //This will also release system lock.
+		else
+			NKern::UnlockSystem();              // Nothing to be done here. Just release system lock.
+		}
+	else
+		{   //... or schedule DFC in supervisor thread to complete the request.
+		TCancelQ linkQ;
+		if (!scheduledForCompletition)
+			linkQ.iPropSubRequest = aSubs;      // CancelationDFC will complete this request with KErrCancel.
+		else
+			linkQ.iPropSubRequest = NULL;       // Schedule 'dummy' CancelationDFC (no request will be completed).
+		linkQ.iFSemaphore.iOwningThread = NKern::CurrentThread();
+		CancellationQue.Add(&linkQ);
+		CancellationDfc.Enque(SYSTEM_LOCK);     // This will also release system lock.
+		NKern::FSWait(&linkQ.iFSemaphore);      // Wait for CancellationDfc to finish.
+		}
 	}
 // Enter system locked.
 // Return system unlocked.
-// Called in CS or a DFC context
+// Executed in supervisor thread.
 void TProperty::CompleteRequest(TPropertySubsRequest* aSubs, TInt aResult)
 	{ // static
 	__ASSERT_SYSTEM_LOCK;
-	__ASSERT_CRITICAL;
+	__PS_ASSERT(&Kern::CurrentThread() == K::SvThread);
 	TPropertyCompleteFn	fn = aSubs->iCompleteFn;
 	TAny* ptr = aSubs->iPtr;
+	// Mark that this request is about to be completed.
+	aSubs->iProcess = (DProcess*)((TInt)aSubs->iProcess | TPropertySubsRequest::KScheduledForCompletion);
 	NKern::UnlockSystem();
 	(*fn)(ptr, aResult);
 	}
-// Called in CS or a DFC context
+// Executed in supervisor thread.
 void TProperty::CompleteQue(SDblQue* aQue, TInt aReason)
 	{ // static
-	__ASSERT_CRITICAL;
+	__PS_ASSERT(&Kern::CurrentThread() == K::SvThread);
 	NKern::LockSystem();
 	while (!aQue->IsEmpty())
 		{
 		TPropertySubsRequest* subs = (TPropertySubsRequest*) aQue->First();
 		subs->Deque();
 		NKern::LockSystem();
 		}
 	NKern::UnlockSystem();
 	}
-// Executed in DFC context
+// Executed in supervisor thread. Completes requests with KErrNone.
 void TProperty::CompleteDfc(TAny* aQue)
 	{ // static
 	CompleteQue((SDblQue*) aQue, KErrNone);
+	}
+// Executed in supervisor thread.
+void TProperty::CompleteDfcByKErrPermissionDenied(TAny* aQue)
+	{ // static
+	CompleteQue((SDblQue*) aQue, KErrPermissionDenied);
+	}
+// Executed in supervisor thread.
+void TProperty::CompleteDfcByKErrNotFound(TAny* aQue)
+	{ // static
+	CompleteQue((SDblQue*) aQue, KErrNotFound);
+	}
+// Executed in supervisor thread.
+void TProperty::CompleteCancellationQDfc(TAny* aAny)
+	{ // static
+	SDblQue* aQue = (SDblQue*)aAny;
+	NKern::LockSystem();
+	while (!aQue->IsEmpty() )
+		{
+TCancelQ* first = static_cast<TCancelQ*>(aQue->First());
+first->Deque();
+first->iNext = NULL;
+if( first->iPropSubRequest)
+	{
+CompleteRequest(first->iPropSubRequest, KErrCancel); // This will also release system lock.
+NKern::LockSystem();
+	}
+else
+	{
+	// Do not complete the request.
+	// It was already just about to be completed when Cancel request was issued.
+			// As all complitions (this method included) run is Svc thread, we can here be sure that
+			// the request is now completed.
+			NKern::FlashSystem();	// Preemption point
+	}
+NKern::FSSignal( &first->iFSemaphore ); // Issue the signal that the request is now completed.
+}
+NKern::UnlockSystem();
 	}
 // Enter system locked.
 // Return system unlocked.
 void TProperty::CompleteByDfc()
 		{
 		NKern::UnlockSystem();
 		return KErrArgument;
 		}
 	iValue = aValue;
-	CompleteByDfc();
+	CompleteByDfc(); //This will also release system lock.
 	return KErrNone;
 	}
 #ifdef __EPOC32__

branch	RCL_3
changeset 39	2bb754abd467
parent 0	a41df078684a