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