Navigation
- Accueil
- Présentation :
- FAQ
- Bugs et errata
- Contributions de lecteurs
- Téléchargements
- LXR (référencement des sources)
- Mailing-list
- Liens et Projets reliés
Site hébergé par :
Site hébergé par :
|
[ source navigation ] [ diff markup ] [ identifier search ] [ general search ] |
|||
|
||||
001 /* Copyright (C) 2004 David Decotigny 001 /* Copyright (C) 2004 David Decotigny 002 002 003 This program is free software; you can redi 003 This program is free software; you can redistribute it and/or 004 modify it under the terms of the GNU Genera 004 modify it under the terms of the GNU General Public License 005 as published by the Free Software Foundatio 005 as published by the Free Software Foundation; either version 2 006 of the License, or (at your option) any lat 006 of the License, or (at your option) any later version. 007 007 008 This program is distributed in the hope tha 008 This program is distributed in the hope that it will be useful, 009 but WITHOUT ANY WARRANTY; without even the 009 but WITHOUT ANY WARRANTY; without even the implied warranty of 010 MERCHANTABILITY or FITNESS FOR A PARTICULAR 010 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 011 GNU General Public License for more details 011 GNU General Public License for more details. 012 012 013 You should have received a copy of the GNU 013 You should have received a copy of the GNU General Public License 014 along with this program; if not, write to t 014 along with this program; if not, write to the Free Software 015 Foundation, Inc., 59 Temple Place - Suite 3 015 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 016 USA. 016 USA. 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, 028 sos_kwaitq_ordering_t 029 sos_kwaitq_ordering_t ordering) 029 { 030 { 030 sema->value = initial_value; 031 sema->value = initial_value; 031 return sos_kwaitq_init(& sema->kwaitq, name, 032 return sos_kwaitq_init(& sema->kwaitq, name, ordering); 032 } 033 } 033 034 034 035 035 sos_ret_t sos_ksema_dispose(struct sos_ksema * 036 sos_ret_t sos_ksema_dispose(struct sos_ksema *sema) 036 { 037 { 037 return sos_kwaitq_dispose(& sema->kwaitq); 038 return sos_kwaitq_dispose(& sema->kwaitq); 038 } 039 } 039 040 040 041 041 sos_ret_t sos_ksema_down(struct sos_ksema *sem 042 sos_ret_t sos_ksema_down(struct sos_ksema *sema, 042 struct sos_time *time 043 struct sos_time *timeout) 043 { 044 { 044 sos_ui32_t flags; 045 sos_ui32_t flags; 045 sos_ret_t retval; 046 sos_ret_t retval; 046 047 047 sos_disable_IRQs(flags); 048 sos_disable_IRQs(flags); 048 retval = SOS_OK; 049 retval = SOS_OK; 049 050 050 sema->value --; 051 sema->value --; 051 if (sema->value < 0) 052 if (sema->value < 0) 052 { 053 { 053 /* Wait for somebody to wake us */ 054 /* Wait for somebody to wake us */ 054 retval = sos_kwaitq_wait(& sema->kwaitq, 055 retval = sos_kwaitq_wait(& sema->kwaitq, timeout); 055 056 056 /* Something wrong happened (timeout, ex 057 /* Something wrong happened (timeout, external wakeup, ...) ? */ 057 if (SOS_OK != retval) 058 if (SOS_OK != retval) 058 { 059 { 059 /* Yes: pretend we did not ask for t 060 /* Yes: pretend we did not ask for the semaphore */ 060 sema->value ++; 061 sema->value ++; 061 } 062 } 062 } 063 } 063 064 064 sos_restore_IRQs(flags); 065 sos_restore_IRQs(flags); 065 return retval; 066 return retval; 066 } 067 } 067 068 068 069 069 sos_ret_t sos_ksema_trydown(struct sos_ksema * 070 sos_ret_t sos_ksema_trydown(struct sos_ksema *sema) 070 { 071 { 071 sos_ui32_t flags; 072 sos_ui32_t flags; 072 sos_ret_t retval; 073 sos_ret_t retval; 073 074 074 sos_disable_IRQs(flags); 075 sos_disable_IRQs(flags); 075 076 076 /* Can we take the semaphore without blockin 077 /* Can we take the semaphore without blocking ? */ 077 if (sema->value >= 1) 078 if (sema->value >= 1) 078 { 079 { 079 /* Yes: we take it now */ 080 /* Yes: we take it now */ 080 sema->value --; 081 sema->value --; 081 retval = SOS_OK; 082 retval = SOS_OK; 082 } 083 } 083 else 084 else 084 { 085 { 085 /* No: we signal it */ 086 /* No: we signal it */ 086 retval = -SOS_EBUSY; 087 retval = -SOS_EBUSY; 087 } 088 } 088 089 089 sos_restore_IRQs(flags); 090 sos_restore_IRQs(flags); 090 return retval; 091 return retval; 091 } 092 } 092 093 093 094 094 sos_ret_t sos_ksema_up(struct sos_ksema *sema) 095 sos_ret_t sos_ksema_up(struct sos_ksema *sema) 095 { 096 { 096 sos_ui32_t flags; 097 sos_ui32_t flags; 097 sos_ret_t retval; 098 sos_ret_t retval; 098 099 099 sos_disable_IRQs(flags); 100 sos_disable_IRQs(flags); 100 101 101 sema->value ++; 102 sema->value ++; 102 retval = sos_kwaitq_wakeup(& sema->kwaitq, 1 103 retval = sos_kwaitq_wakeup(& sema->kwaitq, 1, SOS_OK); 103 104 104 sos_restore_IRQs(flags); 105 sos_restore_IRQs(flags); 105 return retval; 106 return retval; 106 } 107 } 107 108 108 109 109 sos_ret_t sos_kmutex_init(struct sos_kmutex *m 110 sos_ret_t sos_kmutex_init(struct sos_kmutex *mutex, const char *name, 110 sos_kwaitq_ordering_ 111 sos_kwaitq_ordering_t ordering) 111 { 112 { 112 mutex->owner = NULL; 113 mutex->owner = NULL; 113 return sos_kwaitq_init(& mutex->kwaitq, name 114 return sos_kwaitq_init(& mutex->kwaitq, name, ordering); 114 } 115 } 115 116 116 117 117 sos_ret_t sos_kmutex_dispose(struct sos_kmutex 118 sos_ret_t sos_kmutex_dispose(struct sos_kmutex *mutex) 118 { 119 { 119 return sos_kwaitq_dispose(& mutex->kwaitq); 120 return sos_kwaitq_dispose(& mutex->kwaitq); 120 } 121 } 121 122 122 123 123 /* 124 /* 124 * Implementation based on ownership transfer 125 * Implementation based on ownership transfer (ie no while() 125 * loop). The only assumption is that the thre 126 * loop). The only assumption is that the thread awoken by 126 * kmutex_unlock is not suppressed before effe 127 * kmutex_unlock is not suppressed before effectively waking up: in 127 * that case the mutex will be forever locked 128 * that case the mutex will be forever locked AND unlockable (by 128 * nobody other than the owner, but this is no 129 * nobody other than the owner, but this is not natural since this 129 * owner already issued an unlock()...). The s 130 * owner already issued an unlock()...). The same problem happens with 130 * the semaphores, but in a less obvious manne 131 * the semaphores, but in a less obvious manner. 131 */ 132 */ 132 sos_ret_t sos_kmutex_lock(struct sos_kmutex *m 133 sos_ret_t sos_kmutex_lock(struct sos_kmutex *mutex, 133 struct sos_time *tim 134 struct sos_time *timeout) 134 { 135 { 135 __label__ exit_kmutex_lock; 136 __label__ exit_kmutex_lock; 136 sos_ui32_t flags; 137 sos_ui32_t flags; 137 sos_ret_t retval; 138 sos_ret_t retval; 138 139 139 sos_disable_IRQs(flags); 140 sos_disable_IRQs(flags); 140 retval = SOS_OK; 141 retval = SOS_OK; 141 142 142 /* Mutex already owned ? */ 143 /* Mutex already owned ? */ 143 if (NULL != mutex->owner) 144 if (NULL != mutex->owner) 144 { 145 { 145 /* Owned by us or by someone else ? */ 146 /* Owned by us or by someone else ? */ 146 if (sos_thread_get_current() == mutex->o 147 if (sos_thread_get_current() == mutex->owner) 147 { 148 { 148 /* Owned by us: do nothing */ 149 /* Owned by us: do nothing */ 149 retval = -SOS_EBUSY; 150 retval = -SOS_EBUSY; 150 goto exit_kmutex_lock; 151 goto exit_kmutex_lock; 151 } 152 } 152 153 153 /* Wait for somebody to wake us */ 154 /* Wait for somebody to wake us */ 154 retval = sos_kwaitq_wait(& mutex->kwaitq 155 retval = sos_kwaitq_wait(& mutex->kwaitq, timeout); 155 156 156 /* Something wrong happened ? */ 157 /* Something wrong happened ? */ 157 if (SOS_OK != retval) 158 if (SOS_OK != retval) 158 { 159 { 159 goto exit_kmutex_lock; 160 goto exit_kmutex_lock; 160 } 161 } 161 } 162 } 162 163 163 /* Ok, the mutex is available to us: take it 164 /* Ok, the mutex is available to us: take it */ 164 mutex->owner = sos_thread_get_current(); 165 mutex->owner = sos_thread_get_current(); 165 166 166 exit_kmutex_lock: 167 exit_kmutex_lock: 167 sos_restore_IRQs(flags); 168 sos_restore_IRQs(flags); 168 return retval; 169 return retval; 169 } 170 } 170 171 171 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 172 sos_ret_t sos_kmutex_trylock(struct sos_kmutex 186 sos_ret_t sos_kmutex_trylock(struct sos_kmutex *mutex) 173 { 187 { 174 sos_ui32_t flags; 188 sos_ui32_t flags; 175 sos_ret_t retval; 189 sos_ret_t retval; 176 190 177 sos_disable_IRQs(flags); 191 sos_disable_IRQs(flags); 178 192 179 /* Mutex available to us ? */ 193 /* Mutex available to us ? */ 180 if (NULL == mutex->owner) 194 if (NULL == mutex->owner) 181 { 195 { 182 /* Great ! Take it now */ 196 /* Great ! Take it now */ 183 mutex->owner = sos_thread_get_current(); 197 mutex->owner = sos_thread_get_current(); 184 198 185 retval = SOS_OK; 199 retval = SOS_OK; 186 } 200 } 187 else 201 else 188 { 202 { 189 /* No: signal it */ 203 /* No: signal it */ 190 retval = -SOS_EBUSY; 204 retval = -SOS_EBUSY; 191 } 205 } 192 206 193 sos_restore_IRQs(flags); 207 sos_restore_IRQs(flags); 194 return retval; 208 return retval; 195 } 209 } 196 210 197 211 198 sos_ret_t sos_kmutex_unlock(struct sos_kmutex 212 sos_ret_t sos_kmutex_unlock(struct sos_kmutex *mutex) 199 { 213 { 200 sos_ui32_t flags; 214 sos_ui32_t flags; 201 sos_ret_t retval; 215 sos_ret_t retval; 202 216 203 sos_disable_IRQs(flags); 217 sos_disable_IRQs(flags); 204 218 205 if (sos_thread_get_current() != mutex->owner 219 if (sos_thread_get_current() != mutex->owner) 206 retval = -SOS_EPERM; 220 retval = -SOS_EPERM; 207 221 208 else if (sos_kwaitq_is_empty(& mutex->kwaitq 222 else if (sos_kwaitq_is_empty(& mutex->kwaitq)) 209 { 223 { 210 /* 224 /* 211 * There is NOT ANY thread waiting => we 225 * There is NOT ANY thread waiting => we really mark the mutex 212 * as FREE 226 * as FREE 213 */ 227 */ 214 mutex->owner = NULL; 228 mutex->owner = NULL; 215 retval = SOS_OK; 229 retval = SOS_OK; 216 } 230 } 217 else 231 else 218 { 232 { 219 /* 233 /* 220 * There is at least 1 thread waiting => 234 * There is at least 1 thread waiting => we DO NOT mark the 221 * mutex as free ! 235 * mutex as free ! 222 * Actually, we should have written: 236 * Actually, we should have written: 223 * mutex->owner = thread_that_is_woken 237 * mutex->owner = thread_that_is_woken_up; 224 * But the real Id of the next thread ow 238 * But the real Id of the next thread owning the mutex is not 225 * that important. What is important her 239 * that important. What is important here is that mutex->owner 226 * IS NOT NULL. Otherwise there will be !! 240 * IS NOT NULL and does not correspond to any existing thread >> 241 * (address 0x43 is a good candidate because, in SOS, addresses >> 242 * below 4kB are never mapped in order to catch invalid >> 243 * pointers). Otherwise there will be a possibility for the 227 * thread woken up here to have the mute 244 * thread woken up here to have the mutex stolen by a thread 228 * locking the mutex in the meantime. 245 * locking the mutex in the meantime. 229 */ 246 */ >> 247 #define MUTEX_STILL_LOCKED ((struct sos_thread*) 0x43) >> 248 mutex->owner = MUTEX_STILL_LOCKED; >> 249 >> 250 /* We wake up ONE thread ONLY */ 230 retval = sos_kwaitq_wakeup(& mutex->kwai 251 retval = sos_kwaitq_wakeup(& mutex->kwaitq, 1, SOS_OK); 231 } 252 } 232 253 233 sos_restore_IRQs(flags); 254 sos_restore_IRQs(flags); 234 return retval; 255 return retval; 235 } 256 }
| [ source navigation ] | [ diff markup ] | [ identifier search ] | [ general search ] |