blob: 71582a9f09b46fb0290d4ed37c5b07a2af4c86ad (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
/**
* @file
*
* @brief CORE Mutex API
*
* This include file contains all the constants and structures associated with
* the Mutex Handler. A mutex is an enhanced version of the standard Dijkstra
* binary semaphore used to provide synchronization and mutual exclusion
* capabilities.
*/
/*
* COPYRIGHT (c) 1989-2011.
* On-Line Applications Research Corporation (OAR).
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.com/license/LICENSE.
*/
#ifndef _RTEMS_SCORE_COREMUTEX_H
#define _RTEMS_SCORE_COREMUTEX_H
#include <rtems/score/thread.h>
#include <rtems/score/threadq.h>
#include <rtems/score/priority.h>
#include <rtems/score/watchdog.h>
#include <rtems/score/interr.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* @defgroup ScoreMutex Mutex Handler
*
* @ingroup Score
*
* This handler encapsulates functionality which provides the foundation
* Mutex services used in all of the APIs supported by RTEMS.
*/
/**@{*/
/**
* @brief The blocking disciplines for a mutex.
*
* This enumerated type defines the blocking disciplines for a mutex.
*/
typedef enum {
/** This specifies that threads will wait for the mutex in FIFO order. */
CORE_MUTEX_DISCIPLINES_FIFO,
/** This specifies that threads will wait for the mutex in priority order. */
CORE_MUTEX_DISCIPLINES_PRIORITY,
/** This specifies that threads will wait for the mutex in priority order.
* Additionally, the Priority Inheritance Protocol will be in effect.
*/
CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT,
/** This specifies that threads will wait for the mutex in priority order.
* Additionally, the Priority Ceiling Protocol will be in effect.
*/
CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING
} CORE_mutex_Disciplines;
/**
* @brief The possible behaviors for lock nesting.
*
* This enumerated type defines the possible behaviors for
* lock nesting.
*/
typedef enum {
/**
* This sequence has no blocking or errors:
*
* + lock(m)
* + lock(m)
* + unlock(m)
* + unlock(m)
*/
CORE_MUTEX_NESTING_ACQUIRES,
#if defined(RTEMS_POSIX_API)
/**
* This sequence returns an error at the indicated point:
*
* + lock(m)
* + lock(m) - already locked error
* + unlock(m)
*/
CORE_MUTEX_NESTING_IS_ERROR,
#endif
/**
* This sequence performs as indicated:
* + lock(m)
* + lock(m) - deadlocks or timeouts
* + unlock(m) - releases
*/
CORE_MUTEX_NESTING_BLOCKS
} CORE_mutex_Nesting_behaviors;
/**
* @brief The control block used to manage attributes of each mutex.
*
* The following defines the control block used to manage the
* attributes of each mutex.
*/
typedef struct {
/** This field determines what the behavior of this mutex instance will
* be when attempting to acquire the mutex when it is already locked.
*/
CORE_mutex_Nesting_behaviors lock_nesting_behavior;
/** When this field is true, then only the thread that locked the mutex
* is allowed to unlock it.
*/
bool only_owner_release;
/** This field indicates whether threads waiting on the mutex block in
* FIFO or priority order.
*/
CORE_mutex_Disciplines discipline;
/** This field contains the ceiling priority to be used if that protocol
* is selected.
*/
Priority_Control priority_ceiling;
} CORE_mutex_Attributes;
#ifdef __RTEMS_STRICT_ORDER_MUTEX__
/**
* @brief The control block to manage lock chain of priority inheritance mutex.
*
* The following defines the control block used to manage lock chain of
* priority inheritance mutex.
*/
typedef struct{
/** This field is a chian of locked mutex by a thread,new mutex will
* be added to the head of queue, and the mutex which will be released
* must be the head of queue.
*/
Chain_Node lock_queue;
/** This field is the priority of thread before locking this mutex
*
*/
Priority_Control priority_before;
} CORE_mutex_order_list;
#endif
/**
* @brief Control block used to manage each mutex.
*
* The following defines the control block used to manage each mutex.
*/
typedef struct {
/** This field is the Waiting Queue used to manage the set of tasks
* which are blocked waiting to lock the mutex.
*/
Thread_queue_Control Wait_queue;
/** This element is the set of attributes which define this instance's
* behavior.
*/
CORE_mutex_Attributes Attributes;
/** This element contains the current state of the mutex.
*/
uint32_t lock;
/** This element contains the number of times the mutex has been acquired
* nested. This must be zero (0) before the mutex is actually unlocked.
*/
uint32_t nest_count;
/** This is the number of waiting threads. */
uint32_t blocked_count;
/** This element points to the thread which is currently holding this mutex.
* The holder is the last thread to successfully lock the mutex and which
* has not unlocked it. If the thread is not locked, there is no holder.
*/
Thread_Control *holder;
/** This element contains the object Id of the holding thread. */
Objects_Id holder_id;
#ifdef __RTEMS_STRICT_ORDER_MUTEX__
/** This field is used to manipulate the priority inheritance mutex queue*/
CORE_mutex_order_list queue;
#endif
} CORE_mutex_Control;
/**@}*/
#ifdef __cplusplus
}
#endif
#endif
/* end of include file */
|
