tskmng.c

一个操作系统源代码 用于嵌入式设备 在Vc++环境下仿真 成功移植到多款处理器上

//------------------------------------------------------------------------------
// Function name  : ContextSwitch
// Description    :
// No return value
// No argument
// Remarks        :
// So also        :
//------------------------------------------------------------------------------
ER ContextSwitch( void )
{
	ER	result;

	ResetEvent( hEnEventInt );
	result = iContextSwitch( );
	SetEvent( hEnEventInt );

	return result;
}

ER iContextSwitch( void )
{
    ID idNextTask, idTemp;
    B i;
	DWORD	temp;
//	DWORD	error;

	ENTER_CS

    if( g_ubSysStat&TSS_DDSP || !isSystemStart )
    {
		flgdbgprintf( "Disable Switch!" );
		
		LEAVE_CS
		
		return E_SYS;
	}

	for(i=1;i<=MAX_TSKPRI;i++)
    {
        idNextTask = aReadyQueue[i].idFirstTask;
        if( idNextTask )// yes, we have a task to switch
        {
            if( idCurTask )// there's a task running before
            {
                // do nothing if the new task to be activated is the current
                // task
                if( idNextTask == idCurTask )
                {    
					flgdbgprintf( "No Switch!" );
					
					LEAVE_CS

					break;
				}
                //if( aReadyQueue[i].idFirstTask != aReadyQueue[i].idLastTask )
                //{
                //    RemoveFirstTaskFromReadyQueue( i );
                //    AppendTaskToReadyQueue( idNextTask );
                //}

                idTemp = idCurTask;
                idCurTask = idNextTask;
                aTcb[idTemp].ubStatus &= ~TTS_RUN;
                aTcb[idNextTask].ubStatus |= TTS_RUN;

				flgdbgprintf( "Switch!" );
				temp = ResumeThread( aTcb[idNextTask].hThread );
//				while( temp == -1 )
//				{	
//					error = GetLastError();
//					flgdbgoutput( "resume task %d error", idNextTask );
//					flgdbgoutput( "thread %ld", (DWORD) aTcb[idNextTask].hThread );
//					flgdbgoutput( "error code: %ld", error );
//					temp = ResumeThread( aTcb[idNextTask].hThread );
//				}
				flgdbgoutput( "Resume task(c): %d", idNextTask );
				flgdbgoutput( "Resume result(c): %ld", temp );
				
				LEAVE_CS

				flgdbgoutput( "Suspend task(c): %d", idTemp );
				temp = SuspendThread( aTcb[idTemp].hThread );
				flgdbgoutput( "Suspend result(c): %ld", temp );
				

                break;
            }
            else
            {
                //if( aReadyQueue[i].idFirstTask != aReadyQueue[i].idLastTask )
                //{
                //    AppendTaskToReadyQueue( idNextTask );
                //    RemoveFirstTaskFromReadyQueue( i );
                //}
                idCurTask = idNextTask;
				flgdbgprintf( "Select!" );
                temp = ResumeThread( aTcb[idNextTask].hThread );
				flgdbgoutput( "Resume task(ic): %d", idNextTask );
				flgdbgoutput( "Resume result(ic): %ld", temp );
                
				LEAVE_CS

				break;
            }
        }
    }
    if( i>MAX_TSKPRI && idCurTask )
    {
        idTemp = idCurTask;
        idCurTask = 0;

		LEAVE_CS

        SuspendThread( aTcb[idTemp].hThread );
    }

	return E_OK;
}


//------------------------------------------------------------------------------
// Function name  : chg_pri
// Description    : 
// Return type    : ER
// Argument       : ID tskid
// Argument       : PRI tskpri
// Remarks        : 
// So also        : 
//------------------------------------------------------------------------------
ER chg_pri( ID tskid, 
			PRI tskpri )
{
    B bOldPriority;

#if ENABLE_SYSCALL_STATISTIC	
	gSyscallSta[5].sta++;
#endif

    if( tskid<0 )
        return E_ID;
    
    if(tskid > TSK_NUM)
        return E_NOEXS;
    
    if( tskpri<1 || tskpri>MAX_TSKPRI )
        return E_PAR;
    
    if( !aTcb[tskid].fpPC )
        return E_NOEXS;

    if( aTcb[tskid].ubStatus & TTS_DMT)
        return E_OBJ;

    bOldPriority = aTcb[tskid].bPriority;
    aTcb[tskid].bPriority = tskpri;

    if( !( aTcb[tskid].ubStatus & ( ~( TTS_RUN | TTS_RDY ) ) ) )
    {
        RemoveTaskFromReadyQueue( bOldPriority, tskid );
        AppendTaskToReadyQueue( tskid );
        ContextSwitch( );
    }
    return E_OK;
}

//------------------------------------------------------------------------------
// Function name  : rot_rdq
// Description    : 
// Return type    : ER
// Argument       : PRI tskpri
// Remarks        : 
// So also        : 
//------------------------------------------------------------------------------
ER rot_rdq( PRI tskpri )
{
    ID idTask;

#if ENABLE_SYSCALL_STATISTIC	
	gSyscallSta[6].sta++;
#endif

    if( tskpri<0 || tskpri>MAX_TSKPRI )
        return E_PAR;

    if( tskpri==TPRI_RUN || tskpri==aTcb[idCurTask].bPriority )
        ContextSwitch( );
    else if( aReadyQueue[tskpri].idFirstTask
    && aReadyQueue[tskpri].idFirstTask != aReadyQueue[tskpri].idLastTask )
    {
        idTask = RemoveFirstTaskFromReadyQueue( (B)tskpri );
        AppendTaskToReadyQueue( idTask );
    }
    return E_OK;
}

//------------------------------------------------------------------------------
// Function name  : get_tid
// Description    : 
// Return type    : ER
// Argument       : ID *p_tskid
// Remarks        : 
// So also        : 
//------------------------------------------------------------------------------
ER get_tid( ID *p_tskid )
{
#if ENABLE_SYSCALL_STATISTIC	
	gSyscallSta[8].sta++;
#endif

	*p_tskid = idCurTask;
    return E_OK;
}

//------------------------------------------------------------------------------
// Function name  : dis_dsp
// Description    : 
// Return type    : ER
// No argument
// Remarks        : 
// So also        : 
//------------------------------------------------------------------------------
ER dis_dsp( void )
{
#if ENABLE_SYSCALL_STATISTIC	
//	ID id;

//	get_tid( &id );
	gSyscallSta[3].sta++;
//	dbgoutput( "%d dis_dsp\n", id );
#endif

    if( g_ubSysStat == TSS_LOC )
        return E_CTX;

    g_ubSysStat |= TSS_DDSP;
    
    return E_OK;
}

//------------------------------------------------------------------------------
// Function name  : ena_dsp
// Description    : 
// Return type    : ER
// No argument
// Remarks        : 
// So also        : 
//------------------------------------------------------------------------------
ER ena_dsp( void )
{
#if ENABLE_SYSCALL_STATISTIC	
//	ID id;

//	get_tid( &id );
	gSyscallSta[4].sta++;
//	dbgoutput( "%d ena_dsp\n", id );
#endif

    if( g_ubSysStat == TSS_LOC )
        return E_CTX;

    g_ubSysStat &= ~TSS_DDSP;

    ContextSwitch( );

    return E_OK;
}

//------------------------------------------------------------------------------
// Function name  : get_ver
// Description    : 
// Return type    : ER
// Argument       : T_VER *pk_ver
// Remarks        : 
// So also        : 
//------------------------------------------------------------------------------
ER get_ver( T_VER *pk_ver )
{
    if( !pk_ver )
        return E_PAR;

    pk_ver->maker   = 0x0000;           // maker code none
    pk_ver->id      = 0x0091;           // id
    pk_ver->spver   = 0x5302;           // mITRON ver3.02
    pk_ver->prver   = ROS33_VERSION;    // implement version
    pk_ver->prno[0] = 0x0000;           // not use
    pk_ver->prno[1] = 0x0000;           // not use
    pk_ver->prno[2] = 0x0000;           // not use
    pk_ver->prno[3] = 0x0000;           // not use
    pk_ver->cpu     = 0x0000;           // cpu code none
    pk_ver->var     = 0x8000;           // level S (standard level)

    return E_OK;
}

//------------------------------------------------------------------------------
// Function name  : PollingTimerHandler
// Description    : 
// No return value
// Argument       : ID idTask
// Remarks        : 
// So also        : 
//------------------------------------------------------------------------------
void PollingTimerHandler(	HWND hwnd, 
									UINT uMSG, 
									UINT idTask,
									DWORD dwTime )
{
    
	KillTimer( hwnd, idTask );

	if( aTcb[idTask].ubStatus & TTS_WAI )
    {
        aTcb[idTask].ubStatus &= ~TTS_WAI;
        switch( aTcb[idTask].ubWaitStat )
		{
			case TTW_DLY:
			case TTW_SLP:
				aTcb[idTask].vwWaitRet = E_OK;
				break;
			case TTW_FLG:
			case TTW_MBX:
			//case TTW_SEM:
			//case TTW_SMBF:
			//case TTW_MBF:
			//case TTW_MPL:
			//case TTW_MPF:
			//case TTW_NOD:
				aTcb[idTask].vwWaitRet = E_TMOUT;
				break;
			
		}
        aTcb[idTask].ubWaitStat = 0;

        AppendTaskToReadyQueue( idTask );
        ContextSwitch( );
    }
	
}
//new function

//----------------------------- The End of the File ----------------------------