Diff markup
001 001
002 002
003 003
004 004
005 005
006 006
007 007
008 008
009 009
010 010
011 011
012 012
013 013
014 014
015 015
016 016
017 017
018 018
019 019
020 #include <hwcore/irq.h> 020 #include <hwcore/irq.h>
021 #include <sos/assert.h> <<
022 021
023 022
024 #include "ksynch.h" 023 #include "ksynch.h"
025 024
026 025
027 sos_ret_t sos_ksema_init(struct sos_ksema *sem 026 sos_ret_t sos_ksema_init(struct sos_ksema *sema, const char *name,
028 int initial_value, 027 int initial_value,
029 sos_kwaitq_ordering_t 028 sos_kwaitq_ordering_t ordering)
030 { 029 {
031 sema->value = initial_value; 030 sema->value = initial_value;
032 return sos_kwaitq_init(& sema->kwaitq, name, 031 return sos_kwaitq_init(& sema->kwaitq, name, ordering);
033 } 032 }
034 033
035 034
036 sos_ret_t sos_ksema_dispose(struct sos_ksema * 035 sos_ret_t sos_ksema_dispose(struct sos_ksema *sema)
037 { 036 {
038 return sos_kwaitq_dispose(& sema->kwaitq); 037 return sos_kwaitq_dispose(& sema->kwaitq);
039 } 038 }
040 039
041 040
042 sos_ret_t sos_ksema_down(struct sos_ksema *sem 041 sos_ret_t sos_ksema_down(struct sos_ksema *sema,
043 struct sos_time *time 042 struct sos_time *timeout)
044 { 043 {
045 sos_ui32_t flags; 044 sos_ui32_t flags;
046 sos_ret_t retval; 045 sos_ret_t retval;
047 046
048 sos_disable_IRQs(flags); 047 sos_disable_IRQs(flags);
049 retval = SOS_OK; 048 retval = SOS_OK;
050 049
051 sema->value --; 050 sema->value --;
052 if (sema->value < 0) 051 if (sema->value < 0)
053 { 052 {
054 053
055 retval = sos_kwaitq_wait(& sema->kwaitq, 054 retval = sos_kwaitq_wait(& sema->kwaitq, timeout);
056 055
057 056
058 if (SOS_OK != retval) 057 if (SOS_OK != retval)
059 { 058 {
060 059
061 sema->value ++; 060 sema->value ++;
062 } 061 }
063 } 062 }
064 063
065 sos_restore_IRQs(flags); 064 sos_restore_IRQs(flags);
066 return retval; 065 return retval;
067 } 066 }
068 067
069 068
070 sos_ret_t sos_ksema_trydown(struct sos_ksema * 069 sos_ret_t sos_ksema_trydown(struct sos_ksema *sema)
071 { 070 {
072 sos_ui32_t flags; 071 sos_ui32_t flags;
073 sos_ret_t retval; 072 sos_ret_t retval;
074 073
075 sos_disable_IRQs(flags); 074 sos_disable_IRQs(flags);
076 075
077 076
078 if (sema->value >= 1) 077 if (sema->value >= 1)
079 { 078 {
080 079
081 sema->value --; 080 sema->value --;
082 retval = SOS_OK; 081 retval = SOS_OK;
083 } 082 }
084 else 083 else
085 { 084 {
086 085
087 retval = -SOS_EBUSY; 086 retval = -SOS_EBUSY;
088 } 087 }
089 088
090 sos_restore_IRQs(flags); 089 sos_restore_IRQs(flags);
091 return retval; 090 return retval;
092 } 091 }
093 092
094 093
095 sos_ret_t sos_ksema_up(struct sos_ksema *sema) 094 sos_ret_t sos_ksema_up(struct sos_ksema *sema)
096 { 095 {
097 sos_ui32_t flags; 096 sos_ui32_t flags;
098 sos_ret_t retval; 097 sos_ret_t retval;
099 098
100 sos_disable_IRQs(flags); 099 sos_disable_IRQs(flags);
101 100
102 sema->value ++; 101 sema->value ++;
103 retval = sos_kwaitq_wakeup(& sema->kwaitq, 1 102 retval = sos_kwaitq_wakeup(& sema->kwaitq, 1, SOS_OK);
104 103
105 sos_restore_IRQs(flags); 104 sos_restore_IRQs(flags);
106 return retval; 105 return retval;
107 } 106 }
108 107
109 108
110 sos_ret_t sos_kmutex_init(struct sos_kmutex *m 109 sos_ret_t sos_kmutex_init(struct sos_kmutex *mutex, const char *name,
111 sos_kwaitq_ordering_ 110 sos_kwaitq_ordering_t ordering)
112 { 111 {
113 mutex->owner = NULL; 112 mutex->owner = NULL;
114 return sos_kwaitq_init(& mutex->kwaitq, name 113 return sos_kwaitq_init(& mutex->kwaitq, name, ordering);
115 } 114 }
116 115
117 116
118 sos_ret_t sos_kmutex_dispose(struct sos_kmutex 117 sos_ret_t sos_kmutex_dispose(struct sos_kmutex *mutex)
119 { 118 {
120 return sos_kwaitq_dispose(& mutex->kwaitq); 119 return sos_kwaitq_dispose(& mutex->kwaitq);
121 } 120 }
122 121
123 122
124 123
125 124
126 125
127 126
128 127
129 128
130 129
131 130
132 131
133 sos_ret_t sos_kmutex_lock(struct sos_kmutex *m 132 sos_ret_t sos_kmutex_lock(struct sos_kmutex *mutex,
134 struct sos_time *tim 133 struct sos_time *timeout)
135 { 134 {
136 __label__ exit_kmutex_lock; 135 __label__ exit_kmutex_lock;
137 sos_ui32_t flags; 136 sos_ui32_t flags;
138 sos_ret_t retval; 137 sos_ret_t retval;
139 138
140 sos_disable_IRQs(flags); 139 sos_disable_IRQs(flags);
141 retval = SOS_OK; 140 retval = SOS_OK;
142 141
143 142
144 if (NULL != mutex->owner) 143 if (NULL != mutex->owner)
145 { 144 {
146 145
147 if (sos_thread_get_current() == mutex->o 146 if (sos_thread_get_current() == mutex->owner)
148 { 147 {
149 148
150 retval = -SOS_EBUSY; 149 retval = -SOS_EBUSY;
151 goto exit_kmutex_lock; 150 goto exit_kmutex_lock;
152 } 151 }
153 152
154 153
155 retval = sos_kwaitq_wait(& mutex->kwaitq 154 retval = sos_kwaitq_wait(& mutex->kwaitq, timeout);
156 155
157 156
158 if (SOS_OK != retval) 157 if (SOS_OK != retval)
159 { 158 {
160 goto exit_kmutex_lock; 159 goto exit_kmutex_lock;
161 } 160 }
162 } 161 }
163 162
164 163
165 mutex->owner = sos_thread_get_current(); 164 mutex->owner = sos_thread_get_current();
166 165
167 exit_kmutex_lock: 166 exit_kmutex_lock:
168 sos_restore_IRQs(flags); 167 sos_restore_IRQs(flags);
169 return retval; 168 return retval;
170 } 169 }
171 170
172 171
173 sos_bool_t sos_kmutex_owned_by_me(struct sos_k <<
174 { <<
175 sos_ui32_t flags; <<
176 sos_bool_t retval; <<
177 <<
178 sos_disable_IRQs(flags); <<
179 retval = (sos_thread_get_current() == mutex- <<
180 sos_restore_IRQs(flags); <<
181 <<
182 return retval; <<
183 } <<
184 <<
185 <<
186 sos_ret_t sos_kmutex_trylock(struct sos_kmutex 172 sos_ret_t sos_kmutex_trylock(struct sos_kmutex *mutex)
187 { 173 {
188 sos_ui32_t flags; 174 sos_ui32_t flags;
189 sos_ret_t retval; 175 sos_ret_t retval;
190 176
191 sos_disable_IRQs(flags); 177 sos_disable_IRQs(flags);
192 178
193 179
194 if (NULL == mutex->owner) 180 if (NULL == mutex->owner)
195 { 181 {
196 182
197 mutex->owner = sos_thread_get_current(); 183 mutex->owner = sos_thread_get_current();
198 184
199 retval = SOS_OK; 185 retval = SOS_OK;
200 } 186 }
201 else 187 else
202 { 188 {
203 189
204 retval = -SOS_EBUSY; 190 retval = -SOS_EBUSY;
205 } 191 }
206 192
207 sos_restore_IRQs(flags); 193 sos_restore_IRQs(flags);
208 return retval; 194 return retval;
209 } 195 }
210 196
211 197
212 sos_ret_t sos_kmutex_unlock(struct sos_kmutex 198 sos_ret_t sos_kmutex_unlock(struct sos_kmutex *mutex)
213 { 199 {
214 sos_ui32_t flags; 200 sos_ui32_t flags;
215 sos_ret_t retval; 201 sos_ret_t retval;
216 202
217 sos_disable_IRQs(flags); 203 sos_disable_IRQs(flags);
218 204
219 if (sos_thread_get_current() != mutex->owner 205 if (sos_thread_get_current() != mutex->owner)
220 retval = -SOS_EPERM; 206 retval = -SOS_EPERM;
221 207
222 else if (sos_kwaitq_is_empty(& mutex->kwaitq 208 else if (sos_kwaitq_is_empty(& mutex->kwaitq))
223 { 209 {
224 210
225 211
226 212
227 213
228 mutex->owner = NULL; 214 mutex->owner = NULL;
229 retval = SOS_OK; 215 retval = SOS_OK;
230 } 216 }
231 else 217 else
232 { 218 {
233 219
234 220
235 221
236 222
237 223
238 224
239 225
240 !! 226
241 <<
242 <<
243 <<
244 227
245 228
246 229
247 #define MUTEX_STILL_LOCKED ((struct sos_thread <<
248 mutex->owner = MUTEX_STILL_LOCKED; <<
249 <<
250 <<
251 retval = sos_kwaitq_wakeup(& mutex->kwai 230 retval = sos_kwaitq_wakeup(& mutex->kwaitq, 1, SOS_OK);
252 } 231 }
253 232
254 sos_restore_IRQs(flags); 233 sos_restore_IRQs(flags);
255 return retval; 234 return retval;
256 } 235 }