FreeCalypso > hg > fc-tourmaline
view src/nucleus/tcs.c @ 281:a75eefbf8be4
Phone boot with PWON: weed out short button presses
Every standard end user phone has a design provision, most naturally
implemented in firmware, whereby the PWON button effects a boot only
if it is held down long enough - short presses of this PWON button
are detected, assumed to be spurious and cause the fw to power back off
instead of proceeding with boot. The present change introduces this
standard function in FreeCalypso.
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Fri, 24 Sep 2021 02:03:08 +0000 |
| parents | 4e78acac3d88 |
| children |
line wrap: on
line source
/*************************************************************************/ /* */ /* Copyright Mentor Graphics Corporation 2002 */ /* All Rights Reserved. */ /* */ /* THIS WORK CONTAINS TRADE SECRET AND PROPRIETARY INFORMATION WHICH IS */ /* THE PROPERTY OF MENTOR GRAPHICS CORPORATION OR ITS LICENSORS AND IS */ /* SUBJECT TO LICENSE TERMS. */ /* */ /*************************************************************************/ /*************************************************************************/ /* */ /* FILE NAME VERSION */ /* */ /* tcs.c Nucleus PLUS 1.14 */ /* */ /* COMPONENT */ /* */ /* TC - Thread Control */ /* */ /* DESCRIPTION */ /* */ /* This file contains supplemental routines for the Thread Control */ /* component. */ /* */ /* DATA STRUCTURES */ /* */ /* None */ /* */ /* FUNCTIONS */ /* */ /* TCS_Change_Priority Change task's priority */ /* TCS_Change_Preemption Change task's preemption */ /* TCS_Change_Time_Slice Change task's time-slice */ /* TCS_Control_Signals Control signals */ /* TCS_Receive_Signals Receive signals */ /* TCS_Register_Signal_Handler Register signal handler */ /* TCS_Send_Signals Send signals to a task */ /* */ /* */ /* DEPENDENCIES */ /* */ /* cs_extr.h Common Service functions */ /* tc_extr.h Thread Control functions */ /* in_extr.h Initialization/Interrupt */ /* functions */ /* tm_extr.h Timer Control function */ /* er_extr.h Error handling function */ /* hi_extr.h History functions */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1994 Created initial version 1.1 from */ /* previous version of TCC.C */ /* */ /* 03-18-1994 Verified version 1.1 */ /* 04-04-1996 Modified TCS_Send_Signals, */ /* resulting in version 1.1+ */ /* (spr 107) */ /* 04-17-1996 updated to version 1.2 */ /* 03-24-1998 Released version 1.3. */ /* 03-26-1999 Released 1.11m (new release */ /* numbering scheme) */ /* 04-17-2002 Released version 1.13m */ /* 11-07-2002 Released version 1.14 */ /*************************************************************************/ #define NU_SOURCE_FILE #include "cs_extr.h" /* Common service functions */ #include "tc_extr.h" /* Thread control functions */ #include "in_extr.h" /* Initialization/Interrupt */ /* functions */ #include "tm_extr.h" /* Timer control functions */ #include "er_extr.h" /* Error handling function */ #include "hi_extr.h" /* History functions */ #include "profiler.h" /* ProView interface */ /* Define external inner-component global data references. */ extern CS_NODE *TCD_Created_Tasks_List; extern TC_TCB *TCD_Priority_List[TC_PRIORITIES]; extern UNSIGNED TCD_Priority_Groups; extern DATA_ELEMENT TCD_Sub_Priority_Groups[TC_MAX_GROUPS]; extern UNSIGNED_CHAR TCD_Lowest_Set_Bit[]; extern INT TCD_Highest_Priority; extern TC_TCB *TCD_Execute_Task; extern VOID *TCD_Current_Thread; extern TC_PROTECT TCD_System_Protect; extern INT TMD_Time_Slice_State; /* Define external inner-component function calls that are not available to other components. */ VOID TCT_Build_Signal_Frame(TC_TCB *task_ptr); VOID TCT_Protect_Switch(TC_TCB *task); VOID TCT_Signal_Exit(VOID); /* Define internal function calls. */ VOID TCC_Signal_Shell(VOID); /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* TCS_Change_Priority */ /* */ /* DESCRIPTION */ /* */ /* This function changes the priority of the specified task. The */ /* priority of a suspended or a ready task can be changed. If the */ /* new priority necessitates a context switch, control is */ /* transferred back to the system. */ /* */ /* CALLED BY */ /* */ /* Application */ /* TCSE_Change_Priority Error checking shell */ /* */ /* CALLS */ /* */ /* [HIC_Make_History_Entry] Make entry in history log */ /* [TCT_Check_Stack] Stack checking function */ /* TCT_Control_To_System Transfer control to system */ /* TCT_Protect Protect scheduling data */ /* TCT_Set_Execute_Task Set TCD_Execute_Task pointer */ /* TCT_Unprotect Release protection of data */ /* */ /* INPUTS */ /* */ /* task_ptr Task control block pointer */ /* new_priority New priority for task */ /* */ /* OUTPUTS */ /* */ /* old_priority Original task priority */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* 03-01-1994 Modified function interface, */ /* added register optimizations, */ /* modified protection logic, */ /* resulting in version 1.1 */ /* */ /* 03-18-1994 Verified version 1.1 */ /* */ /* 10-4-1999 Bug fixes - return if new */ /* priority equals old priority */ /* and don't move the head pointer */ /* unless the head node is changing */ /*************************************************************************/ OPTION TCS_Change_Priority(NU_TASK *task_ptr, OPTION new_priority) { R1 TC_TCB *task; /* Task control block ptr */ R2 TC_TCB *head; /* Head list pointer */ R3 INT index; /* Working index variable */ OPTION old_priority; /* Previous priority of task */ DATA_ELEMENT temp; /* Temporary variable */ NU_SUPERV_USER_VARIABLES /* Switch to supervisor mode */ NU_SUPERVISOR_MODE(); /* Move task control block pointer into internal pointer. */ task = (TC_TCB *) task_ptr; #ifdef NU_ENABLE_STACK_CHECK /* Call stack checking function to check for an overflow condition. */ TCT_Check_Stack(); #endif #ifdef NU_ENABLE_HISTORY /* Make an entry that corresponds to this function in the system history log. */ HIC_Make_History_Entry(NU_CHANGE_PRIORITY_ID, (UNSIGNED) task, (UNSIGNED) new_priority, (UNSIGNED) 0); #endif /* Protect against multiple access to the scheduling list. */ TCT_Protect(&TCD_System_Protect); /* Save the old priority of the task. */ old_priority = task -> tc_priority; /* BUG FIX this should probably go into an error checking routine instead of here */ if (!(task -> tc_priority == new_priority)) { /* Check to see if the task is currently ready. */ if (task -> tc_status == NU_READY) { /* Remove the task from the ready list. */ /* Determine if the task is the only one on the list. */ if (task -> tc_ready_next == task) { /* Only task on the list. Clear the task's pointers and clear the entry in the priority table. */ task -> tc_ready_next = NU_NULL; task -> tc_ready_previous = NU_NULL; *(task -> tc_priority_head) = NU_NULL; /* Clear the sub-priority group. */ *(task -> tc_sub_priority_ptr) = *(task -> tc_sub_priority_ptr) & ~(task -> tc_sub_priority); /* Determine if the main priority group needs to be cleared. This is only true if there are no other bits set in this sub-priority. */ if (*(task -> tc_sub_priority_ptr) == 0) /* Clear the main priority group bit. */ TCD_Priority_Groups = TCD_Priority_Groups & ~(task -> tc_priority_group); } else { /* Not the only task ready at the same priority level. */ /* Remove from the linked-list. */ (task -> tc_ready_previous) -> tc_ready_next = task -> tc_ready_next; (task -> tc_ready_next) -> tc_ready_previous = task -> tc_ready_previous; /* Update the head pointer. */ /* BUG FIX - update head if head is changing priority - leave it alone otherwise! */ if(*(task -> tc_priority_head) == task ) *(task -> tc_priority_head) = task -> tc_ready_next; /* Clear the next and previous pointers. */ task -> tc_ready_next = NU_NULL; task -> tc_ready_previous = NU_NULL; } /* Now add in the task at the new priority. */ task -> tc_priority = new_priority; /* Build the other priority information. */ task -> tc_priority = new_priority; task -> tc_priority_head = &(TCD_Priority_List[new_priority]); task -> tc_sub_priority = (DATA_ELEMENT) (1 << (new_priority & 7)); task -> tc_priority_group = ((UNSIGNED) 1) << (new_priority >> 3); task -> tc_sub_priority_ptr = &(TCD_Sub_Priority_Groups[(new_priority >> 3)]); #ifdef INCLUDE_PROVIEW _RTProf_DumpTask(task,RT_PROF_CHANGE_PRIORITY); #endif /* Link the task into the new priority list. */ head = *(task -> tc_priority_head); /* Determine if the list is non-empty. */ if (head) { /* Add the TCB to the end of the ready list. */ task -> tc_ready_previous = head -> tc_ready_previous; (task -> tc_ready_previous) -> tc_ready_next = task; task -> tc_ready_next = head; (task -> tc_ready_next) -> tc_ready_previous = task; /* Note that the priority bit map does not need to be modified since there are other active tasks at the same priority. */ } else { /* Add the TCB to an empty list. */ task -> tc_ready_previous = task; task -> tc_ready_next = task; *(task -> tc_priority_head)= task; /* Update the priority group bit map to indicate that this priority now has a task ready. */ TCD_Priority_Groups = TCD_Priority_Groups | (task -> tc_priority_group); /* Update the sub-priority bit map to show that this priority is ready. */ *(task -> tc_sub_priority_ptr) = (*(task -> tc_sub_priority_ptr)) | task -> tc_sub_priority; } /* Determine the highest priority task in the system. */ if (TCD_Priority_Groups & TC_HIGHEST_MASK) /* Base of sub-group is 0. */ index = 0; else if (TCD_Priority_Groups & TC_NEXT_HIGHEST_MASK) /* Base of sub-group is 8. */ index = 8; else if (TCD_Priority_Groups & TC_NEXT_LOWEST_MASK) /* Base of sub-group is 16. */ index = 16; else /* Base of sub-group is 24. */ index = 24; /* Calculate the highest available priority. */ index = index + TCD_Lowest_Set_Bit[(INT) ((TCD_Priority_Groups >> index) & TC_HIGHEST_MASK)]; /* Get the mask of the priority within the group of 8 priorities. */ temp = TCD_Sub_Priority_Groups[index]; /* Calculate the actual priority. */ TCD_Highest_Priority = (index << 3) + TCD_Lowest_Set_Bit[temp]; /* Check for preemption. */ if ((TCD_Highest_Priority <= ((INT) TCD_Execute_Task -> tc_priority)) && (TCD_Execute_Task -> tc_preemption)) { /* Update the current task pointer. */ TCT_Set_Execute_Task(TCD_Priority_List[TCD_Highest_Priority]); /* Now, check and see if the current thread is a task. If so, return a status that indicates a context switch is needed. */ if ((TCD_Current_Thread) && (((TC_TCB *) TCD_Current_Thread) -> tc_id == TC_TASK_ID)) /* Transfer control to the system. */ TCT_Control_To_System(); } } else { /* Just modify the priority. */ task -> tc_priority = new_priority; /* Build the other priority information. */ task -> tc_priority = new_priority; task -> tc_priority_head = &(TCD_Priority_List[new_priority]); task -> tc_sub_priority = (DATA_ELEMENT) (1 << (new_priority & 7)); task -> tc_priority_group = ((UNSIGNED) 1) << (new_priority >> 3); task -> tc_sub_priority_ptr = &(TCD_Sub_Priority_Groups[(new_priority >> 3)]); } #ifdef INCLUDE_PROVIEW _RTProf_DumpTask(task,RT_PROF_CHANGE_PRIORITY); #endif } /* Release the protection of the scheduling list. */ TCT_Unprotect(); /* Return to user mode */ NU_USER_MODE(); /* Return the old priority. */ return(old_priority); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* TCS_Change_Preemption */ /* */ /* DESCRIPTION */ /* */ /* This function changes the preemption posture of the calling */ /* task. Preemption for a task may be enabled or disabled. If */ /* it is disabled, the task runs until it suspends or relinquishes. */ /* If a preemption is pending, a call to this function to enable */ /* preemption causes a context switch. */ /* */ /* CALLED BY */ /* */ /* Application */ /* TCSE_Change_Preemption Error checking function */ /* */ /* CALLS */ /* */ /* [HIC_Make_History_Entry] Make entry in history log */ /* [TCT_Check_Stack] Stack checking function */ /* TCT_Control_To_System Transfer control to system */ /* TCT_Protect Protect scheduling info */ /* TCT_Set_Execute_Task Set TCD_Execute_Task pointer */ /* TCT_Unprotect Release protection of info */ /* */ /* INPUTS */ /* */ /* preempt Preempt selection parameter */ /* */ /* OUTPUTS */ /* */ /* old_preempt Original preempt value */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* 03-01-1994 Modified protection logic, */ /* resulting in version 1.1 */ /* */ /* 03-18-1994 Verified version 1.1 */ /* */ /*************************************************************************/ OPTION TCS_Change_Preemption(OPTION preempt) { TC_TCB *task; /* Pointer to task */ OPTION old_preempt; NU_SUPERV_USER_VARIABLES /* Switch to supervisor mode */ NU_SUPERVISOR_MODE(); #ifdef NU_ENABLE_STACK_CHECK /* Call stack checking function to check for an overflow condition. */ TCT_Check_Stack(); #endif #ifdef NU_ENABLE_HISTORY /* Make an entry that corresponds to this function in the system history log. */ HIC_Make_History_Entry(NU_CHANGE_PREEMPTION_ID, (UNSIGNED) preempt, (UNSIGNED) 0, (UNSIGNED) 0); #endif /* Protect the scheduling information. */ TCT_Protect(&TCD_System_Protect); /* Pickup the current thread and place it in the task pointer. */ task = (TC_TCB *) TCD_Current_Thread; /* Save the old preempt value. */ if (task -> tc_preemption) /* Previously enabled. */ old_preempt = NU_PREEMPT; else /* Previously disabled. */ old_preempt = NU_NO_PREEMPT; /* Process the new value. */ if (preempt == NU_NO_PREEMPT) /* Disable preemption. */ TCD_Execute_Task -> tc_preemption = NU_FALSE; else { /* Enable preemption. */ task -> tc_preemption = NU_TRUE; /* Check for a preemption condition. */ if ((task == TCD_Execute_Task) && (TCD_Highest_Priority < ((INT) TCD_Execute_Task -> tc_priority))) { /* Preempt the current task. */ TCT_Set_Execute_Task(TCD_Priority_List[TCD_Highest_Priority]); /* Transfer control to the system. */ TCT_Control_To_System(); } } #ifdef INCLUDE_PROVIEW _RTProf_DumpTask(task,RT_PROF_CHANGE_PREEMPTION); #endif /* Release protection of information. */ TCT_Unprotect(); /* Return to user mode */ NU_USER_MODE(); /* Return the previous preemption posture. */ return(old_preempt); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* TCS_Change_Time_Slice */ /* */ /* DESCRIPTION */ /* */ /* This function changes the time slice of the specified task. A */ /* time slice value of 0 disables time slicing. */ /* */ /* CALLED BY */ /* */ /* Application */ /* TCES_Change_Preemption Error checking function */ /* */ /* CALLS */ /* */ /* [HIC_Make_History_Entry] Make entry in history log */ /* [TCT_Check_Stack] Stack checking function */ /* TCT_Protect Protect scheduling info */ /* TCT_Unprotect Release protection of info */ /* */ /* INPUTS */ /* */ /* task_ptr Task control block pointer */ /* time_slice New time slice value */ /* */ /* OUTPUTS */ /* */ /* old_time_slice Original time slice value */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* 03-01-1994 Modified function interface, */ /* added register optimizations, */ /* modified protection logic, */ /* resulting in version 1.1 */ /* */ /* 03-18-1994 Verified version 1.1 */ /* */ /*************************************************************************/ UNSIGNED TCS_Change_Time_Slice(NU_TASK *task_ptr, UNSIGNED time_slice) { TC_TCB *task; /* Task control block ptr */ UNSIGNED old_time_slice; /* Old time slice value */ NU_SUPERV_USER_VARIABLES /* Switch to supervisor mode */ NU_SUPERVISOR_MODE(); /* Move input task control block pointer into internal pointer. */ task = (TC_TCB *) task_ptr; #ifdef NU_ENABLE_STACK_CHECK /* Call stack checking function to check for an overflow condition. */ TCT_Check_Stack(); #endif #ifdef NU_ENABLE_HISTORY /* Make an entry that corresponds to this function in the system history log. */ HIC_Make_History_Entry(NU_CHANGE_TIME_SLICE_ID, (UNSIGNED) task, (UNSIGNED) time_slice, (UNSIGNED) 0); #endif /* Protect the scheduling information. */ TCT_Protect(&TCD_System_Protect); /* Save the old time slice value. */ old_time_slice = task -> tc_time_slice; /* Store the new time slice value. */ task -> tc_time_slice = time_slice; task -> tc_cur_time_slice = time_slice; /* Bug fix. Let the system know we have started a new time slice */ TMD_Time_Slice_State = TM_ACTIVE; #ifdef INCLUDE_PROVIEW _RTProf_DumpTask(task,RT_PROF_CHANGE_TIME_SLICE); #endif /* Release protection of information. */ TCT_Unprotect(); /* Return to user mode */ NU_USER_MODE(); /* Return the previous time slice value. */ return(old_time_slice); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* TCS_Control_Signals */ /* */ /* DESCRIPTION */ /* */ /* This function enables the specified signals and returns the */ /* previous enable signal value back to the caller. If a newly */ /* enabled signal is present and a signal handler is registered, */ /* signal handling is started. */ /* */ /* CALLED BY */ /* */ /* Application */ /* TCSE_Control_Signals Error checking shell */ /* */ /* CALLS */ /* */ /* [HIC_Make_History_Entry] Make entry in history log */ /* TCC_Signal_Shell Task signal execution */ /* [TCT_Check_Stack] Stack checking function */ /* TCT_Protect Protect against other access */ /* TCT_Unprotect Release protection */ /* */ /* INPUTS */ /* */ /* enable_signal_mask Enable signal mask */ /* */ /* OUTPUTS */ /* */ /* Previous signal enable mask */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* 05-15-1993 Corrected problem with a comment */ /* 05-15-1993 Verified comment repair */ /* 03-01-1994 Added register optimizations, */ /* modified protection logic, */ /* resulting in version 1.1 */ /* */ /* 03-18-1994 Verified version 1.1 */ /* */ /*************************************************************************/ UNSIGNED TCS_Control_Signals(UNSIGNED enable_signal_mask) { R1 TC_TCB *task; /* Task pointer */ UNSIGNED old_enable_mask; /* Old enable signal mask */ NU_SUPERV_USER_VARIABLES /* Switch to supervisor mode */ NU_SUPERVISOR_MODE(); #ifdef NU_ENABLE_STACK_CHECK /* Call stack checking function to check for an overflow condition. */ TCT_Check_Stack(); #endif #ifdef NU_ENABLE_HISTORY /* Make an entry that corresponds to this function in the system history log. */ HIC_Make_History_Entry(NU_CONTROL_SIGNALS_ID,(UNSIGNED) enable_signal_mask, (UNSIGNED) 0, (UNSIGNED) 0); #endif /* Pickup the task pointer. */ task = (TC_TCB *) TCD_Current_Thread; /* Protect against simultaneous access. */ TCT_Protect(&TCD_System_Protect); /* Pickup the old signal mask. */ old_enable_mask = task -> tc_enabled_signals; /* Put the new mask in. */ task -> tc_enabled_signals = enable_signal_mask; /* Now, determine if the signal handler needs to be invoked. */ if ((enable_signal_mask & task -> tc_signals) && (!task -> tc_signal_active) && (task -> tc_signal_handler)) { /* Signal processing is required. */ /* Indicate that signal processing is in progress. */ task -> tc_signal_active = NU_TRUE; /* Clear the saved stack pointer to indicate that this is an in line signal handler call. */ task -> tc_saved_stack_ptr = NU_NULL; #ifdef INCLUDE_PROVIEW _RTProf_DumpTask(task,RT_PROF_CONTROL_SIGNALS); #endif /* Release protection from multiple access. */ TCT_Unprotect(); /* Call the signal handling shell. */ TCC_Signal_Shell(); } else { #ifdef INCLUDE_PROVIEW _RTProf_DumpTask(task,RT_PROF_CONTROL_SIGNALS); #endif /* Release protection. */ TCT_Unprotect(); } /* Return to user mode */ NU_USER_MODE(); /* Return the old enable mask. */ return(old_enable_mask); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* TCS_Receive_Signals */ /* */ /* DESCRIPTION */ /* */ /* This function returns the current signals back to the caller. */ /* Note that the signals are cleared automatically. */ /* */ /* CALLED BY */ /* */ /* Application */ /* TCSE_Receive_Signals Error checking shell */ /* */ /* CALLS */ /* */ /* [HIC_Make_History_Entry] Make entry in history log */ /* [TCT_Check_Stack] Stack checking function */ /* TCT_Protect Protect against other access */ /* TCT_Unprotect Release protection */ /* */ /* INPUTS */ /* */ /* None */ /* */ /* OUTPUTS */ /* */ /* Current signals */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* 03-01-1994 Modified protection logic, */ /* resulting in version 1.1 */ /* */ /* 03-18-1994 Verified version 1.1 */ /* */ /*************************************************************************/ UNSIGNED TCS_Receive_Signals(VOID) { TC_TCB *task; /* Task pointer */ UNSIGNED signals; /* Current signals */ NU_SUPERV_USER_VARIABLES /* Switch to supervisor mode */ NU_SUPERVISOR_MODE(); #ifdef NU_ENABLE_STACK_CHECK /* Call stack checking function to check for an overflow condition. */ TCT_Check_Stack(); #endif #ifdef NU_ENABLE_HISTORY /* Make an entry that corresponds to this function in the system history log. */ HIC_Make_History_Entry(NU_RECEIVE_SIGNALS_ID, (UNSIGNED) 0, (UNSIGNED) 0, (UNSIGNED) 0); #endif /* Pickup the task pointer. */ task = (TC_TCB *) TCD_Current_Thread; /* Protect against simultaneous access. */ TCT_Protect(&TCD_System_Protect); /* Pickup the current events. */ signals = task -> tc_signals; /* Clear the current signals. */ task -> tc_signals = 0; #ifdef INCLUDE_PROVIEW _RTProf_DumpTask(task,RT_PROF_RECEIVE_SIGNALS); #endif /* Release protection. */ TCT_Unprotect(); /* Return to user mode */ NU_USER_MODE(); /* Return the signals to the caller. */ return(signals); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* TCS_Register_Signal_Handler */ /* */ /* DESCRIPTION */ /* */ /* This function registers a signal handler for the calling task. */ /* Note that if an enabled signal is present and this is the first */ /* registered signal handler call, the signal is processed */ /* immediately. */ /* */ /* CALLED BY */ /* */ /* Application */ /* TCSE_Register_Signal_Handler Error checking shell */ /* */ /* CALLS */ /* */ /* [HIC_Make_History_Entry] Make entry in history log */ /* TCC_Signal_Shell Signal execution shell */ /* [TCT_Check_Stack] Stack checking function */ /* TCT_Protect Protect against other access */ /* TCT_Unprotect Release protection */ /* */ /* INPUTS */ /* */ /* signal_handler Signal execution shell */ /* */ /* OUTPUTS */ /* */ /* NU_SUCCESS */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* 05-15-1993 Corrected problem with a comment */ /* 05-15-1993 Verified comment repair */ /* 03-01-1994 Added register optimizations, */ /* modified protection logic, */ /* resulting in version 1.1 */ /* */ /* 03-18-1994 Verified version 1.1 */ /* */ /*************************************************************************/ STATUS TCS_Register_Signal_Handler(VOID (*signal_handler)(UNSIGNED)) { R1 TC_TCB *task; /* Task pointer */ NU_SUPERV_USER_VARIABLES /* Switch to supervisor mode */ NU_SUPERVISOR_MODE(); #ifdef NU_ENABLE_STACK_CHECK /* Call stack checking function to check for an overflow condition. */ TCT_Check_Stack(); #endif #ifdef NU_ENABLE_HISTORY /* Make an entry that corresponds to this function in the system history log. */ HIC_Make_History_Entry(NU_REGISTER_SIGNAL_HANDLER_ID, (UNSIGNED) signal_handler, (UNSIGNED) 0, (UNSIGNED) 0); #endif /* Pickup the task pointer. */ task = (TC_TCB *) TCD_Current_Thread; /* Protect against simultaneous access. */ TCT_Protect(&TCD_System_Protect); /* Put the new signal handler in. */ task -> tc_signal_handler = signal_handler; /* Now, determine if the signal handler needs to be invoked. */ if ((task -> tc_enabled_signals & task -> tc_signals) && (!task -> tc_signal_active) && (task -> tc_signal_handler)) { /* Signal processing is required. */ /* Indicate that signal processing is in progress. */ task -> tc_signal_active = NU_TRUE; /* Clear the saved stack pointer to indicate that this is an in line signal handler call. */ task -> tc_saved_stack_ptr = NU_NULL; /* Release protection from multiple access. */ TCT_Unprotect(); /* Call the signal handling shell. */ TCC_Signal_Shell(); } else /* Release protection. */ TCT_Unprotect(); /* Return to user mode */ NU_USER_MODE(); /* Return success. */ return(NU_SUCCESS); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* TCS_Send_Signals */ /* */ /* DESCRIPTION */ /* */ /* This function sends the specified task the specified signals. */ /* If enabled, the specified task is setup in order to process the */ /* signals. */ /* */ /* CALLED BY */ /* */ /* Application */ /* TCSE_Send_Signals Error checking shell */ /* */ /* CALLS */ /* */ /* [HIC_Make_History_Entry] Make entry in history log */ /* TCC_Resume_Task Resume task that is suspended*/ /* TCC_Signal_Shell Signal execution shell */ /* TCT_Build_Signal_Frame Build a signal frame */ /* [TCT_Check_Stack] Stack checking function */ /* TCT_Control_To_System Control to system */ /* TCT_Protect Protect against other access */ /* TCT_Unprotect Release protection */ /* */ /* INPUTS */ /* */ /* task_ptr Task pointer */ /* signals Signals to send to the task */ /* */ /* OUTPUTS */ /* */ /* NU_SUCCESS */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* 03-01-1994 Modified function interface, */ /* added register optimizations, */ /* modified protection logic, */ /* resulting in version 1.1 */ /* */ /* 03-18-1994 Verified version 1.1 */ /* 04-04-1996 On line 995, changed tc_signals */ /* to tc_enabled_signals, */ /* resulting in version 1.1+ */ /* (spr 107) */ /* */ /*************************************************************************/ STATUS TCS_Send_Signals(NU_TASK *task_ptr, UNSIGNED signals) { R1 TC_TCB *task; /* Task control block ptr */ NU_SUPERV_USER_VARIABLES /* Switch to supervisor mode */ NU_SUPERVISOR_MODE(); /* Move input task control block pointer into internal pointer. */ task = (TC_TCB *) task_ptr; #ifdef NU_ENABLE_STACK_CHECK /* Call stack checking function to check for an overflow condition. */ TCT_Check_Stack(); #endif #ifdef NU_ENABLE_HISTORY /* Make an entry that corresponds to this function in the system history log. */ HIC_Make_History_Entry(NU_SEND_SIGNALS_ID, (UNSIGNED) signals, (UNSIGNED) 0, (UNSIGNED) 0); #endif /* Protect against simultaneous access. */ TCT_Protect(&TCD_System_Protect); /* Or the new signals into the current signals. */ task -> tc_signals = task -> tc_signals | signals; #ifdef INCLUDE_PROVIEW _RTProf_DumpTask(task,RT_PROF_SEND_SIGNALS); #endif /* Now, determine if the signal handler needs to be invoked. */ if ((task -> tc_signals & task -> tc_enabled_signals) && (!task -> tc_signal_active) && (task -> tc_status != NU_TERMINATED) && (task -> tc_status != NU_FINISHED) && (task -> tc_signal_handler)) { /* Indicate that signal processing is in progress. */ task -> tc_signal_active = NU_TRUE; /* Signal processing is required. Determine if the task is sending signals to itself or if the calling thread is not the current task. */ if (task == (TC_TCB *) TCD_Current_Thread) { /* Task sending signals to itself. */ /* Clear the saved stack pointer to indicate that this is an in line signal handler call. */ task -> tc_saved_stack_ptr = NU_NULL; /* Release protection from multiple access. */ TCT_Unprotect(); /* Call the signal handling shell. */ TCC_Signal_Shell(); } else { /* Target task must be prepared to receive the signals. */ /* First, insure that the target task is not in a protected area. */ do { /* Check for protection. Remember that protection is still in effect. */ if (task -> tc_current_protect) { /* Yes, target task is in a protected mode. Release the protection on the scheduling list and transfer control briefly to the target task. */ TCT_Unprotect(); /* Switch to the protected task and wait until the task is not protected. */ TCT_Protect_Switch(task); /* Restore protection on the scheduling structures. */ TCT_Protect(&TCD_System_Protect); } } while (task -> tc_current_protect); /* Copy the current status and stack pointer to the signal save areas. */ task -> tc_saved_status = task -> tc_status; task -> tc_saved_stack_ptr = task -> tc_stack_pointer; /* Build a stack frame for the signal handling shell function. */ TCT_Build_Signal_Frame(task); /* Determine if the target task is currently suspended. If it is suspended for any other reason than a pure suspend, resume it. */ if ((task -> tc_status != NU_READY) && (task -> tc_status != NU_PURE_SUSPEND)) { /* Resume the target task and check for preemption. */ if (TCC_Resume_Task(task_ptr, task -> tc_status)) /* Preemption needs to take place. */ TCT_Control_To_System(); } } } /* Release protection, no signals are currently enabled. */ TCT_Unprotect(); /* Return to user mode */ NU_USER_MODE(); /* Return a successful status. */ return(NU_SUCCESS); }