source: rtems/cpukit/score/src/thread.c @ 3652ad35

4.104.114.84.95
Last change on this file since 3652ad35 was b3ac6a8d, checked in by Joel Sherrill <joel.sherrill@…>, on Sep 12, 1995 at 7:45:42 PM

Initial attempt at building HP PA-RISC using Solaris hosted tools.

Changed back to Newlib for Solaris UNIX simulator.

  • Property mode set to 100644
File size: 24.5 KB
Line 
1/*
2 *  Thread Handler
3 *
4 *
5 *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
6 *  On-Line Applications Research Corporation (OAR).
7 *  All rights assigned to U.S. Government, 1994.
8 *
9 *  This material may be reproduced by or for the U.S. Government pursuant
10 *  to the copyright license under the clause at DFARS 252.227-7013.  This
11 *  notice must appear in all copies of this file and its derivatives.
12 *
13 *  $Id$
14 */
15
16#include <rtems/system.h>
17#include <rtems/core/context.h>
18#include <rtems/core/interr.h>
19#include <rtems/core/intthrd.h>
20#include <rtems/core/isr.h>
21#include <rtems/core/object.h>
22#include <rtems/core/priority.h>
23#include <rtems/core/states.h>
24#include <rtems/core/thread.h>
25#include <rtems/core/threadq.h>
26#include <rtems/core/userext.h>
27#include <rtems/core/wkspace.h>
28
29/*PAGE
30 *
31 *  _Thread_Handler_initialization
32 *
33 *  This routine initializes all thread manager related data structures.
34 *
35 *  Input parameters:
36 *    ticks_per_timeslice - clock ticks per quantum
37 *    maximum_proxies     - number of proxies to initialize
38 *
39 *  Output parameters:  NONE
40 */
41
42void _Thread_Handler_initialization(
43  unsigned32   ticks_per_timeslice,
44  unsigned32   maximum_extensions,
45  unsigned32   maximum_proxies
46)
47{
48  unsigned32 index;
49
50  _Context_Switch_necessary = FALSE;
51  _Thread_Executing         = NULL;
52  _Thread_Heir              = NULL;
53  _Thread_Allocated_fp      = NULL;
54
55  _Thread_Maximum_extensions = maximum_extensions;
56
57  _Thread_Ticks_remaining_in_timeslice = ticks_per_timeslice;
58  _Thread_Ticks_per_timeslice          = ticks_per_timeslice;
59
60  _Thread_Ready_chain = _Workspace_Allocate_or_fatal_error(
61    (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control)
62  );
63
64  for ( index=0; index <= PRIORITY_MAXIMUM ; index++ )
65    _Chain_Initialize_empty( &_Thread_Ready_chain[ index ] );
66
67  _Thread_MP_Handler_initialization( maximum_proxies );
68}
69
70/*PAGE
71 *
72 *  _Thread_Start_multitasking
73 *
74 *  This kernel routine readies the requested thread, the thread chain
75 *  is adjusted.  A new heir thread may be selected.
76 *
77 *  Input parameters:
78 *    system_thread - pointer to system initialization thread control block
79 *    idle_thread   - pointer to idle thread control block
80 *
81 *  Output parameters:  NONE
82 *
83 *  NOTE:  This routine uses the "blocking" heir selection mechanism.
84 *         This insures the correct heir after a thread restart.
85 *
86 *  INTERRUPT LATENCY:
87 *    ready chain
88 *    select heir
89 */
90
91void _Thread_Start_multitasking(
92  Thread_Control *system_thread,
93  Thread_Control *idle_thread
94)
95{
96
97   _Thread_Executing  =
98   _Thread_Heir       =
99   _Thread_MP_Receive = system_thread;
100
101   /*
102    *  Scheduling will not work "correctly" until the above
103    *  statements have been executed.
104    */
105
106   _Thread_Ready( system_thread );
107   _Thread_Ready( idle_thread );
108
109   _Context_Switch_necessary = FALSE;
110
111   _Context_Switch( &_Thread_BSP_context, &system_thread->Registers );
112
113}
114
115/*PAGE
116 *
117 *  _Thread_Dispatch
118 *
119 *  This kernel routine determines if a dispatch is needed, and if so
120 *  dispatches to the heir thread.  Once the heir is running an attempt
121 *  is made to dispatch any ASRs.
122 *
123 *  ALTERNATE ENTRY POINTS:
124 *    void _Thread_Enable_dispatch();
125 *
126 *  Input parameters:  NONE
127 *
128 *  Output parameters:  NONE
129 *
130 *  INTERRUPT LATENCY:
131 *    dispatch thread
132 *    no dispatch thread
133 */
134
135#if ( CPU_INLINE_ENABLE_DISPATCH == FALSE )
136void _Thread_Enable_dispatch( void )
137{
138  if ( --_Thread_Dispatch_disable_level )
139    return;
140  _Thread_Dispatch();
141}
142#endif
143
144void _Thread_Dispatch( void )
145{
146  Thread_Control   *executing;
147  Thread_Control   *heir;
148  ISR_Level         level;
149
150  executing   = _Thread_Executing;
151  _ISR_Disable( level );
152  while ( _Context_Switch_necessary == TRUE ) {
153    heir = _Thread_Heir;
154    _Thread_Dispatch_disable_level = 1;
155    _Context_Switch_necessary = FALSE;
156    _Thread_Executing = heir;
157    _ISR_Enable( level );
158
159    _User_extensions_Thread_switch( executing, heir );
160
161    _Thread_Ticks_remaining_in_timeslice = _Thread_Ticks_per_timeslice;
162
163    /*
164     *  If the CPU has hardware floating point, then we must address saving
165     *  and restoring it as part of the context switch.
166     *
167     *  The second conditional compilation section selects the algorithm used
168     *  to context switch between floating point tasks.  The deferred algorithm
169     *  can be significantly better in a system with few floating point tasks
170     *  because it reduces the total number of save and restore FP context
171     *  operations.  However, this algorithm can not be used on all CPUs due
172     *  to unpredictable use of FP registers by some compilers for integer
173     *  operations.
174     */
175
176#if ( CPU_HARDWARE_FP == TRUE )
177#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
178    if ( (heir->fp_context != NULL) && !_Thread_Is_allocated_fp( heir ) ) {
179      if ( _Thread_Allocated_fp != NULL )
180        _Context_Save_fp( &_Thread_Allocated_fp->fp_context );
181      _Context_Restore_fp( &heir->fp_context );
182      _Thread_Allocated_fp = heir;
183    }
184#else
185    if ( executing->fp_context != NULL )
186      _Context_Save_fp( &executing->fp_context );
187
188    if ( heir->fp_context != NULL )
189      _Context_Restore_fp( &heir->fp_context );
190#endif
191#endif
192
193    _Context_Switch( &executing->Registers, &heir->Registers );
194
195    executing = _Thread_Executing;
196
197    _ISR_Disable( level );
198  }
199
200  _Thread_Dispatch_disable_level = 0;
201
202  _ISR_Enable( level );
203
204  _User_extensions_Thread_post_switch( executing );
205 
206}
207
208/*PAGE
209 *
210 *  _Thread_Initialize
211 *
212 *  XXX
213 */
214
215boolean _Thread_Initialize(
216  Objects_Information *information,
217  Thread_Control      *the_thread,
218  void                *stack_area,    /* NULL if to be allocated */
219  unsigned32           stack_size,    /* insure it is >= min */
220  boolean              is_fp,         /* TRUE if thread uses FP */
221  Priority_Control     priority,
222  boolean              is_preemptible,
223  boolean              is_timeslice,
224  unsigned32           isr_level,
225  Objects_Name         name
226 
227)
228{
229  unsigned32           actual_stack_size;
230  void                *stack;
231  void                *fp_area;
232  void                *extensions_area;
233
234  /*
235   *  Allocate and Initialize the stack for this thread.
236   */
237
238  if ( !_Stack_Is_enough( stack_size ) )
239    actual_stack_size = STACK_MINIMUM_SIZE;
240  else
241    actual_stack_size = stack_size;
242
243  actual_stack_size = _Stack_Adjust_size( actual_stack_size );
244  stack             = stack_area;
245
246  if ( !stack ) {
247    stack = _Workspace_Allocate( actual_stack_size );
248 
249    if ( !stack ) 
250      return FALSE;
251
252    the_thread->Start.stack = stack;
253  } else
254    the_thread->Start.stack = NULL;
255
256  _Stack_Initialize(
257     &the_thread->Start.Initial_stack,
258     stack,
259     actual_stack_size
260  );
261
262  /*
263   *  Allocate the floating point area for this thread
264   */
265 
266  if ( is_fp ) {
267
268    fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
269    if ( !fp_area ) {
270      if ( the_thread->Start.stack )
271        (void) _Workspace_Free( the_thread->Start.stack );
272      return FALSE;
273    }
274    fp_area = _Context_Fp_start( fp_area, 0 );
275
276  } else
277    fp_area = NULL;
278
279  the_thread->fp_context       = fp_area;
280  the_thread->Start.fp_context = fp_area;
281 
282
283  /*
284   *  Allocate the floating point area for this thread
285   */
286
287  if ( _Thread_Maximum_extensions ) {
288    extensions_area = _Workspace_Allocate(
289      (_Thread_Maximum_extensions + 1) * sizeof( void * )
290    );
291
292    if ( !extensions_area ) {
293      if ( fp_area )
294        (void) _Workspace_Free( fp_area );
295
296      if ( the_thread->Start.stack )
297        (void) _Workspace_Free( the_thread->Start.stack );
298
299      return FALSE;
300    }
301  } else 
302    extensions_area = NULL;
303 
304  the_thread->extensions = extensions_area;
305
306  /*
307   *  General initialization
308   */
309
310  the_thread->Start.is_preemptible = is_preemptible;
311  the_thread->Start.is_timeslice   = is_timeslice;
312  the_thread->Start.isr_level      = isr_level;
313
314  the_thread->current_state          = STATES_DORMANT;
315  the_thread->resource_count         = 0;
316  the_thread->real_priority          = priority;
317  the_thread->Start.initial_priority = priority;
318 
319  _Thread_Set_priority( the_thread, priority );
320
321  /*
322   *  Open the object
323   */
324
325  _Objects_Open( information, &the_thread->Object, name );
326
327  /*
328   *  Invoke create extensions
329   */
330
331  if ( !_User_extensions_Thread_create( the_thread ) ) {
332
333    if ( extensions_area )
334      (void) _Workspace_Free( extensions_area );
335
336    if ( fp_area )
337      (void) _Workspace_Free( fp_area );
338
339    if ( the_thread->Start.stack )
340      (void) _Workspace_Free( the_thread->Start.stack );
341
342    return FALSE;
343  }
344
345  return TRUE;
346   
347}
348
349/*
350 *  _Thread_Start
351 *
352 *  DESCRIPTION:
353 *
354 *  XXX
355 */
356 
357boolean _Thread_Start(
358  Thread_Control       *the_thread,
359  Thread_Start_types    the_prototype,
360  void                 *entry_point,
361  void                 *pointer_argument,
362  unsigned32            numeric_argument
363)
364{
365  if ( _States_Is_dormant( the_thread->current_state ) ) {
366 
367    the_thread->Start.entry_point      = entry_point;
368   
369    the_thread->Start.prototype        = the_prototype;
370    the_thread->Start.pointer_argument = pointer_argument;
371    the_thread->Start.numeric_argument = numeric_argument;
372 
373    _Thread_Load_environment( the_thread );
374 
375    _Thread_Ready( the_thread );
376 
377    _User_extensions_Thread_start( the_thread );
378 
379    return TRUE;
380  }
381 
382  return FALSE;
383 
384}
385
386/*
387 *  _Thread_Restart
388 *
389 *  DESCRIPTION:
390 *
391 *  XXX
392 */
393 
394boolean _Thread_Restart(
395  Thread_Control      *the_thread,
396  void                *pointer_argument,
397  unsigned32           numeric_argument
398)
399{
400  if ( !_States_Is_dormant( the_thread->current_state ) ) {
401 
402    _Thread_Set_transient( the_thread );
403    the_thread->resource_count = 0;
404    the_thread->is_preemptible = the_thread->Start.is_preemptible;
405    the_thread->is_timeslice   = the_thread->Start.is_timeslice;
406
407    the_thread->Start.pointer_argument = pointer_argument;
408    the_thread->Start.numeric_argument = numeric_argument;
409 
410    if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
411 
412      if ( _Watchdog_Is_active( &the_thread->Timer ) )
413        (void) _Watchdog_Remove( &the_thread->Timer );
414    }
415
416    if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
417      the_thread->real_priority = the_thread->Start.initial_priority;
418      _Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
419    }
420 
421    _Thread_Load_environment( the_thread );
422 
423    _Thread_Ready( the_thread );
424 
425    _User_extensions_Thread_restart( the_thread );
426 
427    if ( _Thread_Is_executing ( the_thread ) )
428      _Thread_Restart_self();
429 
430    return TRUE;
431  }
432 
433  return FALSE;
434}
435
436/*
437 *  _Thread_Close
438 *
439 *  DESCRIPTION:
440 *
441 *  XXX
442 */
443 
444void _Thread_Close(
445  Objects_Information  *information,
446  Thread_Control       *the_thread
447)
448{
449  _Objects_Close( information, &the_thread->Object );
450 
451  _Thread_Set_state( the_thread, STATES_TRANSIENT );
452 
453  if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
454 
455    if ( _Watchdog_Is_active( &the_thread->Timer ) )
456      (void) _Watchdog_Remove( &the_thread->Timer );
457  }
458
459  _User_extensions_Thread_delete( the_thread );
460 
461#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
462  if ( _Thread_Is_allocated_fp( the_thread ) )
463    _Thread_Deallocate_fp();
464#endif
465  the_thread->fp_context = NULL;
466
467  (void) _Workspace_Free( the_thread->Start.fp_context );
468
469  if ( the_thread->Start.stack )
470    (void) _Workspace_Free( the_thread->Start.stack );
471
472  if ( the_thread->extensions )
473    (void) _Workspace_Free( the_thread->extensions );
474
475  the_thread->Start.stack = NULL;
476  the_thread->extensions = NULL;
477}
478
479/*PAGE
480 *
481 *  _Thread_Ready
482 *
483 *  This kernel routine readies the requested thread, the thread chain
484 *  is adjusted.  A new heir thread may be selected.
485 *
486 *  Input parameters:
487 *    the_thread - pointer to thread control block
488 *
489 *  Output parameters:  NONE
490 *
491 *  NOTE:  This routine uses the "blocking" heir selection mechanism.
492 *         This insures the correct heir after a thread restart.
493 *
494 *  INTERRUPT LATENCY:
495 *    ready chain
496 *    select heir
497 */
498
499void _Thread_Ready(
500  Thread_Control *the_thread
501)
502{
503  ISR_Level              level;
504  Thread_Control *heir;
505
506  _ISR_Disable( level );
507
508  the_thread->current_state = STATES_READY;
509
510  _Priority_Add_to_bit_map( &the_thread->Priority_map );
511
512  _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );
513
514  _ISR_Flash( level );
515
516  _Thread_Calculate_heir();
517
518  heir = _Thread_Heir;
519
520  if ( !_Thread_Is_executing( heir ) && _Thread_Executing->is_preemptible ) 
521    _Context_Switch_necessary = TRUE;
522
523  _ISR_Enable( level );
524}
525
526/*PAGE
527 *
528 *  _Thread_Clear_state
529 *
530 *  This kernel routine clears the appropriate states in the
531 *  requested thread.  The thread ready chain is adjusted if
532 *  necessary and the Heir thread is set accordingly.
533 *
534 *  Input parameters:
535 *    the_thread - pointer to thread control block
536 *    state      - state set to clear
537 *
538 *  Output parameters:  NONE
539 *
540 *  INTERRUPT LATENCY:
541 *    priority map
542 *    select heir
543 */
544
545void _Thread_Clear_state(
546  Thread_Control *the_thread,
547  States_Control  state
548)
549{
550  ISR_Level level;
551
552  _ISR_Disable( level );
553    the_thread->current_state =
554      _States_Clear( state, the_thread->current_state );
555
556    if ( _States_Is_ready( the_thread->current_state ) ) {
557
558      _Priority_Add_to_bit_map( &the_thread->Priority_map );
559
560      _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );
561
562      _ISR_Flash( level );
563
564      if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
565        _Thread_Heir = the_thread;
566        if ( _Thread_Executing->is_preemptible ||
567             the_thread->current_priority == 0 )
568          _Context_Switch_necessary = TRUE;
569      }
570    }
571  _ISR_Enable( level );
572}
573
574/*PAGE
575 *
576 * _Thread_Set_state
577 *
578 * This kernel routine sets the requested state in the THREAD.  The
579 * THREAD chain is adjusted if necessary.
580 *
581 * Input parameters:
582 *   the_thread   - pointer to thread control block
583 *   state - state to be set
584 *
585 * Output parameters:  NONE
586 *
587 *  INTERRUPT LATENCY:
588 *    ready chain
589 *    select map
590 */
591
592void _Thread_Set_state(
593  Thread_Control *the_thread,
594  States_Control         state
595)
596{
597  ISR_Level             level;
598  Chain_Control *ready;
599
600  ready = the_thread->ready;
601  _ISR_Disable( level );
602  if ( !_States_Is_ready( the_thread->current_state ) ) {
603    the_thread->current_state =
604       _States_Set( state, the_thread->current_state );
605    _ISR_Enable( level );
606    return;
607  }
608
609  the_thread->current_state = state;
610
611  if ( _Chain_Has_only_one_node( ready ) ) {
612
613    _Chain_Initialize_empty( ready );
614    _Priority_Remove_from_bit_map( &the_thread->Priority_map );
615
616  } else
617    _Chain_Extract_unprotected( &the_thread->Object.Node );
618
619  _ISR_Flash( level );
620
621  if ( _Thread_Is_heir( the_thread ) )
622     _Thread_Calculate_heir();
623
624  if ( _Thread_Is_executing( the_thread ) )
625    _Context_Switch_necessary = TRUE;
626
627  _ISR_Enable( level );
628}
629
630/*PAGE
631 *
632 *  _Thread_Set_transient
633 *
634 *  This kernel routine places the requested thread in the transient state
635 *  which will remove it from the ready queue, if necessary.  No
636 *  rescheduling is necessary because it is assumed that the transient
637 *  state will be cleared before dispatching is enabled.
638 *
639 *  Input parameters:
640 *    the_thread - pointer to thread control block
641 *
642 *  Output parameters:  NONE
643 *
644 *  INTERRUPT LATENCY:
645 *    only case
646 */
647
648void _Thread_Set_transient(
649  Thread_Control *the_thread
650)
651{
652  ISR_Level             level;
653  unsigned32            old_state;
654  Chain_Control *ready;
655
656  ready = the_thread->ready;
657  _ISR_Disable( level );
658
659  old_state = the_thread->current_state;
660  the_thread->current_state = _States_Set( STATES_TRANSIENT, old_state );
661
662  if ( _States_Is_ready( old_state ) ) {
663    if ( _Chain_Has_only_one_node( ready ) ) {
664
665      _Chain_Initialize_empty( ready );
666      _Priority_Remove_from_bit_map( &the_thread->Priority_map );
667
668    } else
669      _Chain_Extract_unprotected( &the_thread->Object.Node );
670  }
671
672  _ISR_Enable( level );
673
674}
675
676/*PAGE
677 *
678 *  _Thread_Reset_timeslice
679 *
680 *  This routine will remove the running thread from the ready chain
681 *  and place it immediately at the rear of this chain and then the
682 *  timeslice counter is reset.  The heir THREAD will be updated if
683 *  the running is also the currently the heir.
684 *
685 *  Input parameters:   NONE
686 *
687 *  Output parameters:  NONE
688 *
689 *  INTERRUPT LATENCY:
690 *    ready chain
691 *    select heir
692 */
693
694void _Thread_Reset_timeslice( void )
695{
696  ISR_Level              level;
697  Thread_Control *executing;
698  Chain_Control  *ready;
699
700  executing = _Thread_Executing;
701  ready     = executing->ready;
702  _ISR_Disable( level );
703    if ( _Chain_Has_only_one_node( ready ) ) {
704      _Thread_Ticks_remaining_in_timeslice = _Thread_Ticks_per_timeslice;
705      _ISR_Enable( level );
706      return;
707    }
708    _Chain_Extract_unprotected( &executing->Object.Node );
709    _Chain_Append_unprotected( ready, &executing->Object.Node );
710
711  _ISR_Flash( level );
712
713    if ( _Thread_Is_heir( executing ) )
714      _Thread_Heir = (Thread_Control *) ready->first;
715
716    _Context_Switch_necessary = TRUE;
717
718  _ISR_Enable( level );
719}
720
721/*PAGE
722 *
723 *  _Thread_Tickle_timeslice
724 *
725 *  This scheduler routine determines if timeslicing is enabled
726 *  for the currently executing thread and, if so, updates the
727 *  timeslice count and checks for timeslice expiration.
728 *
729 *  Input parameters:   NONE
730 *
731 *  Output parameters:  NONE
732 */
733
734void _Thread_Tickle_timeslice( void )
735{
736  if ( !_Thread_Executing->is_timeslice  ||
737       !_Thread_Executing->is_preemptible ||
738       !_States_Is_ready( _Thread_Executing->current_state ) ) 
739    return;
740
741  if ( --_Thread_Ticks_remaining_in_timeslice == 0 ) {
742      _Thread_Reset_timeslice();
743  }
744}
745
746/*PAGE
747 *
748 *  _Thread_Yield_processor
749 *
750 *  This kernel routine will remove the running THREAD from the ready chain
751 *  and place it immediatly at the rear of this chain.  Reset timeslice
752 *  and yield the processor functions both use this routine, therefore if
753 *  reset is TRUE and this is the only thread on the chain then the
754 *  timeslice counter is reset.  The heir THREAD will be updated if the
755 *  running is also the currently the heir.
756 *
757 *  Input parameters:   NONE
758 *
759 *  Output parameters:  NONE
760 *
761 *  INTERRUPT LATENCY:
762 *    ready chain
763 *    select heir
764 */
765
766void _Thread_Yield_processor( void )
767{
768  ISR_Level       level;
769  Thread_Control *executing;
770  Chain_Control  *ready;
771
772  executing = _Thread_Executing;
773  ready     = executing->ready;
774  _ISR_Disable( level );
775    if ( !_Chain_Has_only_one_node( ready ) ) {
776      _Chain_Extract_unprotected( &executing->Object.Node );
777      _Chain_Append_unprotected( ready, &executing->Object.Node );
778
779      _ISR_Flash( level );
780
781      if ( _Thread_Is_heir( executing ) )
782        _Thread_Heir = (Thread_Control *) ready->first;
783      _Context_Switch_necessary = TRUE;
784    }
785    else if ( !_Thread_Is_heir( executing ) )
786      _Context_Switch_necessary = TRUE;
787
788  _ISR_Enable( level );
789}
790
791/*PAGE
792 *
793 *  _Thread_Load_environment
794 *
795 *  Load starting environment for another thread from its start area in the
796 *  thread.  Only called from t_restart and t_start.
797 *
798 *  Input parameters:
799 *    the_thread - thread control block pointer
800 *
801 *  Output parameters:  NONE
802 */
803
804void _Thread_Load_environment(
805  Thread_Control *the_thread
806)
807{
808  if ( the_thread->Start.fp_context ) {
809    the_thread->fp_context = the_thread->Start.fp_context;
810    _Context_Initialize_fp( &the_thread->fp_context );
811  }
812
813  the_thread->is_preemptible = the_thread->Start.is_preemptible;
814  the_thread->is_timeslice   = the_thread->Start.is_timeslice;
815
816  _Context_Initialize(
817    &the_thread->Registers,
818    the_thread->Start.Initial_stack.area,
819    the_thread->Start.Initial_stack.size,
820    the_thread->Start.isr_level,
821    _Thread_Handler
822  );
823
824}
825
826/*PAGE
827 *
828 *  _Thread_Handler
829 *
830 *  This routine is the default thread exitted error handler.  It is
831 *  returned to when a thread exits.  The configured fatal error handler
832 *  is invoked to process the exit.
833 *
834 *  Input parameters:   NONE
835 *
836 *  Output parameters:  NONE
837 */
838
839void _Thread_Handler( void )
840{
841  Thread_Control *executing;
842
843  executing = _Thread_Executing;
844
845  /*
846   * Take care that 'begin' extensions get to complete before
847   * 'switch' extensions can run.  This means must keep dispatch
848   * disabled until all 'begin' extensions complete.
849   */
850 
851  _User_extensions_Thread_begin( executing );
852 
853  /*
854   *  At this point, the dispatch disable level BETTER be 1.
855   */
856
857  _Thread_Enable_dispatch();
858 
859  switch ( executing->Start.prototype ) {
860    case THREAD_START_NUMERIC:
861      (*executing->Start.entry_point)( executing->Start.numeric_argument );
862      break;
863    case THREAD_START_POINTER:
864      (*executing->Start.entry_point)( executing->Start.pointer_argument );
865      break;
866    case THREAD_START_BOTH_POINTER_FIRST:
867      (*executing->Start.entry_point)( 
868        executing->Start.pointer_argument,
869        executing->Start.numeric_argument
870      );
871      break;
872    case THREAD_START_BOTH_NUMERIC_FIRST:
873      (*executing->Start.entry_point)( 
874        executing->Start.numeric_argument,
875        executing->Start.pointer_argument
876      );
877      break;
878  }
879
880  _User_extensions_Thread_exitted( executing );
881
882  _Internal_error_Occurred(
883    INTERNAL_ERROR_CORE,
884    TRUE,
885    INTERNAL_ERROR_THREAD_EXITTED
886  );
887}
888
889/*PAGE
890 *
891 *  _Thread_Delay_ended
892 *
893 *  This routine processes a thread whose delay period has ended.
894 *  It is called by the watchdog handler.
895 *
896 *  Input parameters:
897 *    id - thread id
898 *
899 *  Output parameters: NONE
900 */
901
902void _Thread_Delay_ended(
903  Objects_Id  id,
904  void       *ignored
905)
906{
907  Thread_Control    *the_thread;
908  Objects_Locations  location;
909
910  the_thread = _Thread_Get( id, &location );
911  switch ( location ) {
912    case OBJECTS_ERROR:
913    case OBJECTS_REMOTE:  /* impossible */
914      break;
915    case OBJECTS_LOCAL:
916      _Thread_Unblock( the_thread );
917      _Thread_Unnest_dispatch();
918      break;
919  }
920}
921
922/*PAGE
923 *
924 *  _Thread_Change_priority
925 *
926 *  This kernel routine changes the priority of the thread.  The
927 *  thread chain is adjusted if necessary.
928 *
929 *  Input parameters:
930 *    the_thread   - pointer to thread control block
931 *    new_priority - ultimate priority
932 *
933 *  Output parameters:  NONE
934 *
935 *  INTERRUPT LATENCY:
936 *    ready chain
937 *    select heir
938 */
939
940void _Thread_Change_priority(
941  Thread_Control   *the_thread,
942  Priority_Control  new_priority
943)
944{
945  ISR_Level level;
946
947  _Thread_Set_transient( the_thread );
948
949  if ( the_thread->current_priority != new_priority )
950    _Thread_Set_priority( the_thread, new_priority );
951
952  _ISR_Disable( level );
953
954  the_thread->current_state =
955    _States_Clear( STATES_TRANSIENT, the_thread->current_state );
956
957  if ( ! _States_Is_ready( the_thread->current_state ) ) {
958    _ISR_Enable( level );
959    return;
960  }
961
962  _Priority_Add_to_bit_map( &the_thread->Priority_map );
963  _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );
964
965  _ISR_Flash( level );
966
967  _Thread_Calculate_heir();
968
969  if ( !_Thread_Is_executing_also_the_heir() &&
970       _Thread_Executing->is_preemptible )
971    _Context_Switch_necessary = TRUE;
972
973  _ISR_Enable( level );
974}
975
976/*PAGE
977 *
978 * _Thread_Set_priority
979 *
980 * This directive enables and disables several modes of
981 * execution for the requesting thread.
982 *
983 *  Input parameters:
984 *    the_thread   - pointer to thread priority
985 *    new_priority - new priority
986 *
987 *  Output: NONE
988 */
989
990void _Thread_Set_priority(
991  Thread_Control   *the_thread,
992  Priority_Control  new_priority
993)
994{
995  the_thread->current_priority = new_priority;
996  the_thread->ready            = &_Thread_Ready_chain[ new_priority ];
997
998  _Priority_Initialize_information( &the_thread->Priority_map, new_priority );
999}
1000
1001/*PAGE
1002 *
1003 *  _Thread_Evaluate_mode
1004 *
1005 *  XXX
1006 */
1007
1008boolean _Thread_Evaluate_mode( void )
1009{
1010  Thread_Control     *executing;
1011
1012  executing = _Thread_Executing;
1013
1014  if ( !_States_Is_ready( executing->current_state ) ||
1015       ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
1016    _Context_Switch_necessary = TRUE;
1017    return TRUE;
1018  }
1019
1020  return FALSE;
1021}
1022
1023/*PAGE
1024 *
1025 *  _Thread_Get
1026 *
1027 *  NOTE:  If we are not using static inlines, this must be a real
1028 *         subroutine call.
1029 *
1030 *  NOTE:  XXX... This routine may be able to be optimized.
1031 */
1032
1033#ifndef USE_INLINES
1034
1035STATIC INLINE Thread_Control *_Thread_Get (
1036  Objects_Id           id,
1037  Objects_Locations   *location
1038)
1039{
1040  Objects_Classes      the_class;
1041  Objects_Information *information;
1042 
1043  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
1044    _Thread_Disable_dispatch();
1045    *location = OBJECTS_LOCAL;
1046    return( _Thread_Executing );
1047  }
1048 
1049  the_class = _Objects_Get_class( id );
1050 
1051  if ( the_class > OBJECTS_CLASSES_LAST ) {
1052    *location = OBJECTS_ERROR;
1053    return (Thread_Control *) 0;
1054  } 
1055 
1056  information = _Objects_Information_table[ the_class ];
1057 
1058  if ( !information || !information->is_thread ) { 
1059    *location = OBJECTS_ERROR;
1060    return (Thread_Control *) 0;
1061  }
1062 
1063  return (Thread_Control *) _Objects_Get( information, id, location );
1064}
1065#endif
Note: See TracBrowser for help on using the repository browser.