1 // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32\nkern\nkern.cpp

    15 // 

    16 //

    17 

    18 // NThreadBase member data

    19 #define __INCLUDE_NTHREADBASE_DEFINES__

    20 

    21 #include "nk_priv.h"

    22 

    23 /******************************************************************************

    24  * Fast mutex

    25  ******************************************************************************/

    26 

    27 /** Checks if the current thread holds this fast mutex

    28 

    29 	@return TRUE if the current thread holds this fast mutex

    30 	@return FALSE if not

    31 */

    32 EXPORT_C TBool NFastMutex::HeldByCurrentThread()

    33 	{

    34 	return iHoldingThread == NCurrentThread();

    35 	}

    36 

    37 /** Find the fast mutex held by the current thread

    38 

    39 	@return a pointer to the fast mutex held by the current thread

    40 	@return NULL if the current thread does not hold a fast mutex

    41 */

    42 EXPORT_C NFastMutex* NKern::HeldFastMutex()

    43 	{

    44 	return TheScheduler.iCurrentThread->iHeldFastMutex;

    45 	}

    46 

    47 

    48 #ifndef __FAST_MUTEX_MACHINE_CODED__

    49 /** Acquires the fast mutex.

    50 

    51     This will block until the mutex is available, and causes

    52 	the thread to enter an implicit critical section until the mutex is released.

    53 

    54 	Generally threads would use NKern::FMWait() which manipulates the kernel lock

    55 	for you.

    56 	

    57 	@pre Kernel must be locked, with lock count 1.

    58 	@pre The calling thread holds no fast mutexes.

    59 	

    60 	@post Kernel is locked, with lock count 1.

    61 	@post The calling thread holds the mutex.

    62 	

    63 	@see NFastMutex::Signal()

    64 	@see NKern::FMWait()

    65 */

    66 EXPORT_C void NFastMutex::Wait()

    67 	{

    68 	__KTRACE_OPT(KNKERN,DEBUGPRINT("FMWait %M",this));

    69 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED_ONCE|MASK_NO_FAST_MUTEX,"NFastMutex::Wait");			

    70 	NThreadBase* pC=TheScheduler.iCurrentThread;

    71 	if (iHoldingThread)

    72 		{

    73 		iWaiting=1;

    74 		pC->iWaitFastMutex=this;

    75 		__KTRACE_OPT(KNKERN,DEBUGPRINT("FMWait: YieldTo %T",iHoldingThread));

    76 		TheScheduler.YieldTo(iHoldingThread);	// returns with kernel unlocked, interrupts disabled

    77 		TheScheduler.iKernCSLocked = 1;	// relock kernel

    78 		NKern::EnableAllInterrupts();

    79 		pC->iWaitFastMutex=NULL;

    80 		}

    81 	pC->iHeldFastMutex=this;		// automatically puts thread into critical section

    82 #ifdef BTRACE_FAST_MUTEX

    83 	BTraceContext4(BTrace::EFastMutex,BTrace::EFastMutexWait,this);

    84 #endif

    85 	iHoldingThread=pC;

    86 	}

    87 

    88 

    89 /** Releases a previously acquired fast mutex.

    90 	

    91 	Generally, threads would use NKern::FMSignal() which manipulates the kernel lock

    92 	for you.

    93 	

    94 	@pre The calling thread holds the mutex.

    95 	@pre Kernel must be locked.

    96 	

    97 	@post Kernel is locked.

    98 	

    99 	@see NFastMutex::Wait()

   100 	@see NKern::FMSignal()

   101 */

   102 EXPORT_C void NFastMutex::Signal()

   103 	{

   104 	__KTRACE_OPT(KNKERN,DEBUGPRINT("FMSignal %M",this));

   105 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED,"NFastMutex::Signal");			

   106 	NThreadBase* pC=TheScheduler.iCurrentThread;

   107 	__ASSERT_WITH_MESSAGE_DEBUG(pC->iHeldFastMutex==this,"The calling thread holds the mutex","NFastMutex::Signal");

   108 #ifdef BTRACE_FAST_MUTEX

   109 	BTraceContext4(BTrace::EFastMutex,BTrace::EFastMutexSignal,this);

   110 #endif

   111 	iHoldingThread=NULL;

   112 	pC->iHeldFastMutex=NULL;

   113 	TBool w=iWaiting;

   114 	iWaiting=0;

   115 	if (w)

   116 		{

   117 		RescheduleNeeded();

   118 		if (pC->iCsFunction && !pC->iCsCount)

   119 			pC->DoCsFunction();

   120 		}

   121 	}

   122 

   123 

   124 /** Acquires a fast mutex.

   125 

   126     This will block until the mutex is available, and causes

   127 	the thread to enter an implicit critical section until the mutex is released.

   128 

   129 	@param aMutex The fast mutex to acquire.

   130 	

   131 	@post The calling thread holds the mutex.

   132 	

   133 	@see NFastMutex::Wait()

   134 	@see NKern::FMSignal()

   135 

   136 	@pre No fast mutex can be held.

   137 	@pre Call in a thread context.

   138 	@pre Kernel must be unlocked

   139 	@pre interrupts enabled

   140 

   141 */

   142 EXPORT_C void NKern::FMWait(NFastMutex* aMutex)

   143 	{

   144 	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"NKern::FMWait");

   145 	NKern::Lock();

   146 	aMutex->Wait();

   147 	NKern::Unlock();

   148 	}

   149 

   150 

   151 /** Releases a previously acquired fast mutex.

   152 	

   153 	@param aMutex The fast mutex to release.

   154 	

   155 	@pre The calling thread holds the mutex.

   156 	

   157 	@see NFastMutex::Signal()

   158 	@see NKern::FMWait()

   159 */

   160 EXPORT_C void NKern::FMSignal(NFastMutex* aMutex)

   161 	{

   162 	NKern::Lock();

   163 	aMutex->Signal();

   164 	NKern::Unlock();

   165 	}

   166 

   167 

   168 /** Acquires the System Lock.

   169 

   170     This will block until the mutex is available, and causes

   171 	the thread to enter an implicit critical section until the mutex is released.

   172 

   173 	@post System lock is held.

   174 

   175 	@see NKern::UnlockSystem()

   176 	@see NKern::FMWait()

   177 

   178 	@pre No fast mutex can be held.

   179 	@pre Call in a thread context.

   180 	@pre Kernel must be unlocked

   181 	@pre interrupts enabled

   182 */

   183 EXPORT_C void NKern::LockSystem()

   184 	{

   185 	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"NKern::LockSystem");

   186 	NKern::Lock();

   187 	TheScheduler.iLock.Wait();

   188 	NKern::Unlock();

   189 	}

   190 

   191 

   192 /** Releases the System Lock.

   193 

   194 	@pre System lock must be held.

   195 

   196 	@see NKern::LockSystem()

   197 	@see NKern::FMSignal()

   198 */

   199 EXPORT_C void NKern::UnlockSystem()

   200 	{

   201 	NKern::Lock();

   202 	TheScheduler.iLock.Signal();

   203 	NKern::Unlock();

   204 	}

   205 

   206 

   207 /** Temporarily releases a fast mutex if there is contention.

   208 

   209     If there is another thread attempting to acquire the mutex, the calling

   210 	thread releases the mutex and then acquires it again.

   211 	

   212 	This is more efficient than the equivalent code:

   213 	

   214 	@code

   215 	NKern::FMSignal();

   216 	NKern::FMWait();

   217 	@endcode

   218 

   219 	@return	TRUE if the mutex was relinquished, FALSE if not.

   220 

   221 	@pre	The mutex must be held.

   222 

   223 	@post	The mutex is held.

   224 */

   225 EXPORT_C TBool NKern::FMFlash(NFastMutex* aM)

   226 	{

   227 	__ASSERT_WITH_MESSAGE_DEBUG(aM->HeldByCurrentThread(),"The calling thread holds the mutex","NKern::FMFlash");

   228 	TBool w = aM->iWaiting;

   229 	if (w)

   230 		{

   231 		NKern::Lock();

   232 		aM->Signal();

   233 		NKern::PreemptionPoint();

   234 		aM->Wait();

   235 		NKern::Unlock();

   236 		}

   237 #ifdef BTRACE_FAST_MUTEX

   238 	else

   239 		{

   240 		BTraceContext4(BTrace::EFastMutex,BTrace::EFastMutexFlash,aM);

   241 		}

   242 #endif

   243 	return w;

   244 	}

   245 

   246 

   247 /** Temporarily releases the System Lock if there is contention.

   248 

   249     If there

   250 	is another thread attempting to acquire the System lock, the calling

   251 	thread releases the mutex and then acquires it again.

   252 	

   253 	This is more efficient than the equivalent code:

   254 	

   255 	@code

   256 	NKern::UnlockSystem();

   257 	NKern::LockSystem();

   258 	@endcode

   259 

   260 	Note that this can only allow higher priority threads to use the System

   261 	lock as lower priority cannot cause contention on a fast mutex.

   262 

   263 	@return	TRUE if the system lock was relinquished, FALSE if not.

   264 

   265 	@pre	System lock must be held.

   266 

   267 	@post	System lock is held.

   268 

   269 	@see NKern::LockSystem()

   270 	@see NKern::UnlockSystem()

   271 */

   272 EXPORT_C TBool NKern::FlashSystem()

   273 	{

   274 	return NKern::FMFlash(&TheScheduler.iLock);

   275 	}

   276 #endif

   277 

   278 

   279 /******************************************************************************

   280  * Fast semaphore

   281  ******************************************************************************/

   282 

   283 /** Sets the owner of a fast semaphore.

   284 

   285 	@param aThread The thread to own this semaphore. If aThread==0, then the

   286 					owner is set to the current thread.

   287 

   288 	@pre Kernel must be locked.

   289 	@pre If changing ownership form one thread to another, the there must be no

   290 		 pending signals or waits.

   291 	@pre Call either in a thread or an IDFC context.

   292 	

   293 	@post Kernel is locked.

   294 */

   295 EXPORT_C void NFastSemaphore::SetOwner(NThreadBase* aThread)

   296 	{

   297 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NFastSemaphore::SetOwner");		

   298 	if(!aThread)

   299 		aThread = TheScheduler.iCurrentThread;

   300 	if(iOwningThread && iOwningThread!=aThread)

   301 		{

   302 		__NK_ASSERT_ALWAYS(!iCount);	// Can't change owner if iCount!=0

   303 		}

   304 	iOwningThread = aThread;

   305 	}

   306 

   307 

   308 #ifndef __FAST_SEM_MACHINE_CODED__

   309 /** Waits on a fast semaphore.

   310 

   311     Decrements the signal count for the semaphore and

   312 	removes the calling thread from the ready-list if the sempahore becomes

   313 	unsignalled. Only the thread that owns a fast semaphore can wait on it.

   314 	

   315 	Note that this function does not block, it merely updates the NThread state,

   316 	rescheduling will only occur when the kernel is unlocked. Generally threads

   317 	would use NKern::FSWait() which manipulates the kernel lock for you.

   318 

   319 	@pre The calling thread must own the semaphore.

   320 	@pre No fast mutex can be held.

   321 	@pre Kernel must be locked.

   322 	

   323 	@post Kernel is locked.

   324 	

   325 	@see NFastSemaphore::Signal()

   326 	@see NKern::FSWait()

   327 	@see NKern::Unlock()

   328  */

   329 EXPORT_C void NFastSemaphore::Wait()

   330 	{

   331 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NO_FAST_MUTEX,"NFastSemaphore::Wait");		

   332 	NThreadBase* pC=TheScheduler.iCurrentThread;

   333 	__ASSERT_WITH_MESSAGE_ALWAYS(pC==iOwningThread,"The calling thread must own the semaphore","NFastSemaphore::Wait");

   334 	if (--iCount<0)

   335 		{

   336 		pC->iNState=NThread::EWaitFastSemaphore;

   337 		pC->iWaitObj=this;

   338 		TheScheduler.Remove(pC);

   339 		RescheduleNeeded();

   340 		}

   341 	}

   342 

   343 

   344 /** Signals a fast semaphore.

   345 

   346     Increments the signal count of a fast semaphore by

   347 	one and releases any waiting thread if the semphore becomes signalled.

   348 	

   349 	Note that a reschedule will not occur before this function returns, this will

   350 	only take place when the kernel is unlocked. Generally threads

   351 	would use NKern::FSSignal() which manipulates the kernel lock for you.

   352 	

   353 	@pre Kernel must be locked.

   354 	@pre Call either in a thread or an IDFC context.

   355 	

   356 	@post Kernel is locked.

   357 	

   358 	@see NFastSemaphore::Wait()

   359 	@see NKern::FSSignal()

   360 	@see NKern::Unlock()

   361  */

   362 EXPORT_C void NFastSemaphore::Signal()

   363 	{

   364 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NFastSemaphore::Signal");			

   365 	if (++iCount<=0)

   366 		{

   367 		iOwningThread->iWaitObj=NULL;

   368 		iOwningThread->CheckSuspendThenReady();

   369 		}

   370 	}

   371 

   372 

   373 /** Signals a fast semaphore multiple times.

   374 

   375 	@pre Kernel must be locked.

   376 	@pre Call either in a thread or an IDFC context.

   377 	

   378 	@post Kernel is locked.

   379 

   380 	@internalComponent	

   381  */

   382 EXPORT_C void NFastSemaphore::SignalN(TInt aCount)

   383 	{

   384 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NFastSemaphore::SignalN");			

   385 	__NK_ASSERT_DEBUG(aCount>=0);

   386 	if (aCount>0 && iCount<0)

   387 		{

   388 		iOwningThread->iWaitObj=NULL;

   389 		iOwningThread->CheckSuspendThenReady();

   390 		}

   391 	iCount+=aCount;

   392 	}

   393 

   394 

   395 /** Resets a fast semaphore.

   396 

   397 	@pre Kernel must be locked.

   398 	@pre Call either in a thread or an IDFC context.

   399 	

   400 	@post Kernel is locked.

   401 

   402 	@internalComponent	

   403  */

   404 EXPORT_C void NFastSemaphore::Reset()

   405 	{

   406 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NFastSemaphore::Reset");			

   407 	if (iCount<0)

   408 		{

   409 		iOwningThread->iWaitObj=NULL;

   410 		iOwningThread->CheckSuspendThenReady();

   411 		}

   412 	iCount=0;

   413 	}

   414 

   415 

   416 /** Cancels a wait on a fast semaphore.

   417 

   418 	@pre Kernel must be locked.

   419 	@pre Call either in a thread or an IDFC context.

   420 	

   421 	@post Kernel is locked.

   422 

   423 	@internalComponent	

   424  */

   425 void NFastSemaphore::WaitCancel()

   426 	{

   427 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NFastSemaphore::WaitCancel");			

   428 	iCount=0;

   429 	iOwningThread->iWaitObj=NULL;

   430 	iOwningThread->CheckSuspendThenReady();

   431 	}

   432 

   433 

   434 /** Waits for a signal on the current thread's I/O semaphore.

   435 

   436 	@pre No fast mutex can be held.

   437 	@pre Call in a thread context.

   438 	@pre Kernel must be unlocked

   439 	@pre interrupts enabled

   440  */

   441 EXPORT_C void NKern::WaitForAnyRequest()

   442 	{

   443 	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"NKern::WaitForAnyRequest");

   444 	__KTRACE_OPT(KNKERN,DEBUGPRINT("WfAR"));

   445 	NThreadBase* pC=TheScheduler.iCurrentThread;

   446 	NKern::Lock();

   447 	pC->iRequestSemaphore.Wait();

   448 	NKern::Unlock();

   449 	}

   450 #endif

   451 

   452 

   453 /** Sets the owner of a fast semaphore.

   454 

   455 	@param aSem The semaphore to change ownership off.

   456 	@param aThread The thread to own this semaphore. If aThread==0, then the

   457 					owner is set to the current thread.

   458 

   459 	@pre If changing ownership form one thread to another, the there must be no

   460 		 pending signals or waits.

   461 */

   462 EXPORT_C void NKern::FSSetOwner(NFastSemaphore* aSem,NThreadBase* aThread)

   463 	{

   464 	__KTRACE_OPT(KNKERN,DEBUGPRINT("NKern::FSSetOwner %m %T",aSem,aThread));

   465 	NKern::Lock();

   466 	aSem->SetOwner(aThread);

   467 	NKern::Unlock();

   468 	}

   469 

   470 /** Waits on a fast semaphore.

   471 

   472     Decrements the signal count for the semaphore

   473 	and waits for a signal if the sempahore becomes unsignalled. Only the

   474 	thread that owns a fast	semaphore can wait on it.

   475 

   476 	@param aSem The semaphore to wait on.

   477 	

   478 	@pre The calling thread must own the semaphore.

   479 	@pre No fast mutex can be held.

   480 	

   481 	@see NFastSemaphore::Wait()

   482 */

   483 EXPORT_C void NKern::FSWait(NFastSemaphore* aSem)

   484 	{

   485 	__KTRACE_OPT(KNKERN,DEBUGPRINT("NKern::FSWait %m",aSem));

   486 	NKern::Lock();

   487 	aSem->Wait();

   488 	NKern::Unlock();

   489 	}

   490 

   491 

   492 /** Signals a fast semaphore.

   493 

   494     Increments the signal count of a fast semaphore

   495 	by one and releases any	waiting thread if the semphore becomes signalled.

   496 	

   497 	@param aSem The semaphore to signal.

   498 

   499 	@see NKern::FSWait()

   500 

   501 	@pre Interrupts must be enabled.

   502 	@pre Do not call from an ISR

   503  */

   504 EXPORT_C void NKern::FSSignal(NFastSemaphore* aSem)

   505 	{

   506 	CHECK_PRECONDITIONS(MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR,"NKern::FSSignal(NFastSemaphore*)");

   507 	__KTRACE_OPT(KNKERN,DEBUGPRINT("NKern::FSSignal %m",aSem));

   508 	NKern::Lock();

   509 	aSem->Signal();

   510 	NKern::Unlock();

   511 	}

   512 

   513 

   514 /** Atomically signals a fast semaphore and releases a fast mutex.

   515 

   516 	Rescheduling only occurs after both synchronisation operations are complete.

   517 	

   518 	@param aSem The semaphore to signal.

   519 	@param aMutex The mutex to release. If NULL, the System Lock is released

   520 

   521 	@pre The calling thread must hold the mutex.

   522 	

   523 	@see NKern::FMSignal()

   524  */

   525 EXPORT_C void NKern::FSSignal(NFastSemaphore* aSem, NFastMutex* aMutex)

   526 	{

   527 	if (!aMutex)

   528 		aMutex=&TheScheduler.iLock;

   529 	__KTRACE_OPT(KNKERN,DEBUGPRINT("NKern::FSSignal %m +FM %M",aSem,aMutex));

   530 	NKern::Lock();

   531 	aSem->Signal();

   532 	aMutex->Signal();

   533 	NKern::Unlock();

   534 	}

   535 

   536 

   537 /** Signals a fast semaphore multiple times.

   538 

   539     Increments the signal count of a

   540 	fast semaphore by aCount and releases any waiting thread if the semphore

   541 	becomes signalled.

   542 	

   543 	@param aSem The semaphore to signal.

   544 	@param aCount The number of times to signal the semaphore.

   545 

   546 	@see NKern::FSWait()

   547 

   548 	@pre Interrupts must be enabled.

   549 	@pre Do not call from an ISR

   550  */

   551 EXPORT_C void NKern::FSSignalN(NFastSemaphore* aSem, TInt aCount)

   552 	{

   553 	CHECK_PRECONDITIONS(MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR,"NKern::FSSignalN(NFastSemaphore*, TInt)");

   554 	__KTRACE_OPT(KNKERN,DEBUGPRINT("NKern::FSSignalN %m %d",aSem,aCount));

   555 	NKern::Lock();

   556 	aSem->SignalN(aCount);

   557 	NKern::Unlock();

   558 	}

   559 

   560 

   561 /** Atomically signals a fast semaphore multiple times and releases a fast mutex.

   562 

   563 	Rescheduling only occurs after both synchronisation operations are complete.

   564 	

   565 	@param aSem The semaphore to signal.

   566 	@param aCount The number of times to signal the semaphore.

   567 	@param aMutex The mutex to release. If NULL, the System Lock is released.

   568 

   569 	@pre The calling thread must hold the mutex.

   570 	

   571 	@see NKern::FMSignal()

   572  */

   573 EXPORT_C void NKern::FSSignalN(NFastSemaphore* aSem, TInt aCount, NFastMutex* aMutex)

   574 	{

   575 	if (!aMutex)

   576 		aMutex=&TheScheduler.iLock;

   577 	__KTRACE_OPT(KNKERN,DEBUGPRINT("NKern::FSSignalN %m %d + FM %M",aSem,aCount,aMutex));

   578 	NKern::Lock();

   579 	aSem->SignalN(aCount);

   580 	aMutex->Signal();

   581 	NKern::Unlock();

   582 	}

   583 

   584 

   585 /******************************************************************************

   586  * Thread

   587  ******************************************************************************/

   588 

   589 #ifndef __SCHEDULER_MACHINE_CODED__

   590 /** Makes a nanothread ready provided that it is not explicitly suspended.

   591 	

   592 	For use by RTOS personality layers.

   593 

   594 	@pre	Kernel must be locked.

   595 	@pre	Call either in a thread or an IDFC context.

   596 

   597 	@post	Kernel is locked.

   598  */

   599 EXPORT_C void NThreadBase::CheckSuspendThenReady()

   600 	{

   601 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NThreadBase::CheckSuspendThenReady");	

   602 	if (iSuspendCount==0)

   603 		Ready();

   604 	else

   605 		iNState=ESuspended;

   606 	}

   607 

   608 /** Makes a nanothread ready.

   609 	

   610 	For use by RTOS personality layers.

   611 

   612 	@pre	Kernel must be locked.

   613 	@pre	Call either in a thread or an IDFC context.

   614 	@pre	The thread being made ready must not be explicitly suspended

   615 	

   616 	@post	Kernel is locked.

   617  */

   618 EXPORT_C void NThreadBase::Ready()

   619 	{

   620 #ifdef _DEBUG

   621 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NThreadBase::Ready");	

   622 	__ASSERT_WITH_MESSAGE_DEBUG(iSuspendCount==0,"The thread being made ready must not be explicitly suspended","NThreadBase::Ready");

   623 

   624 	if (DEBUGNUM(KCRAZYSCHEDDELAY) && iPriority && TheTimerQ.iMsCount)

   625 		{

   626 		// Delay this thread, unless it's already on the delayed queue

   627 		if ((i_ThrdAttr & KThreadAttDelayed) == 0)

   628 			{

   629 			i_ThrdAttr |= KThreadAttDelayed;

   630 			TheScheduler.iDelayedQ.Add(this);

   631 			}

   632 		}

   633 	else

   634 		{

   635 		// Delayed scheduler off

   636 		// or idle thread, or the tick hasn't started yet

   637 		DoReady();

   638 		}

   639 #else

   640 	DoReady();

   641 #endif

   642 	}

   643 

   644 void NThreadBase::DoReady()

   645 	{

   646 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NThreadBase::DoReady");	

   647 	__ASSERT_WITH_MESSAGE_DEBUG(iSuspendCount==0,"The thread being made ready must not be explicitly suspended","NThreadBase::DoReady");

   648 

   649 	TScheduler& s=TheScheduler;

   650 	TInt p=iPriority;

   651 //	__KTRACE_OPT(KSCHED,Kern::Printf("Ready(%O), priority %d status %d",this,p,iStatus));

   652 	if (iNState==EDead)

   653 		return;

   654 	s.Add(this);

   655 	iNState=EReady;

   656 	if (!(s>p))	// s>p <=> highest ready priority > our priority so no preemption

   657 		{

   658 		// if no other thread at this priority or first thread at this priority has used its timeslice, reschedule

   659 		// note iNext points to first thread at this priority since we got added to the end

   660 		if (iNext==this || ((NThreadBase*)iNext)->iTime==0)

   661 			RescheduleNeeded();

   662 		}

   663 	}

   664 #endif

   665 

   666 void NThreadBase::DoCsFunction()

   667 	{

   668 	__KTRACE_OPT(KNKERN,DEBUGPRINT("NThreadBase::DoCsFunction %T %d",this,iCsFunction));

   669 	TInt f=iCsFunction;

   670 	iCsFunction=0;

   671 	if (f>0)

   672 		{

   673 		// suspend this thread f times

   674 		Suspend(f);

   675 		return;

   676 		}

   677 	if (f==ECSExitPending)

   678 		{

   679 		// We need to exit now

   680 		Exit();	// this won't return

   681 		}

   682 	UnknownState(ELeaveCS,f);	// call into RTOS personality

   683 	}

   684 

   685 

   686 /** Suspends a nanothread the specified number of times.

   687 	

   688 	For use by RTOS personality layers.

   689 	Do not use this function directly on a Symbian OS thread.

   690 	Since the kernel is locked on entry, any reschedule will be deferred until

   691 	it is unlocked.

   692 	The suspension will be deferred if the target thread is currently in a

   693 	critical section; in this case the suspension will take effect when it exits

   694 	the critical section.

   695 	The thread's unknown state handler will be invoked with function ESuspend and

   696 	parameter aCount if the current NState is not recognised and it is not in a

   697 	critical section.

   698 

   699 	@param	aCount = the number of times to suspend.

   700 	@return	TRUE, if the suspension has taken immediate effect;

   701 			FALSE, if the thread is in a critical section or is already suspended.

   702 	

   703 	@pre	Kernel must be locked.

   704 	@pre	Call in a thread context.

   705 	

   706 	@post	Kernel is locked.

   707  */

   708 EXPORT_C TBool NThreadBase::Suspend(TInt aCount)

   709 	{

   710 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR|MASK_NOT_IDFC,"NThreadBase::Suspend");		

   711 	// If thread is executing a critical section, we must defer the suspend

   712 	if (iNState==EDead)

   713 		return FALSE;		// already dead so suspension is a no-op

   714 	if (iCsCount || iHeldFastMutex)

   715 		{

   716 		__KTRACE_OPT(KNKERN,DEBUGPRINT("NThreadBase::Suspend %T (CSF %d) %d",this,iCsFunction,aCount));

   717 		if (iCsFunction>=0)			// -ve means thread is about to exit

   718 			{

   719 			iCsFunction+=aCount;	// so thread will suspend itself when it leaves the critical section

   720 			if (iHeldFastMutex && iCsCount==0)

   721 				iHeldFastMutex->iWaiting=1;

   722 			}

   723 		return FALSE;

   724 		}

   725 

   726 	// thread not in critical section, so suspend it

   727 	__KTRACE_OPT(KNKERN,DEBUGPRINT("NThreadBase::Suspend %T (NState %d) %d",this,iNState,aCount));

   728 	switch (iNState)

   729 		{

   730 		case EReady:

   731 			TheScheduler.Remove(this);

   732 			RescheduleNeeded();

   733 			iNState=ESuspended;

   734 		case EWaitFastSemaphore:

   735 		case EWaitDfc:

   736 		case ESleep:

   737 		case EBlocked:

   738 		case ESuspended:

   739 			break;

   740 		default:

   741 			UnknownState(ESuspend,aCount);

   742 			break;

   743 		}

   744 	TInt old_suspend=iSuspendCount;

   745 	iSuspendCount-=aCount;

   746 	return (old_suspend==0);	// return TRUE if thread has changed from not-suspended to suspended.

   747 	}

   748 

   749 

   750 /** Resumes a nanothread, cancelling one suspension.

   751 	

   752 	For use by RTOS personality layers.

   753 	Do not use this function directly on a Symbian OS thread.

   754 	Since the kernel is locked on entry, any reschedule will be deferred until

   755 	it is unlocked.

   756 	If the target thread is currently in a critical section this will simply

   757 	cancel one deferred suspension.

   758 	The thread's unknown state handler will be invoked with function EResume if

   759 	the current NState is not recognised and it is not in a	critical section.

   760 

   761 	@return	TRUE, if the resumption has taken immediate effect;

   762 			FALSE, if the thread is in a critical section or is still suspended.

   763 	

   764 	@pre	Kernel must be locked.

   765 	@pre	Call either in a thread or an IDFC context.

   766 	

   767 	@post	Kernel must be locked.

   768  */

   769 EXPORT_C TBool NThreadBase::Resume()

   770 	{

   771 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR|MASK_NOT_IDFC,"NThreadBase::Resume");		

   772 	__KTRACE_OPT(KNKERN,DEBUGPRINT("NThreadBase::Resume %T, state %d CSC %d CSF %d",this,iNState,iCsCount,iCsFunction));

   773 	if (iNState==EDead)

   774 		return FALSE;

   775 

   776 	// If thread is in critical section, just cancel deferred suspends

   777 	if (iCsCount || iHeldFastMutex)

   778 		{

   779 		if (iCsFunction>0)

   780 			--iCsFunction;	// one less deferred suspension

   781 		return FALSE;

   782 		}

   783 	if (iSuspendCount<0 && ++iSuspendCount==0)

   784 		{

   785 		switch (iNState)

   786 			{

   787 			case ESuspended:

   788 				Ready();

   789 			case EReady:

   790 			case EWaitFastSemaphore:

   791 			case EWaitDfc:

   792 			case ESleep:

   793 			case EBlocked:

   794 				break;

   795 			default:

   796 				UnknownState(EResume,0);

   797 				break;

   798 			}

   799 		return TRUE;	// thread has changed from suspended to not-suspended

   800 		}

   801 	return FALSE;	// still suspended or not initially suspended so no higher level action required

   802 	}

   803 

   804 

   805 /** Resumes a nanothread, cancelling all outstanding suspensions.

   806 	

   807 	For use by RTOS personality layers.

   808 	Do not use this function directly on a Symbian OS thread.

   809 	Since the kernel is locked on entry, any reschedule will be deferred until

   810 	it is unlocked.

   811 	If the target thread is currently in a critical section this will simply

   812 	cancel all deferred suspensions.

   813 	The thread's unknown state handler will be invoked with function EForceResume

   814 	if the current NState is not recognised and it is not in a	critical section.

   815 

   816 	@return	TRUE, if the resumption has taken immediate effect;

   817 			FALSE, if the thread is in a critical section.

   818 

   819 	@pre	Kernel must be locked.

   820 	@pre	Call either in a thread or an IDFC context.

   821 

   822 	@post	Kernel is locked.

   823  */

   824 EXPORT_C TBool NThreadBase::ForceResume()

   825 	{

   826 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NThreadBase::ForceResume");		

   827 	__KTRACE_OPT(KNKERN,DEBUGPRINT("NThreadBase::ForceResume %T, state %d CSC %d CSF %d",this,iNState,iCsCount,iCsFunction));

   828 	if (iNState==EDead)

   829 		return FALSE;

   830 

   831 	// If thread is in critical section, just cancel deferred suspends

   832 	if (iCsCount || iHeldFastMutex)

   833 		{

   834 		if (iCsFunction>0)

   835 			iCsFunction=0;	// cancel all deferred suspensions

   836 		return FALSE;

   837 		}

   838 	if (iSuspendCount<0)

   839 		{

   840 		iSuspendCount=0;

   841 		switch (iNState)

   842 			{

   843 			case ESuspended:

   844 				Ready();

   845 			case EReady:

   846 			case EWaitFastSemaphore:

   847 			case EWaitDfc:

   848 			case ESleep:

   849 			case EBlocked:

   850 			case EDead:

   851 				break;

   852 			default:

   853 				UnknownState(EForceResume,0);

   854 				break;

   855 			}

   856 		}

   857 	return TRUE;

   858 	}

   859 

   860 

   861 /** Releases a waiting nanokernel thread.

   862 

   863 	For use by RTOS personality layers.

   864 	Do not use this function directly on a Symbian OS thread.

   865 	This function should make the thread ready (provided it is not explicitly

   866 	suspended) and cancel any wait timeout. It should also remove it from any

   867 	wait queues.

   868 	If aReturnCode is nonnegative it indicates normal completion of the wait.

   869 	If aReturnCode is negative it indicates early/abnormal completion of the

   870 	wait and so any wait object should be reverted as if the wait had never

   871 	occurred (eg semaphore count should be incremented as this thread has not

   872 	actually acquired the semaphore).

   873 	The thread's unknown state handler will be invoked with function ERelease

   874 	and parameter aReturnCode if the current NState is not recognised.

   875 	

   876 	@param aReturnCode	The reason code for release.

   877 

   878 	@pre	Kernel must be locked.

   879 	@pre	Call either in a thread or an IDFC context.

   880 	

   881 	@post	Kernel is locked.

   882  */

   883 EXPORT_C void NThreadBase::Release(TInt aReturnCode)

   884 	{

   885 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NThreadBase::Release");		

   886 	__KTRACE_OPT(KNKERN,DEBUGPRINT("NThreadBase::Release %T, state %d retcode %d",this,iNState,aReturnCode));

   887 	switch(iNState)

   888 		{

   889 		case EDead:

   890 			return;

   891 		case EReady:

   892 		case ESuspended:

   893 			// don't release explicit suspensions

   894 			break;

   895 		case EWaitFastSemaphore:

   896 			if (aReturnCode<0 && iWaitObj)

   897 				((NFastSemaphore*)iWaitObj)->WaitCancel();

   898 			break;

   899 		case ESleep:

   900 		case EBlocked:

   901 		case EWaitDfc:

   902 			CheckSuspendThenReady();

   903 			break;

   904 		default:

   905 			UnknownState(ERelease,aReturnCode);

   906 			break;

   907 		}

   908 	if (iTimer.iUserFlags)

   909 		{

   910 		if (iTimer.iState == NTimer::EIdle)

   911 			{

   912 			// Potential race condition - timer must have completed but expiry

   913 			// handler has not yet run. Signal to the handler that it should do

   914 			// nothing by flipping the bottom bit of iTimer.iPtr

   915 			// This condition cannot possibly recur until the expiry handler has

   916 			// run since all expiry handlers run in DfcThread1.

   917 			TLinAddr& x = *(TLinAddr*)&iTimer.iPtr;

   918 			x ^= 1;

   919 			}

   920 		iTimer.Cancel();

   921 		iTimer.iUserFlags = FALSE;

   922 		}

   923 	iWaitObj=NULL;

   924 	iReturnValue=aReturnCode;

   925 	}

   926 

   927 

   928 /** Signals a nanokernel thread's request semaphore.

   929 

   930 	This can also be used on Symbian OS threads.

   931 	

   932 	@pre	Kernel must be locked.

   933 	@pre	Call either in a thread or an IDFC context.

   934 	

   935 	@post	Kernel is locked.

   936  */

   937 EXPORT_C void NThreadBase::RequestSignal()

   938 	{

   939 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NThreadBase::RequestSignal");		

   940 	iRequestSemaphore.Signal();

   941 	}

   942 

   943 void NThreadBase::TimerExpired(TAny* aPtr)

   944 	{

   945 	TLinAddr cookie = (TLinAddr)aPtr;

   946 	NThread* pT = (NThread*)(cookie &~ 3);

   947 	__KTRACE_OPT(KNKERN,DEBUGPRINT("NThreadBase::TimerExpired %T, state %d",pT,pT->iNState));

   948 	NThreadTimeoutHandler th = pT->iHandlers->iTimeoutHandler;

   949 	NKern::Lock();

   950 	if (pT->iNState<ENumNStates && pT->iNState!=EBlocked)

   951 		th = NULL;

   952 	if (th)

   953 		{

   954 		// Use higher level timeout handler

   955 		NKern::Unlock();

   956 		(*th)(pT, ETimeoutPreamble);

   957 		TInt param = ETimeoutPostamble;

   958 		NKern::Lock();

   959 		TLinAddr current_cookie = (TLinAddr)pT->iTimer.iPtr;

   960 		if ((cookie ^ current_cookie) & 1)

   961 			{

   962 			// The timer was cancelled just after expiring but before this function

   963 			// managed to call NKern::Lock(), so it's spurious

   964 			param = ETimeoutSpurious;

   965 			}

   966 		else

   967 			pT->iTimer.iUserFlags = FALSE;

   968 		NKern::Unlock();

   969 		(*th)(pT, param);

   970 		return;

   971 		}

   972 	TLinAddr current_cookie = (TLinAddr)pT->iTimer.iPtr;

   973 	if ((cookie ^ current_cookie) & 1)

   974 		{

   975 		// The timer was cancelled just after expiring but before this function

   976 		// managed to call NKern::Lock(), so just return without doing anything.

   977 		NKern::Unlock();

   978 		return;

   979 		}

   980 	pT->iTimer.iUserFlags = FALSE;

   981 	switch(pT->iNState)

   982 		{

   983 		case EDead:

   984 		case EReady:

   985 		case ESuspended:

   986 			NKern::Unlock();

   987 			return;

   988 		case EWaitFastSemaphore:

   989 			((NFastSemaphore*)pT->iWaitObj)->WaitCancel();

   990 			break;

   991 		case EBlocked:

   992 		case ESleep:

   993 		case EWaitDfc:

   994 			pT->CheckSuspendThenReady();

   995 			break;

   996 		default:

   997 			pT->UnknownState(ETimeout,0);

   998 			break;

   999 		}

  1000 	pT->iWaitObj=NULL;

  1001 	pT->iReturnValue=KErrTimedOut;

  1002 	NKern::Unlock();

  1003 	}

  1004 

  1005 

  1006 /** Changes the priority of a nanokernel thread.

  1007 

  1008 	For use by RTOS personality layers.

  1009 	Do not use this function directly on a Symbian OS thread.

  1010 

  1011 	The thread's unknown state handler will be invoked with function EChangePriority

  1012 	and parameter newp if the current NState is not recognised and the new priority

  1013 	is not equal to the original priority.

  1014 	

  1015 	@param	newp  The new nanokernel priority (0 <= newp < KNumPriorities).

  1016 

  1017 	@pre	Kernel must be locked.

  1018 	@pre	Call in a thread context.

  1019 	

  1020 	@post	Kernel is locked.

  1021  */

  1022 EXPORT_C void NThreadBase::SetPriority(TInt newp)

  1023 	{

  1024 	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_IDFC|MASK_NOT_ISR,"NThreadBase::SetPriority");		

  1025 	__KTRACE_OPT(KNKERN,DEBUGPRINT("NThreadBase::SetPriority %T %d->%d, state %d",this,iPriority,newp,iNState));

  1026 #ifdef _DEBUG

  1027 	// When the crazy scheduler is active, refuse to set any priority higher than 1

  1028 	if (KCrazySchedulerEnabled() && newp>1)

  1029 		newp=1;

  1030 #endif

  1031 	if (newp==iPriority)

  1032 		return;

  1033 #ifdef BTRACE_THREAD_PRIORITY

  1034 	BTrace8(BTrace::EThreadPriority,BTrace::ENThreadPriority,this,newp);

  1035 #endif

  1036 	switch(iNState)

  1037 		{

  1038 		case EReady:

  1039 			{

  1040 			TInt oldp=iPriority;

  1041 			TheScheduler.ChangePriority(this,newp);

  1042 			NThreadBase* pC=TheScheduler.iCurrentThread;

  1043 			if (this==pC)

  1044 				{

  1045 				if (newp<oldp && (TheScheduler>newp || !TPriListLink::Alone()))	// can't have scheduler<newp

  1046 					RescheduleNeeded();

  1047 				}

  1048 			else if (newp>oldp)

  1049 				{

  1050 				TInt cp=pC->iPriority;

  1051 				if (newp>cp)

  1052 					RescheduleNeeded();

  1053 				else if (newp==cp && pC->iTime==0)

  1054 					{

  1055 					if (pC->iHeldFastMutex)

  1056 						pC->iHeldFastMutex->iWaiting=1;	// don't round-robin now, wait until fast mutex released

  1057 					else

  1058 						RescheduleNeeded();

  1059 					}

  1060 				}

  1061 			break;

  1062 			}

  1063 		case ESuspended:

  1064 		case EWaitFastSemaphore:

  1065 		case EWaitDfc:

  1066 		case ESleep:

  1067 		case EBlocked:

  1068 		case EDead:

  1069 			iPriority=TUint8(newp);

  1070 			break;

  1071 		default:

  1072 			UnknownState(EChangePriority,newp);

  1073 			break;

  1074 		}

  1075 	}

  1076 

  1077 void NThreadBase::Exit()

  1078 	{

  1079 	// The current thread is exiting

  1080 	// Enter with kernel locked, don't return

  1081 	__NK_ASSERT_DEBUG(this==TheScheduler.iCurrentThread);

  1082 

  1083 	OnExit();

  1084 

  1085 	TInt threadCS=iCsCount;

  1086 	TInt kernCS=TheScheduler.iKernCSLocked;

  1087 	iCsCount=1;

  1088 	iCsFunction=ECSExitInProgress;

  1089 	NKern::Unlock();

  1090 	__KTRACE_OPT(KSCHED,DEBUGPRINT("Exit %T %u",this,NTickCount()));

  1091 	__KTRACE_OPT(KNKERN,DEBUGPRINT("NThreadBase::Exit %T, CSC %d HeldFM %M KernCS %d",this,threadCS,iHeldFastMutex,kernCS));

  1092 	if (kernCS!=1)

  1093 		FAULT();

  1094 	if (iHeldFastMutex)

  1095 		FAULT();

  1096 	if (threadCS)

  1097 		FAULT();

  1098 	TDfc* pD=NULL;

  1099 	NThreadExitHandler xh = iHandlers->iExitHandler;

  1100 	if (xh)

  1101 		pD=(*xh)((NThread*)this);		// call exit handler

  1102 	NKern::Lock();

  1103 	if (pD)

  1104 		pD->DoEnque();

  1105 	iNState=EDead;

  1106 	TheScheduler.Remove(this);

  1107 	RescheduleNeeded();

  1108 #ifdef BTRACE_THREAD_IDENTIFICATION

  1109 	BTrace4(BTrace::EThreadIdentification,BTrace::ENanoThreadDestroy,this);

  1110 #endif

  1111 	__NK_ASSERT_ALWAYS(iCsFunction == ECSExitInProgress);

  1112 	TScheduler::Reschedule();	// this won't return

  1113 	FAULT();

  1114 	}

  1115 

  1116 

  1117 /** Kills a nanokernel thread.

  1118 

  1119 	For use by RTOS personality layers.

  1120 	Do not use this function directly on a Symbian OS thread.

  1121 

  1122 	When acting on the calling thread, causes the calling thread to exit.

  1123 

  1124 	When acting on another thread, causes that thread to exit unless it is

  1125 	currently in a critical section. In this case the thread is marked as

  1126 	"exit pending" and will exit as soon as it leaves the critical section.

  1127 

  1128 	In either case the exiting thread first invokes its exit handler (if it

  1129 	exists). The handler runs with preemption enabled and with the thread in a

  1130 	critical section so that it may not be suspended or killed again. The

  1131 	handler may return a pointer to a TDfc, which will be enqueued just before

  1132 	the thread finally terminates (after the kernel has been relocked). This DFC

  1133 	will therefore execute once the NThread has been safely removed from the

  1134 	scheduler and is intended to be used to cleanup the NThread object and any