source: rtems/c/src/exec/score/src/coremutex.c @ 742b399

4.104.114.84.95
Last change on this file since 742b399 was 742b399, checked in by Joel Sherrill <joel.sherrill@…>, on Jun 3, 1996 at 9:08:26 PM

added priority ceiling support

  • Property mode set to 100644
File size: 8.2 KB
Line 
1/*
2 *  Mutex Handler
3 *
4 *  DESCRIPTION:
5 *
6 *  This package is the implementation of the Mutex Handler.
7 *  This handler provides synchronization and mutual exclusion capabilities.
8 *
9 *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
10 *  On-Line Applications Research Corporation (OAR).
11 *  All rights assigned to U.S. Government, 1994.
12 *
13 *  This material may be reproduced by or for the U.S. Government pursuant
14 *  to the copyright license under the clause at DFARS 252.227-7013.  This
15 *  notice must appear in all copies of this file and its derivatives.
16 *
17 *  $Id$
18 */
19
20#include <rtems/system.h>
21#include <rtems/score/isr.h>
22#include <rtems/score/coremutex.h>
23#include <rtems/score/states.h>
24#include <rtems/score/thread.h>
25#include <rtems/score/threadq.h>
26
27/*PAGE
28 *
29 *  _CORE_mutex_Initialize
30 *
31 *  This routine initializes a mutex at create time and set the control
32 *  structure according to the values passed.
33 *
34 *  Input parameters:
35 *    the_mutex             - the mutex control block to initialize
36 *    the_class             - the API class of the object
37 *    the_mutex_attributes  - the mutex attributes specified at create time
38 *    initial_lock          - mutex initial lock or unlocked status
39 *    proxy_extract_callout - MP specific extract callout
40 *
41 *  Output parameters:  NONE
42 */
43
44void _CORE_mutex_Initialize(
45  CORE_mutex_Control           *the_mutex,
46  Objects_Classes               the_class,
47  CORE_mutex_Attributes        *the_mutex_attributes,
48  unsigned32                    initial_lock,
49  Thread_queue_Extract_callout  proxy_extract_callout
50)
51{
52
53/* Add this to the RTEMS environment later ?????????
54  rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||
55                initial_lock == CORE_MUTEX_UNLOCKED );
56 */
57
58  the_mutex->Attributes = *the_mutex_attributes;
59  the_mutex->lock          = initial_lock;
60
61  if ( initial_lock == CORE_MUTEX_LOCKED ) {
62    the_mutex->nest_count = 1;
63    the_mutex->holder     = _Thread_Executing;
64    the_mutex->holder_id  = _Thread_Executing->Object.id;
65    _Thread_Executing->resource_count++;
66  } else {
67    the_mutex->nest_count = 0;
68    the_mutex->holder     = NULL;
69    the_mutex->holder_id  = 0;
70  }
71
72  _Thread_queue_Initialize(
73    &the_mutex->Wait_queue,
74    the_class,
75    _CORE_mutex_Is_priority( the_mutex_attributes ) ?
76      THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
77    STATES_WAITING_FOR_MUTEX,
78    proxy_extract_callout,
79    CORE_MUTEX_TIMEOUT
80  );
81}
82
83/*PAGE
84 *
85 *  _CORE_mutex_Seize
86 *
87 *  This routine attempts to allocate a mutex to the calling thread.
88 *
89 *  Input parameters:
90 *    the_mutex - pointer to mutex control block
91 *    id        - id of object to wait on
92 *    wait      - TRUE if wait is allowed, FALSE otherwise
93 *    timeout   - number of ticks to wait (0 means forever)
94 *
95 *  Output parameters:  NONE
96 *
97 *  INTERRUPT LATENCY:
98 *    available
99 *    wait
100 */
101
102void _CORE_mutex_Seize(
103  CORE_mutex_Control  *the_mutex,
104  Objects_Id           id,
105  boolean              wait,
106  Watchdog_Interval    timeout
107)
108{
109  Thread_Control *executing;
110  ISR_Level       level;
111
112  executing = _Thread_Executing;
113  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
114  _ISR_Disable( level );
115  if ( ! _CORE_mutex_Is_locked( the_mutex ) ) {
116    the_mutex->lock       = CORE_MUTEX_LOCKED;
117    the_mutex->holder     = executing;
118    the_mutex->holder_id  = executing->Object.id;
119    the_mutex->nest_count = 1;
120    executing->resource_count++;
121    _ISR_Enable( level );
122    return;
123  }
124
125  if ( _Objects_Are_ids_equal(
126              _Thread_Executing->Object.id, the_mutex->holder_id ) ) {
127    if ( _CORE_mutex_Is_nesting_allowed( &the_mutex->Attributes ) )
128      the_mutex->nest_count++;
129    else 
130      executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
131
132    _ISR_Enable( level );
133    return;
134  }
135
136  if ( !wait ) {
137    _ISR_Enable( level );
138    executing->Wait.return_code = CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT;
139    return;
140  }
141
142  _Thread_queue_Enter_critical_section( &the_mutex->Wait_queue );
143  executing->Wait.queue      = &the_mutex->Wait_queue;
144  executing->Wait.id         = id;
145  _ISR_Enable( level );
146
147  switch ( the_mutex->Attributes.discipline ) {
148    case CORE_MUTEX_DISCIPLINES_FIFO:
149    case CORE_MUTEX_DISCIPLINES_PRIORITY:
150    case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
151      break;
152    case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
153      if ( the_mutex->holder->current_priority > executing->current_priority ) {
154        _Thread_Change_priority(
155          the_mutex->holder,
156          executing->current_priority
157        );
158      }
159      break;
160  }
161
162  _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout );
163
164  if ( _Thread_Executing->Wait.return_code == CORE_MUTEX_STATUS_SUCCESSFUL ) {
165    switch ( the_mutex->Attributes.discipline ) {
166      case CORE_MUTEX_DISCIPLINES_FIFO:
167      case CORE_MUTEX_DISCIPLINES_PRIORITY:
168      case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
169        break;
170      case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
171        _Thread_Change_priority(
172          executing,
173          the_mutex->Attributes.priority_ceiling
174        );
175        break;
176    }
177  }
178}
179
180/*
181 *  _CORE_mutex_Surrender
182 *
183 *  DESCRIPTION:
184 *
185 *  This routine frees a unit to the mutex.  If a task was blocked waiting for
186 *  a unit from this mutex, then that task will be readied and the unit
187 *  given to that task.  Otherwise, the unit will be returned to the mutex.
188 *
189 *  Input parameters:
190 *    the_mutex            - the mutex to be flushed
191 *    id                   - id of parent mutex
192 *    api_mutex_mp_support - api dependent MP support actions
193 *
194 *  Output parameters:
195 *    CORE_MUTEX_STATUS_SUCCESSFUL - if successful
196 *    core error code              - if unsuccessful
197 */
198
199CORE_mutex_Status _CORE_mutex_Surrender(
200  CORE_mutex_Control                *the_mutex,
201  Objects_Id                         id,
202  CORE_mutex_API_mp_support_callout  api_mutex_mp_support
203)
204{
205  Thread_Control *the_thread;
206  Thread_Control *executing;
207
208  executing = _Thread_Executing;
209
210  if ( !_Objects_Are_ids_equal(
211           _Thread_Executing->Object.id, the_mutex->holder_id ) )
212    return( CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE );
213
214  the_mutex->nest_count--;
215
216  if ( the_mutex->nest_count != 0 )
217    return( CORE_MUTEX_STATUS_SUCCESSFUL );
218
219  _Thread_Executing->resource_count--;
220  the_mutex->holder    = NULL;
221  the_mutex->holder_id = 0;
222
223  /*
224   *  Whether or not someone is waiting for the mutex, an
225   *  inherited priority must be lowered if this is the last
226   *  mutex (i.e. resource) this task has.
227   */
228
229  switch ( the_mutex->Attributes.discipline ) {
230    case CORE_MUTEX_DISCIPLINES_FIFO:
231    case CORE_MUTEX_DISCIPLINES_PRIORITY:
232      break;
233    case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
234    case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
235      if ( executing->resource_count == 0 &&
236           executing->real_priority !=
237           executing->current_priority ) {
238         _Thread_Change_priority( executing, executing->real_priority );
239      }
240      break;
241  }
242
243
244  if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) {
245
246    if ( !_Objects_Is_local_id( the_thread->Object.id ) ) {
247     
248      the_mutex->holder     = NULL;
249      the_mutex->holder_id  = the_thread->Object.id;
250      the_mutex->nest_count = 1;
251
252      ( *api_mutex_mp_support)( the_thread, id );
253
254    } else {
255
256      the_mutex->holder     = the_thread;
257      the_mutex->holder_id  = the_thread->Object.id;
258      the_thread->resource_count++;
259      the_mutex->nest_count = 1;
260
261     /*
262      *  No special action for priority inheritance or priority ceiling
263      *  because the_thread is guaranteed to be the highest priority
264      *  thread waiting for the mutex.
265      */
266    }
267  } else
268    the_mutex->lock = CORE_MUTEX_UNLOCKED;
269
270  return( CORE_MUTEX_STATUS_SUCCESSFUL );
271}
272
273/*PAGE
274 *
275 *  _CORE_mutex_Flush
276 *
277 *  This function a flushes the mutex's task wait queue.
278 *
279 *  Input parameters:
280 *    the_mutex              - the mutex to be flushed
281 *    remote_extract_callout - function to invoke remotely
282 *    status                 - status to pass to thread
283 *
284 *  Output parameters:  NONE
285 */
286
287void _CORE_mutex_Flush(
288  CORE_mutex_Control         *the_mutex,
289  Thread_queue_Flush_callout  remote_extract_callout,
290  unsigned32                  status
291)
292{
293  _Thread_queue_Flush(
294    &the_mutex->Wait_queue,
295    remote_extract_callout,
296    status
297  );
298}
Note: See TracBrowser for help on using the repository browser.