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 021 022 022 023 #include "ksynch.h" 023 #include "ksynch.h" 024 024 025 025 026 sos_ret_t sos_ksema_init(struct sos_ksema *sem 026 sos_ret_t sos_ksema_init(struct sos_ksema *sema, const char *name, 027 int initial_value) !! 027 int initial_value, >> 028 sos_kwaitq_ordering_t ordering) 028 { 029 { 029 sema->value = initial_value; 030 sema->value = initial_value; 030 return sos_kwaitq_init(& sema->kwaitq, name) !! 031 return sos_kwaitq_init(& sema->kwaitq, name, ordering); 031 } 032 } 032 033 033 034 034 sos_ret_t sos_ksema_dispose(struct sos_ksema * 035 sos_ret_t sos_ksema_dispose(struct sos_ksema *sema) 035 { 036 { 036 return sos_kwaitq_dispose(& sema->kwaitq); 037 return sos_kwaitq_dispose(& sema->kwaitq); 037 } 038 } 038 039 039 040 040 sos_ret_t sos_ksema_down(struct sos_ksema *sem 041 sos_ret_t sos_ksema_down(struct sos_ksema *sema, 041 struct sos_time *time 042 struct sos_time *timeout) 042 { 043 { 043 sos_ui32_t flags; 044 sos_ui32_t flags; 044 sos_ret_t retval; 045 sos_ret_t retval; 045 046 046 sos_disable_IRQs(flags); 047 sos_disable_IRQs(flags); 047 retval = SOS_OK; 048 retval = SOS_OK; 048 049 049 sema->value --; 050 sema->value --; 050 if (sema->value < 0) 051 if (sema->value < 0) 051 { 052 { 052 /* Wait for somebody to wake us */ 053 /* Wait for somebody to wake us */ 053 retval = sos_kwaitq_wait(& sema->kwaitq, 054 retval = sos_kwaitq_wait(& sema->kwaitq, timeout); 054 055 055 /* Something wrong happened (timeout, ex 056 /* Something wrong happened (timeout, external wakeup, ...) ? */ 056 if (SOS_OK != retval) 057 if (SOS_OK != retval) 057 { 058 { 058 /* Yes: pretend we did not ask for t 059 /* Yes: pretend we did not ask for the semaphore */ 059 sema->value ++; 060 sema->value ++; 060 } 061 } 061 } 062 } 062 063 063 sos_restore_IRQs(flags); 064 sos_restore_IRQs(flags); 064 return retval; 065 return retval; 065 } 066 } 066 067 067 068 068 sos_ret_t sos_ksema_trydown(struct sos_ksema * 069 sos_ret_t sos_ksema_trydown(struct sos_ksema *sema) 069 { 070 { 070 sos_ui32_t flags; 071 sos_ui32_t flags; 071 sos_ret_t retval; 072 sos_ret_t retval; 072 073 073 sos_disable_IRQs(flags); 074 sos_disable_IRQs(flags); 074 075 075 /* Can we take the semaphore without blockin 076 /* Can we take the semaphore without blocking ? */ 076 if (sema->value >= 1) 077 if (sema->value >= 1) 077 { 078 { 078 /* Yes: we take it now */ 079 /* Yes: we take it now */ 079 sema->value --; 080 sema->value --; 080 retval = SOS_OK; 081 retval = SOS_OK; 081 } 082 } 082 else 083 else 083 { 084 { 084 /* No: we signal it */ 085 /* No: we signal it */ 085 retval = -SOS_EBUSY; 086 retval = -SOS_EBUSY; 086 } 087 } 087 088 088 sos_restore_IRQs(flags); 089 sos_restore_IRQs(flags); 089 return retval; 090 return retval; 090 } 091 } 091 092 092 093 093 sos_ret_t sos_ksema_up(struct sos_ksema *sema) 094 sos_ret_t sos_ksema_up(struct sos_ksema *sema) 094 { 095 { 095 sos_ui32_t flags; 096 sos_ui32_t flags; 096 sos_ret_t retval; 097 sos_ret_t retval; 097 098 098 sos_disable_IRQs(flags); 099 sos_disable_IRQs(flags); 099 100 100 sema->value ++; 101 sema->value ++; 101 retval = sos_kwaitq_wakeup(& sema->kwaitq, 1 102 retval = sos_kwaitq_wakeup(& sema->kwaitq, 1, SOS_OK); 102 103 103 sos_restore_IRQs(flags); 104 sos_restore_IRQs(flags); 104 return retval; 105 return retval; 105 } 106 } 106 107 107 108 108 sos_ret_t sos_kmutex_init(struct sos_kmutex *m !! 109 sos_ret_t sos_kmutex_init(struct sos_kmutex *mutex, const char *name, >> 110 sos_kwaitq_ordering_t ordering) 109 { 111 { 110 mutex->owner = NULL; 112 mutex->owner = NULL; 111 return sos_kwaitq_init(& mutex->kwaitq, name !! 113 return sos_kwaitq_init(& mutex->kwaitq, name, ordering); 112 } 114 } 113 115 114 116 115 sos_ret_t sos_kmutex_dispose(struct sos_kmutex 117 sos_ret_t sos_kmutex_dispose(struct sos_kmutex *mutex) 116 { 118 { 117 return sos_kwaitq_dispose(& mutex->kwaitq); 119 return sos_kwaitq_dispose(& mutex->kwaitq); 118 } 120 } 119 121 120 122 121 /* 123 /* 122 * Implementation based on ownership transfer 124 * Implementation based on ownership transfer (ie no while() 123 * loop). The only assumption is that the thre 125 * loop). The only assumption is that the thread awoken by 124 * kmutex_unlock is not suppressed before effe 126 * kmutex_unlock is not suppressed before effectively waking up: in 125 * that case the mutex will be forever locked 127 * that case the mutex will be forever locked AND unlockable (by 126 * nobody other than the owner, but this is no 128 * nobody other than the owner, but this is not natural since this 127 * owner already issued an unlock()...). The s 129 * owner already issued an unlock()...). The same problem happens with 128 * the semaphores, but in a less obvious manne 130 * the semaphores, but in a less obvious manner. 129 */ 131 */ 130 sos_ret_t sos_kmutex_lock(struct sos_kmutex *m 132 sos_ret_t sos_kmutex_lock(struct sos_kmutex *mutex, 131 struct sos_time *tim 133 struct sos_time *timeout) 132 { 134 { 133 __label__ exit_kmutex_lock; 135 __label__ exit_kmutex_lock; 134 sos_ui32_t flags; 136 sos_ui32_t flags; 135 sos_ret_t retval; 137 sos_ret_t retval; 136 138 137 sos_disable_IRQs(flags); 139 sos_disable_IRQs(flags); 138 retval = SOS_OK; 140 retval = SOS_OK; 139 141 140 /* Mutex already owned ? */ 142 /* Mutex already owned ? */ 141 if (NULL != mutex->owner) 143 if (NULL != mutex->owner) 142 { 144 { 143 /* Owned by us or by someone else ? */ 145 /* Owned by us or by someone else ? */ 144 if (sos_thread_get_current() == mutex->o 146 if (sos_thread_get_current() == mutex->owner) 145 { 147 { 146 /* Owned by us: do nothing */ 148 /* Owned by us: do nothing */ 147 retval = -SOS_EBUSY; 149 retval = -SOS_EBUSY; 148 goto exit_kmutex_lock; 150 goto exit_kmutex_lock; 149 } 151 } 150 152 151 /* Wait for somebody to wake us */ 153 /* Wait for somebody to wake us */ 152 retval = sos_kwaitq_wait(& mutex->kwaitq 154 retval = sos_kwaitq_wait(& mutex->kwaitq, timeout); 153 155 154 /* Something wrong happened ? */ 156 /* Something wrong happened ? */ 155 if (SOS_OK != retval) 157 if (SOS_OK != retval) 156 { 158 { 157 goto exit_kmutex_lock; 159 goto exit_kmutex_lock; 158 } 160 } 159 } 161 } 160 162 161 /* Ok, the mutex is available to us: take it 163 /* Ok, the mutex is available to us: take it */ 162 mutex->owner = sos_thread_get_current(); 164 mutex->owner = sos_thread_get_current(); 163 165 164 exit_kmutex_lock: 166 exit_kmutex_lock: 165 sos_restore_IRQs(flags); 167 sos_restore_IRQs(flags); 166 return retval; 168 return retval; 167 } 169 } 168 170 169 171 170 sos_ret_t sos_kmutex_trylock(struct sos_kmutex 172 sos_ret_t sos_kmutex_trylock(struct sos_kmutex *mutex) 171 { 173 { 172 sos_ui32_t flags; 174 sos_ui32_t flags; 173 sos_ret_t retval; 175 sos_ret_t retval; 174 176 175 sos_disable_IRQs(flags); 177 sos_disable_IRQs(flags); 176 178 177 /* Mutex available to us ? */ 179 /* Mutex available to us ? */ 178 if (NULL == mutex->owner) 180 if (NULL == mutex->owner) 179 { 181 { 180 /* Great ! Take it now */ 182 /* Great ! Take it now */ 181 mutex->owner = sos_thread_get_current(); 183 mutex->owner = sos_thread_get_current(); 182 184 183 retval = SOS_OK; 185 retval = SOS_OK; 184 } 186 } 185 else 187 else 186 { 188 { 187 /* No: signal it */ 189 /* No: signal it */ 188 retval = -SOS_EBUSY; 190 retval = -SOS_EBUSY; 189 } 191 } 190 192 191 sos_restore_IRQs(flags); 193 sos_restore_IRQs(flags); 192 return retval; 194 return retval; 193 } 195 } 194 196 195 197 196 sos_ret_t sos_kmutex_unlock(struct sos_kmutex 198 sos_ret_t sos_kmutex_unlock(struct sos_kmutex *mutex) 197 { 199 { 198 sos_ui32_t flags; 200 sos_ui32_t flags; 199 sos_ret_t retval; 201 sos_ret_t retval; 200 202 201 sos_disable_IRQs(flags); 203 sos_disable_IRQs(flags); 202 204 203 if (sos_thread_get_current() != mutex->owner 205 if (sos_thread_get_current() != mutex->owner) 204 retval = -SOS_EPERM; 206 retval = -SOS_EPERM; 205 207 206 else if (sos_kwaitq_is_empty(& mutex->kwaitq 208 else if (sos_kwaitq_is_empty(& mutex->kwaitq)) 207 { 209 { 208 /* 210 /* 209 * There is NOT ANY thread waiting => we 211 * There is NOT ANY thread waiting => we really mark the mutex 210 * as FREE 212 * as FREE 211 */ 213 */ 212 mutex->owner = NULL; 214 mutex->owner = NULL; 213 retval = SOS_OK; 215 retval = SOS_OK; 214 } 216 } 215 else 217 else 216 { 218 { 217 /* 219 /* 218 * There is at least 1 thread waiting => 220 * There is at least 1 thread waiting => we DO NOT mark the 219 * mutex as free ! 221 * mutex as free ! 220 * Actually, we should have written: 222 * Actually, we should have written: 221 * mutex->owner = thread_that_is_woken 223 * mutex->owner = thread_that_is_woken_up; 222 * But the real Id of the next thread ow 224 * But the real Id of the next thread owning the mutex is not 223 * that important. What is important her 225 * that important. What is important here is that mutex->owner 224 * IS NOT NULL. Otherwise there will be 226 * IS NOT NULL. Otherwise there will be a possibility for the 225 * thread woken up here to have the mute 227 * thread woken up here to have the mutex stolen by a thread 226 * locking the mutex in the meantime. 228 * locking the mutex in the meantime. 227 */ 229 */ 228 retval = sos_kwaitq_wakeup(& mutex->kwai 230 retval = sos_kwaitq_wakeup(& mutex->kwaitq, 1, SOS_OK); 229 } 231 } 230 232 231 sos_restore_IRQs(flags); 233 sos_restore_IRQs(flags); 232 return retval; 234 return retval; 233 } 235 }
| [ source navigation ] | [ diff markup ] | [ identifier search ] | [ general search ] |