source: rtems/cpukit/score/inline/rtems/score/coremutex.inl @ 34a26792

4.104.114.84.95
Last change on this file since 34a26792 was 34a26792, checked in by Joel Sherrill <joel.sherrill@…>, on 07/06/00 at 20:01:43

Added missing #endif's.

  • Property mode set to 100644
File size: 4.6 KB
Line 
1/*  inline/coremutex.inl
2 *
3 *  This include file contains all of the inlined routines associated
4 *  with the CORE mutexes.
5 *
6 *  COPYRIGHT (c) 1989-1999.
7 *  On-Line Applications Research Corporation (OAR).
8 *
9 *  The license and distribution terms for this file may be
10 *  found in the file LICENSE in this distribution or at
11 *  http://www.OARcorp.com/rtems/license.html.
12 *
13 *  $Id$
14 */
15
16#ifndef __INLINE_CORE_MUTEX_inl
17#define __INLINE_CORE_MUTEX_inl
18
19/*PAGE
20 *
21 *  _CORE_mutex_Is_locked
22 *
23 *  DESCRIPTION:
24 *
25 *  This routine returns TRUE if the mutex specified is locked and FALSE
26 *  otherwise.
27 */
28 
29RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_locked(
30  CORE_mutex_Control  *the_mutex
31)
32{
33  return the_mutex->lock == CORE_MUTEX_LOCKED;
34}
35 
36/*PAGE
37 *
38 *  _CORE_mutex_Is_fifo
39 *
40 *  DESCRIPTION:
41 *
42 *  This routine returns TRUE if the mutex's wait discipline is FIFO and FALSE
43 *  otherwise.
44 */
45 
46RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_fifo(
47  CORE_mutex_Attributes *the_attribute
48)
49{
50  return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_FIFO;
51}
52 
53/*PAGE
54 *
55 *  _CORE_mutex_Is_priority
56 *
57 *  DESCRIPTION:
58 *
59 *  This routine returns TRUE if the mutex's wait discipline is PRIORITY and
60 *  FALSE otherwise.
61 */
62 
63RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_priority(
64  CORE_mutex_Attributes *the_attribute
65)
66{
67  return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY;
68}
69 
70/*PAGE
71 *
72 *  _CORE_mutex_Is_inherit_priority
73 *
74 *  DESCRIPTION:
75 *
76 *  This routine returns TRUE if the mutex's wait discipline is
77 *  INHERIT_PRIORITY and FALSE otherwise.
78 */
79 
80RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority(
81  CORE_mutex_Attributes *the_attribute
82)
83{
84  return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
85}
86 
87/*PAGE
88 *
89 *  _CORE_mutex_Is_priority_ceiling
90 *
91 *  DESCRIPTION:
92 *
93 *  This routine returns TRUE if the mutex's wait discipline is
94 *  PRIORITY_CEILING and FALSE otherwise.
95 */
96 
97RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_priority_ceiling(
98  CORE_mutex_Attributes *the_attribute
99)
100{
101  return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
102}
103 
104/*PAGE
105 *
106 *  _CORE_mutex_Seize_interrupt_trylock
107 *
108 *  DESCRIPTION:
109 *
110 *  This routine returns 0 if "trylock" can resolve whether or not the
111 *  mutex is immediately obtained or there was an error attempting to
112 *  get it.  It returns 1 to indicate that the caller cannot obtain
113 *  the mutex and will have to block to do so.
114 *
115 *  NOTE: There is no MACRO version of this routine.
116 */
117
118RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock(
119  CORE_mutex_Control  *the_mutex,
120  ISR_Level           *level_p
121)
122{
123  Thread_Control   *executing;
124  ISR_Level         level = *level_p;
125
126  /* disabled when you get here */
127
128  executing = _Thread_Executing;
129  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
130  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
131    the_mutex->lock       = CORE_MUTEX_LOCKED;
132    the_mutex->holder     = executing;
133    the_mutex->holder_id  = executing->Object.id;
134    the_mutex->nest_count = 1;
135    executing->resource_count++;
136    if ( the_mutex->Attributes.discipline !=
137           CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING ) {
138        _ISR_Enable( level );
139        return 0;
140    }
141    /* else must be CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING */
142    {
143       Priority_Control  ceiling;
144       Priority_Control  current;
145
146       ceiling = the_mutex->Attributes.priority_ceiling;
147       current = executing->current_priority;
148       if ( current == ceiling ) {
149         _ISR_Enable( level );
150         return 0;
151       }
152       if ( current > ceiling ) {
153        _Thread_Disable_dispatch();
154        _ISR_Enable( level );
155        _Thread_Change_priority(
156          the_mutex->holder,
157          the_mutex->Attributes.priority_ceiling,
158          FALSE
159        );
160        _Thread_Enable_dispatch();
161        return 0;
162      }
163      /* if ( current < ceiling ) */ {
164        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
165        the_mutex->nest_count = 0;     /* undo locking above */
166        executing->resource_count--;   /* undo locking above */
167        _ISR_Enable( level );
168        return 0;
169      }
170    }
171    return 0;
172  }
173
174  if ( _Thread_Is_executing( the_mutex->holder ) ) {
175    switch ( the_mutex->Attributes.lock_nesting_behavior ) {
176      case CORE_MUTEX_NESTING_ACQUIRES:
177        the_mutex->nest_count++;
178        _ISR_Enable( level );
179        return 0;
180      case CORE_MUTEX_NESTING_IS_ERROR:
181        executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
182        _ISR_Enable( level );
183        return 0;
184      case CORE_MUTEX_NESTING_BLOCKS:
185        break;
186    }
187  }
188
189  return 1;
190}
191
192#endif
193/* end of include file */
Note: See TracBrowser for help on using the repository browser.