Mercurial > flash_v2
annotate packages/kernel/current/src/common/kapi.cxx @ 178:aa8364213009
Merge from eCos master repository on 2001-08-15-01:50:29-BST
| author | jlarmour |
|---|---|
| date | Wed, 15 Aug 2001 02:21:28 +0000 |
| parents | 4c750ce71ae3 |
| children | 391299f9e541 |
| rev | line source |
|---|---|
| 0 | 1 //========================================================================== |
| 2 // | |
| 2 | 3 // common/kapi.cxx |
| 0 | 4 // |
| 2 | 5 // C API Implementation |
| 0 | 6 // |
| 7 //========================================================================== | |
| 8 //####COPYRIGHTBEGIN#### | |
|
64
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
9 // |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
10 // ------------------------------------------- |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
11 // The contents of this file are subject to the Red Hat eCos Public License |
|
66
bf00f99aec69
Merge from eCos master repository on 2000-02-02-19:16:44-GMT
jlarmour
parents:
64
diff
changeset
|
12 // Version 1.1 (the "License"); you may not use this file except in |
|
64
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
13 // compliance with the License. You may obtain a copy of the License at |
|
66
bf00f99aec69
Merge from eCos master repository on 2000-02-02-19:16:44-GMT
jlarmour
parents:
64
diff
changeset
|
14 // http://www.redhat.com/ |
|
64
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
15 // |
|
66
bf00f99aec69
Merge from eCos master repository on 2000-02-02-19:16:44-GMT
jlarmour
parents:
64
diff
changeset
|
16 // Software distributed under the License is distributed on an "AS IS" |
|
64
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
17 // basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
18 // License for the specific language governing rights and limitations under |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
19 // the License. |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
20 // |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
21 // The Original Code is eCos - Embedded Configurable Operating System, |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
22 // released September 30, 1998. |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
23 // |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
24 // The Initial Developer of the Original Code is Red Hat. |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
25 // Portions created by Red Hat are |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
26 // Copyright (C) 1998, 1999, 2000 Red Hat, Inc. |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
27 // All Rights Reserved. |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
28 // ------------------------------------------- |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
56
diff
changeset
|
29 // |
| 0 | 30 //####COPYRIGHTEND#### |
| 31 //========================================================================== | |
| 32 //#####DESCRIPTIONBEGIN#### | |
| 33 // | |
| 2 | 34 // Author(s): nickg, dsm |
| 35 // Contributors: nickg | |
| 36 // Date: 1998-03-02 | |
| 37 // Purpose: C API Implementation | |
| 38 // Description: C++ implementation of the C API | |
| 0 | 39 // |
| 40 // | |
| 41 //####DESCRIPTIONEND#### | |
| 42 // | |
| 43 //========================================================================== | |
| 44 | |
| 45 #include <pkgconf/kernel.h> | |
| 46 | |
| 47 #ifdef CYGFUN_KERNEL_API_C | |
| 48 | |
| 49 #include <cyg/kernel/ktypes.h> // base kernel types | |
| 50 #include <cyg/infra/cyg_trac.h> // tracing macros | |
| 51 #include <cyg/infra/cyg_ass.h> // assertion macros | |
| 52 #include <cyg/kernel/instrmnt.h> // instrumentation | |
| 53 #include <cyg/kernel/diag.h> | |
| 54 | |
| 55 #include <cyg/kernel/thread.hxx> | |
| 56 #include <cyg/kernel/thread.inl> // thread inlines | |
| 57 #include <cyg/kernel/sched.hxx> | |
| 58 #include <cyg/kernel/intr.hxx> | |
| 59 #include <cyg/kernel/clock.hxx> | |
| 60 | |
| 61 #include <cyg/kernel/sema.hxx> | |
| 62 #include <cyg/kernel/flag.hxx> | |
| 63 #include <cyg/kernel/mutex.hxx> | |
| 64 #include <cyg/kernel/mbox.hxx> | |
| 65 | |
| 66 #include <cyg/kernel/sched.inl> // scheduler inlines | |
| 67 #include <cyg/kernel/clock.inl> // clock inlines | |
| 68 | |
| 69 #include <cyg/kernel/kapi.h> // C API | |
| 70 | |
| 71 // ------------------------------------------------------------------------- | |
| 72 // Magic new function | |
| 73 | |
| 74 inline void *operator new(size_t size, void *ptr) | |
| 75 { | |
| 76 CYG_CHECK_DATA_PTR( ptr, "Bad pointer" ); | |
| 77 return ptr; | |
| 78 } | |
| 79 | |
| 80 // ------------------------------------------------------------------------- | |
| 81 | |
| 82 #ifdef CYGDBG_USE_ASSERTS | |
| 83 | |
| 84 #define CYG_ASSERT_SIZES(cstruct, cxxstruct) \ | |
| 85 CYG_MACRO_START \ | |
| 86 char *msg = "Size of C struct " #cstruct \ | |
| 87 " != size of C++ struct " #cxxstruct ; \ | |
| 88 CYG_ASSERT( sizeof(cstruct) == sizeof(cxxstruct) , msg ); \ | |
| 89 CYG_MACRO_END | |
| 90 | |
| 91 #else | |
| 92 | |
| 93 #define CYG_ASSERT_SIZES(cstruct, cxxstruct) | |
| 94 | |
| 95 #endif | |
| 96 | |
| 97 /*---------------------------------------------------------------------------*/ | |
| 98 /* Scheduler operations */ | |
| 99 | |
| 100 /* Starts scheduler with created threads. Never returns. */ | |
| 101 externC void cyg_scheduler_start(void) | |
| 102 { | |
| 103 Cyg_Scheduler::start(); | |
| 104 } | |
| 105 | |
|
4
1d7f19c9e4d1
Merge from eCos master repository on 1999-05-11-21:11:10-BST
jlarmour
parents:
2
diff
changeset
|
106 /* Lock the scheduler. */ |
| 0 | 107 externC void cyg_scheduler_lock(void) |
| 108 { | |
| 109 Cyg_Scheduler::lock(); | |
|
56
755351606154
Merge from eCos master repository on 1999-12-01-18:03:05-GMT
jlarmour
parents:
38
diff
changeset
|
110 // get_sched_lock() is unsigned, see below "cyg_ucount32 lock" |
|
755351606154
Merge from eCos master repository on 1999-12-01-18:03:05-GMT
jlarmour
parents:
38
diff
changeset
|
111 CYG_ASSERT( (0xff000000 & (Cyg_Scheduler::get_sched_lock())) == 0, |
|
755351606154
Merge from eCos master repository on 1999-12-01-18:03:05-GMT
jlarmour
parents:
38
diff
changeset
|
112 "Scheduler overlocked" ); |
| 0 | 113 } |
| 114 | |
|
84
489eb5632bc3
Merge from eCos master repository on 2000-04-28-18:44:39-BST
jlarmour
parents:
66
diff
changeset
|
115 /* Lock the scheduler, but never more than level=1. */ |
|
489eb5632bc3
Merge from eCos master repository on 2000-04-28-18:44:39-BST
jlarmour
parents:
66
diff
changeset
|
116 externC void cyg_scheduler_safe_lock(void) |
|
489eb5632bc3
Merge from eCos master repository on 2000-04-28-18:44:39-BST
jlarmour
parents:
66
diff
changeset
|
117 { |
|
489eb5632bc3
Merge from eCos master repository on 2000-04-28-18:44:39-BST
jlarmour
parents:
66
diff
changeset
|
118 Cyg_Scheduler::lock(); |
|
489eb5632bc3
Merge from eCos master repository on 2000-04-28-18:44:39-BST
jlarmour
parents:
66
diff
changeset
|
119 cyg_ucount32 slock = Cyg_Scheduler::get_sched_lock(); |
|
489eb5632bc3
Merge from eCos master repository on 2000-04-28-18:44:39-BST
jlarmour
parents:
66
diff
changeset
|
120 if (slock > 1) |
|
489eb5632bc3
Merge from eCos master repository on 2000-04-28-18:44:39-BST
jlarmour
parents:
66
diff
changeset
|
121 Cyg_Scheduler::unlock(); |
|
489eb5632bc3
Merge from eCos master repository on 2000-04-28-18:44:39-BST
jlarmour
parents:
66
diff
changeset
|
122 // get_sched_lock() is unsigned, see below "cyg_ucount32 lock" |
|
489eb5632bc3
Merge from eCos master repository on 2000-04-28-18:44:39-BST
jlarmour
parents:
66
diff
changeset
|
123 CYG_ASSERT( (0xff000000 & (Cyg_Scheduler::get_sched_lock())) == 0, |
|
489eb5632bc3
Merge from eCos master repository on 2000-04-28-18:44:39-BST
jlarmour
parents:
66
diff
changeset
|
124 "Scheduler overlocked" ); |
|
489eb5632bc3
Merge from eCos master repository on 2000-04-28-18:44:39-BST
jlarmour
parents:
66
diff
changeset
|
125 } |
|
489eb5632bc3
Merge from eCos master repository on 2000-04-28-18:44:39-BST
jlarmour
parents:
66
diff
changeset
|
126 |
|
4
1d7f19c9e4d1
Merge from eCos master repository on 1999-05-11-21:11:10-BST
jlarmour
parents:
2
diff
changeset
|
127 /* Unlock the scheduler. */ |
| 0 | 128 externC void cyg_scheduler_unlock(void) |
| 129 { | |
|
56
755351606154
Merge from eCos master repository on 1999-12-01-18:03:05-GMT
jlarmour
parents:
38
diff
changeset
|
130 cyg_ucount32 slock = Cyg_Scheduler::get_sched_lock(); |
|
755351606154
Merge from eCos master repository on 1999-12-01-18:03:05-GMT
jlarmour
parents:
38
diff
changeset
|
131 CYG_ASSERT( 0 < slock, "Scheduler not locked" ); |
|
755351606154
Merge from eCos master repository on 1999-12-01-18:03:05-GMT
jlarmour
parents:
38
diff
changeset
|
132 // And program defensively too: |
|
755351606154
Merge from eCos master repository on 1999-12-01-18:03:05-GMT
jlarmour
parents:
38
diff
changeset
|
133 if ( 0 < slock ) |
|
755351606154
Merge from eCos master repository on 1999-12-01-18:03:05-GMT
jlarmour
parents:
38
diff
changeset
|
134 Cyg_Scheduler::unlock(); |
| 0 | 135 } |
| 136 | |
|
105
5a0cc6c243a9
Merge from eCos master repository on 2000-06-30-08:18:49-BST
jlarmour
parents:
84
diff
changeset
|
137 /* Read the scheduler lock value. */ |
|
5a0cc6c243a9
Merge from eCos master repository on 2000-06-30-08:18:49-BST
jlarmour
parents:
84
diff
changeset
|
138 externC cyg_ucount32 cyg_scheduler_read_lock(void) |
|
5a0cc6c243a9
Merge from eCos master repository on 2000-06-30-08:18:49-BST
jlarmour
parents:
84
diff
changeset
|
139 { |
|
5a0cc6c243a9
Merge from eCos master repository on 2000-06-30-08:18:49-BST
jlarmour
parents:
84
diff
changeset
|
140 cyg_ucount32 slock = Cyg_Scheduler::get_sched_lock(); |
|
5a0cc6c243a9
Merge from eCos master repository on 2000-06-30-08:18:49-BST
jlarmour
parents:
84
diff
changeset
|
141 return slock; |
|
5a0cc6c243a9
Merge from eCos master repository on 2000-06-30-08:18:49-BST
jlarmour
parents:
84
diff
changeset
|
142 } |
|
5a0cc6c243a9
Merge from eCos master repository on 2000-06-30-08:18:49-BST
jlarmour
parents:
84
diff
changeset
|
143 |
| 0 | 144 /*---------------------------------------------------------------------------*/ |
| 145 /* Thread operations */ | |
| 146 | |
| 147 externC void cyg_thread_create( | |
| 2 | 148 cyg_addrword_t sched_info, /* scheduling info (eg pri) */ |
| 0 | 149 cyg_thread_entry_t *entry, /* entry point function */ |
| 2 | 150 cyg_addrword_t entry_data, /* entry data */ |
| 0 | 151 char *name, /* optional thread name */ |
| 152 void *stack_base, /* stack base, NULL = alloc */ | |
| 153 cyg_ucount32 stack_size, /* stack size, 0 = default */ | |
| 154 cyg_handle_t *handle, /* returned thread handle */ | |
| 155 cyg_thread *thread /* put thread here */ | |
| 156 ) | |
| 157 { | |
| 158 CYG_ASSERT_SIZES( cyg_thread, Cyg_Thread ); | |
| 159 | |
| 160 Cyg_Thread *t = new((void *)thread) Cyg_Thread ( | |
| 161 (CYG_ADDRWORD) sched_info, | |
| 162 (cyg_thread_entry *)entry, | |
| 163 (CYG_ADDRWORD) entry_data, | |
| 164 name, | |
| 2 | 165 (CYG_ADDRWORD) stack_base, |
| 166 stack_size | |
| 0 | 167 ); |
| 168 t=t; | |
| 169 | |
| 170 CYG_CHECK_DATA_PTR( handle, "Bad handle pointer" ); | |
| 171 *handle = (cyg_handle_t)thread; | |
| 172 } | |
| 173 | |
| 174 externC void cyg_thread_exit() | |
| 175 { | |
| 176 Cyg_Thread::exit(); | |
| 177 } | |
| 178 | |
|
8
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
179 externC cyg_bool_t cyg_thread_delete( cyg_handle_t thread ) |
| 2 | 180 { |
| 181 Cyg_Thread *th = (Cyg_Thread *)thread; | |
| 182 if( th->get_state() != Cyg_Thread::EXITED ) | |
|
8
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
183 th->kill(); // encourage it to terminate |
|
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
184 if( th->get_state() != Cyg_Thread::EXITED ) |
|
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
185 return false; // it didn't run yet, leave it up to the app to fix |
|
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
186 th->~Cyg_Thread(); |
|
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
187 return true; |
| 2 | 188 } |
| 189 | |
| 0 | 190 externC void cyg_thread_suspend(cyg_handle_t thread) |
| 191 { | |
| 192 ((Cyg_Thread *)thread)->suspend(); | |
| 193 } | |
| 194 | |
| 195 externC void cyg_thread_resume(cyg_handle_t thread) | |
| 196 { | |
| 197 Cyg_Thread *th = (Cyg_Thread *)thread; | |
| 198 | |
| 199 // If we are resuming an exited thread then | |
| 200 // reinitialize it. | |
| 201 | |
| 202 if( th->get_state() == Cyg_Thread::EXITED ) | |
| 203 th->reinitialize(); | |
| 204 | |
| 205 th->resume(); | |
| 206 } | |
| 207 | |
| 208 externC void cyg_thread_kill( cyg_handle_t thread) | |
| 209 { | |
|
8
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
210 ((Cyg_Thread *)thread)->kill(); |
| 0 | 211 } |
| 212 | |
| 2 | 213 externC void cyg_thread_release( cyg_handle_t thread) |
| 214 { | |
| 215 ((Cyg_Thread *)thread)->release(); | |
| 216 } | |
| 217 | |
| 0 | 218 externC void cyg_thread_yield() |
| 219 { | |
| 220 Cyg_Thread::yield(); | |
| 221 } | |
| 222 | |
| 223 externC cyg_handle_t cyg_thread_self() | |
| 224 { | |
| 225 return (cyg_handle_t)Cyg_Thread::self(); | |
| 226 } | |
| 227 | |
|
10
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
228 // idle thread is not really a plain CygThread; danger. |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
229 externC cyg_handle_t cyg_thread_idle_thread() |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
230 { |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
231 extern Cyg_Thread idle_thread; |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
232 return (cyg_handle_t)&idle_thread; |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
233 } |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
234 |
| 0 | 235 /* Priority manipulation */ |
| 236 externC void cyg_thread_set_priority( | |
| 237 cyg_handle_t thread, cyg_priority_t priority ) | |
| 238 { | |
|
8
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
239 #ifdef CYGIMP_THREAD_PRIORITY |
| 0 | 240 ((Cyg_Thread *)thread)->set_priority(priority); |
|
8
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
241 #endif |
| 0 | 242 } |
| 243 | |
| 244 externC cyg_priority_t cyg_thread_get_priority(cyg_handle_t thread) | |
| 245 { | |
|
8
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
246 #ifdef CYGIMP_THREAD_PRIORITY |
| 0 | 247 return ((Cyg_Thread *)thread)->get_priority(); |
|
8
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
248 #else |
|
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
249 return 0; |
|
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
250 #endif |
| 0 | 251 } |
| 252 | |
| 253 /* Deadline scheduling control (optional) */ | |
| 254 | |
| 255 externC void cyg_thread_deadline_wait( | |
| 256 cyg_tick_count_t start_time, /* abs earliest start time */ | |
| 257 cyg_tick_count_t run_time, /* worst case execution time */ | |
| 258 cyg_tick_count_t deadline /* absolute deadline */ | |
| 259 ) | |
| 260 { | |
| 261 CYG_ASSERT(0,"Not implemented"); | |
| 262 } | |
| 263 | |
| 264 externC void cyg_thread_delay(cyg_tick_count_t delay) | |
| 265 { | |
| 266 Cyg_Thread::self()->delay(delay); | |
| 267 } | |
| 268 | |
|
10
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
269 /* Stack information */ |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
270 externC cyg_addrword_t cyg_thread_get_stack_base(cyg_handle_t thread) |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
271 { |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
272 return ((Cyg_Thread *)thread)->get_stack_base(); |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
273 } |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
274 |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
275 externC cyg_uint32 cyg_thread_get_stack_size(cyg_handle_t thread) |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
276 { |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
277 return ((Cyg_Thread *)thread)->get_stack_size(); |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
278 } |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
279 |
|
147
d397fc472bcf
Merge from eCos master repository on 2001-01-05-06:43:02-GMT
jlarmour
parents:
115
diff
changeset
|
280 #ifdef CYGFUN_KERNEL_THREADS_STACK_MEASUREMENT |
|
d397fc472bcf
Merge from eCos master repository on 2001-01-05-06:43:02-GMT
jlarmour
parents:
115
diff
changeset
|
281 externC cyg_uint32 cyg_thread_measure_stack_usage(cyg_handle_t thread) |
|
d397fc472bcf
Merge from eCos master repository on 2001-01-05-06:43:02-GMT
jlarmour
parents:
115
diff
changeset
|
282 { |
|
d397fc472bcf
Merge from eCos master repository on 2001-01-05-06:43:02-GMT
jlarmour
parents:
115
diff
changeset
|
283 return ((Cyg_Thread *)thread)->measure_stack_usage(); |
|
d397fc472bcf
Merge from eCos master repository on 2001-01-05-06:43:02-GMT
jlarmour
parents:
115
diff
changeset
|
284 } |
|
d397fc472bcf
Merge from eCos master repository on 2001-01-05-06:43:02-GMT
jlarmour
parents:
115
diff
changeset
|
285 #endif |
|
10
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
286 |
| 2 | 287 /*---------------------------------------------------------------------------*/ |
| 288 /* Per-thread data */ | |
| 289 | |
| 290 #ifdef CYGVAR_KERNEL_THREADS_DATA | |
| 291 | |
| 292 externC cyg_ucount32 cyg_thread_new_data_index() | |
| 293 { | |
| 294 return Cyg_Thread::new_data_index(); | |
| 295 } | |
| 296 | |
| 297 externC void cyg_thread_free_data_index(cyg_ucount32 index) | |
| 298 { | |
| 299 Cyg_Thread::free_data_index(index); | |
| 300 } | |
| 301 | |
| 302 externC CYG_ADDRWORD cyg_thread_get_data(cyg_ucount32 index) | |
| 303 { | |
| 304 return Cyg_Thread::get_data(index); | |
| 305 } | |
| 306 | |
| 307 externC CYG_ADDRWORD *cyg_thread_get_data_ptr(cyg_ucount32 index) | |
| 308 { | |
| 309 return Cyg_Thread::get_data_ptr(index); | |
| 310 } | |
| 311 | |
| 312 externC void cyg_thread_set_data(cyg_ucount32 index, CYG_ADDRWORD | |
| 313 data) | |
| 314 { | |
| 315 Cyg_Thread::self()->set_data(index, data); | |
| 316 } | |
| 317 #endif | |
| 0 | 318 |
| 319 /*---------------------------------------------------------------------------*/ | |
| 320 /* Exception handling. */ | |
| 321 | |
| 322 #ifdef CYGPKG_KERNEL_EXCEPTIONS | |
| 323 externC void cyg_exception_set_handler( | |
| 324 cyg_code_t exception_number, | |
| 325 cyg_exception_handler_t *new_handler, | |
| 2 | 326 cyg_addrword_t new_data, |
| 0 | 327 cyg_exception_handler_t **old_handler, |
| 2 | 328 cyg_addrword_t *old_data |
| 0 | 329 ) |
| 330 { | |
| 331 Cyg_Thread::register_exception( | |
| 332 exception_number, | |
| 333 (cyg_exception_handler *)new_handler, | |
| 334 (CYG_ADDRWORD)new_data, | |
| 335 (cyg_exception_handler **)old_handler, | |
| 336 (CYG_ADDRWORD *)old_data | |
| 337 ); | |
| 338 } | |
| 339 | |
| 340 /* Clear exception handler to default */ | |
| 341 externC void cyg_exception_clear_handler( | |
| 342 cyg_code_t exception_number | |
| 343 ) | |
| 344 { | |
| 345 Cyg_Thread::deregister_exception( exception_number ); | |
| 346 } | |
| 347 | |
| 348 /* Invoke exception handler */ | |
| 349 externC void cyg_exception_call_handler( | |
| 350 cyg_handle_t thread, | |
| 351 cyg_code_t exception_number, | |
| 2 | 352 cyg_addrword_t error_code |
| 0 | 353 ) |
| 354 { | |
| 355 Cyg_Thread *t = (Cyg_Thread *)thread; | |
| 356 | |
| 357 t->deliver_exception( exception_number, error_code ); | |
| 358 } | |
| 359 #endif | |
| 360 | |
| 361 /*---------------------------------------------------------------------------*/ | |
| 362 /* Interrupt handling */ | |
| 363 | |
| 364 externC void cyg_interrupt_create( | |
| 365 cyg_vector_t vector, /* Vector to attach to */ | |
| 366 cyg_priority_t priority, /* Queue priority */ | |
| 2 | 367 cyg_addrword_t data, /* Data pointer */ |
| 0 | 368 cyg_ISR_t *isr, /* Interrupt Service Routine */ |
| 369 cyg_DSR_t *dsr, /* Deferred Service Routine */ | |
| 370 cyg_handle_t *handle, /* returned handle */ | |
| 371 cyg_interrupt *intr /* put interrupt here */ | |
| 372 ) | |
| 373 { | |
| 374 CYG_ASSERT_SIZES( cyg_interrupt, Cyg_Interrupt ); | |
| 375 | |
| 376 Cyg_Interrupt *t = new((void *)intr) Cyg_Interrupt ( | |
| 377 (cyg_vector)vector, | |
| 378 (cyg_priority)priority, | |
| 379 (CYG_ADDRWORD)data, | |
| 380 (cyg_ISR *)isr, | |
| 381 (cyg_DSR *)dsr ); | |
| 382 t=t; | |
| 383 | |
| 384 CYG_CHECK_DATA_PTR( handle, "Bad handle pointer" ); | |
| 385 *handle = (cyg_handle_t)intr; | |
| 386 } | |
| 387 | |
| 388 externC void cyg_interrupt_delete( cyg_handle_t interrupt) | |
| 389 { | |
| 390 ((Cyg_Interrupt *)interrupt)->~Cyg_Interrupt(); | |
| 391 } | |
| 392 | |
| 393 void cyg_interrupt_attach( cyg_handle_t interrupt ) | |
| 394 { | |
| 395 ((Cyg_Interrupt *)interrupt)->attach(); | |
| 396 } | |
| 397 | |
| 398 void cyg_interrupt_detach( cyg_handle_t interrupt ) | |
| 399 { | |
| 400 ((Cyg_Interrupt *)interrupt)->detach(); | |
| 401 } | |
| 402 | |
| 403 /* VSR manipulation */ | |
| 404 | |
| 405 externC void cyg_interrupt_get_vsr( | |
| 406 cyg_vector_t vector, /* vector to get */ | |
| 407 cyg_VSR_t **vsr /* vsr got */ | |
| 408 ) | |
| 409 { | |
| 410 Cyg_Interrupt::get_vsr( (cyg_vector)vector, (cyg_VSR **)vsr); | |
| 411 } | |
| 412 | |
| 413 externC void cyg_interrupt_set_vsr( | |
| 414 cyg_vector_t vector, /* vector to set */ | |
| 415 cyg_VSR_t *vsr /* vsr to set */ | |
| 416 ) | |
| 417 { | |
| 418 Cyg_Interrupt::set_vsr( (cyg_vector)vector, (cyg_VSR *)vsr); | |
| 419 } | |
| 420 | |
| 421 /* CPU level interrupt mask */ | |
| 422 externC void cyg_interrupt_disable() | |
| 423 { | |
| 424 Cyg_Interrupt::disable_interrupts(); | |
| 425 } | |
| 426 | |
| 427 externC void cyg_interrupt_enable() | |
| 428 { | |
| 429 Cyg_Interrupt::enable_interrupts(); | |
| 430 } | |
| 431 | |
| 432 /* Interrupt controller access */ | |
| 433 externC void cyg_interrupt_mask(cyg_vector_t vector) | |
| 434 { | |
| 435 Cyg_Interrupt::mask_interrupt( (cyg_vector)vector); | |
| 436 } | |
| 437 | |
| 438 externC void cyg_interrupt_unmask(cyg_vector_t vector) | |
| 439 { | |
| 440 Cyg_Interrupt::unmask_interrupt( (cyg_vector)vector); | |
| 441 } | |
| 442 | |
| 443 | |
| 444 externC void cyg_interrupt_acknowledge(cyg_vector_t vector) | |
| 445 { | |
| 446 Cyg_Interrupt::acknowledge_interrupt( (cyg_vector)vector); | |
| 447 } | |
| 448 | |
| 449 | |
| 450 externC void cyg_interrupt_configure( | |
| 451 cyg_vector_t vector, /* vector to configure */ | |
| 452 cyg_bool_t level, /* level or edge triggered */ | |
| 453 cyg_bool_t up /* rising/faling edge, high/low level*/ | |
| 454 ) | |
| 455 { | |
| 456 Cyg_Interrupt::configure_interrupt( (cyg_vector)vector, level, up ); | |
| 457 } | |
| 458 | |
|
177
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
459 externC void cyg_interrupt_set_cpu( |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
460 cyg_vector_t vector, /* vector to control */ |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
461 cyg_cpu_t cpu /* CPU to set */ |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
462 ) |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
463 { |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
464 #ifdef CYGPKG_KERNEL_SMP_SUPPORT |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
465 Cyg_Interrupt::set_cpu( vector, cpu ); |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
466 #endif |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
467 } |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
468 |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
469 externC cyg_cpu_t cyg_interrupt_get_cpu( |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
470 cyg_vector_t vector /* vector to control */ |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
471 ) |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
472 { |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
473 #ifdef CYGPKG_KERNEL_SMP_SUPPORT |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
474 return Cyg_Interrupt::get_cpu( vector ); |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
475 #else |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
476 return CYG_KERNEL_CPU_THIS(); |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
477 #endif |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
478 |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
479 } |
| 0 | 480 |
| 481 /*---------------------------------------------------------------------------*/ | |
| 482 /* Counters, Clocks and Alarms */ | |
| 483 | |
| 484 externC void cyg_counter_create( | |
| 485 cyg_handle_t *handle, /* returned counter handle */ | |
| 486 cyg_counter *counter /* put counter here */ | |
| 487 ) | |
| 488 { | |
| 489 CYG_ASSERT_SIZES( cyg_counter, Cyg_Counter ); | |
| 490 | |
| 491 Cyg_Counter *t = new((void *)counter) Cyg_Counter (); | |
| 492 t=t; | |
| 493 | |
| 494 CYG_CHECK_DATA_PTR( handle, "Bad handle pointer" ); | |
| 495 *handle = (cyg_handle_t)counter; | |
| 496 } | |
| 497 | |
| 498 externC void cyg_counter_delete(cyg_handle_t counter) | |
| 499 { | |
| 500 ((Cyg_Counter *)counter)->~Cyg_Counter(); | |
| 501 } | |
| 502 | |
| 503 /* Return current value of counter */ | |
| 504 externC cyg_tick_count_t cyg_counter_current_value(cyg_handle_t counter) | |
| 505 { | |
| 506 return ((Cyg_Counter *)counter)->current_value(); | |
| 507 } | |
| 508 | |
| 509 /* Set new current value */ | |
| 510 externC void cyg_counter_set_value( | |
| 511 cyg_handle_t counter, | |
| 512 cyg_tick_count_t new_value | |
| 513 ) | |
| 514 { | |
| 515 ((Cyg_Counter *)counter)->set_value( new_value ); | |
| 516 } | |
| 517 | |
| 518 /* Advance counter by one tick */ | |
| 519 externC void cyg_counter_tick(cyg_handle_t counter) | |
| 520 { | |
| 521 ((Cyg_Counter *)counter)->tick(); | |
| 522 } | |
| 523 | |
| 524 /* Create a clock object */ | |
| 525 externC void cyg_clock_create( | |
| 526 cyg_resolution_t resolution, /* Initial resolution */ | |
| 527 cyg_handle_t *handle, /* Returned clock handle */ | |
| 528 cyg_clock *clock /* put clock here */ | |
| 529 ) | |
| 530 { | |
| 531 CYG_ASSERT_SIZES( cyg_clock, Cyg_Clock ); | |
| 532 | |
| 533 Cyg_Clock::cyg_resolution res; | |
| 534 | |
| 535 res.dividend = resolution.dividend; | |
| 536 res.divisor = resolution.divisor; | |
| 537 | |
| 538 Cyg_Clock *t = new((void *)clock) Cyg_Clock ( res ); | |
| 539 t=t; | |
| 540 | |
| 541 CYG_CHECK_DATA_PTR( handle, "Bad handle pointer" ); | |
| 542 *handle = (cyg_handle_t)clock; | |
| 543 } | |
| 544 | |
| 545 externC void cyg_clock_delete(cyg_handle_t clock) | |
| 546 { | |
| 547 ((Cyg_Clock *)clock)->~Cyg_Clock(); | |
| 548 } | |
| 549 | |
| 550 /* convert a clock handle to a counter handle so we can use the */ | |
| 551 /* counter API on it. */ | |
| 552 externC void cyg_clock_to_counter( | |
| 553 cyg_handle_t clock, | |
| 554 cyg_handle_t *counter | |
| 555 ) | |
| 556 { | |
| 557 CYG_CHECK_DATA_PTR( counter, "Bad counter handle pointer" ); | |
| 558 *counter = (cyg_handle_t)(Cyg_Counter *)clock; | |
| 559 } | |
| 560 | |
| 561 externC void cyg_clock_set_resolution( | |
| 562 cyg_handle_t clock, | |
| 563 cyg_resolution_t resolution /* New resolution */ | |
| 564 ) | |
| 565 { | |
| 566 Cyg_Clock::cyg_resolution res; | |
| 567 | |
| 568 res.dividend = resolution.dividend; | |
| 569 res.divisor = resolution.divisor; | |
| 570 | |
| 571 ((Cyg_Clock *)clock)->set_resolution( res ); | |
| 572 } | |
| 573 | |
| 574 externC cyg_resolution_t cyg_clock_get_resolution(cyg_handle_t clock) | |
| 575 { | |
| 576 Cyg_Clock::cyg_resolution res = | |
| 577 ((Cyg_Clock *)clock)->get_resolution(); | |
| 578 | |
| 579 cyg_resolution_t resolution; | |
| 580 | |
| 581 resolution.dividend = res.dividend; | |
| 582 resolution.divisor = res.divisor; | |
| 583 | |
| 584 return resolution; | |
| 585 } | |
| 586 | |
| 587 #ifdef CYGVAR_KERNEL_COUNTERS_CLOCK | |
| 588 externC cyg_handle_t cyg_real_time_clock(void) | |
| 589 { | |
| 590 return (cyg_handle_t)Cyg_Clock::real_time_clock; | |
| 591 } | |
| 592 | |
| 593 externC cyg_tick_count_t cyg_current_time(void) | |
| 594 { | |
| 595 return Cyg_Clock::real_time_clock->current_value(); | |
| 596 } | |
| 597 #endif | |
| 598 | |
| 599 externC void cyg_alarm_create( | |
| 600 cyg_handle_t counter, /* Attached to this counter */ | |
| 601 cyg_alarm_t *alarmfn, /* Call-back function */ | |
| 2 | 602 cyg_addrword_t data, /* Call-back data */ |
| 0 | 603 cyg_handle_t *handle, /* Returned alarm object */ |
| 604 cyg_alarm *alarm /* put alarm here */ | |
| 605 ) | |
| 606 { | |
| 607 CYG_ASSERT_SIZES( cyg_alarm, Cyg_Alarm ); | |
| 608 | |
| 609 Cyg_Alarm *t = new((void *)alarm) Cyg_Alarm ( | |
| 610 (Cyg_Counter *)counter, | |
| 2 | 611 (cyg_alarm_fn *)alarmfn, |
| 612 (CYG_ADDRWORD)data | |
| 0 | 613 ); |
| 614 t=t; | |
| 615 | |
| 616 CYG_CHECK_DATA_PTR( handle, "Bad handle pointer" ); | |
| 617 *handle = (cyg_handle_t)alarm; | |
| 618 } | |
| 619 | |
| 620 /* Disable alarm, detach from counter and invalidate handles */ | |
| 621 externC void cyg_alarm_delete( cyg_handle_t alarm) | |
| 622 { | |
| 623 ((Cyg_Alarm *)alarm)->~Cyg_Alarm(); | |
| 624 } | |
| 625 | |
| 626 externC void cyg_alarm_initialize( | |
| 627 cyg_handle_t alarm, | |
| 628 cyg_tick_count_t trigger, /* Absolute trigger time */ | |
| 629 cyg_tick_count_t interval /* Relative retrigger interval */ | |
| 630 ) | |
| 631 { | |
| 632 ((Cyg_Alarm *)alarm)->initialize( | |
| 2 | 633 (cyg_tick_count)trigger, |
| 634 (cyg_tick_count)interval); | |
| 0 | 635 } |
| 636 | |
| 637 externC void cyg_alarm_enable( cyg_handle_t alarm ) | |
| 638 { | |
| 639 ((Cyg_Alarm *)alarm)->enable(); | |
| 640 } | |
| 641 | |
| 642 externC void cyg_alarm_disable( cyg_handle_t alarm ) | |
| 643 { | |
| 644 ((Cyg_Alarm *)alarm)->disable(); | |
| 645 } | |
| 646 | |
| 647 /*---------------------------------------------------------------------------*/ | |
| 648 /* Mail boxes */ | |
| 649 | |
| 650 externC void cyg_mbox_create( | |
| 651 cyg_handle_t *handle, | |
| 652 cyg_mbox *mbox | |
| 653 ) | |
| 654 { | |
| 655 CYG_ASSERT_SIZES( cyg_mbox, Cyg_Mbox ); | |
| 656 | |
| 657 Cyg_Mbox *t = new((void *)mbox) Cyg_Mbox(); | |
| 658 t=t; | |
| 659 | |
| 660 CYG_CHECK_DATA_PTR( handle, "Bad handle pointer" ); | |
| 661 *handle = (cyg_handle_t)mbox; | |
| 662 } | |
| 663 | |
| 664 externC void cyg_mbox_delete(cyg_handle_t mbox) | |
| 665 { | |
| 666 ((Cyg_Mbox *)mbox)->~Cyg_Mbox(); | |
| 667 } | |
| 668 | |
| 669 externC void *cyg_mbox_get(cyg_handle_t mbox) | |
| 670 { | |
| 671 return ((Cyg_Mbox *)mbox)->get(); | |
| 672 } | |
| 673 | |
| 674 #ifdef CYGFUN_KERNEL_THREADS_TIMER | |
| 675 void *cyg_mbox_timed_get( | |
| 676 cyg_handle_t mbox, | |
| 677 cyg_tick_count_t abstime | |
| 678 ) | |
| 679 { | |
| 680 return ((Cyg_Mbox *)mbox)->get(abstime); | |
| 681 } | |
| 682 #endif | |
| 683 | |
| 684 externC void *cyg_mbox_tryget(cyg_handle_t mbox) | |
| 685 { | |
| 686 return ((Cyg_Mbox *)mbox)->tryget(); | |
| 687 } | |
| 688 | |
| 689 externC void *cyg_mbox_peek_item(cyg_handle_t mbox) | |
| 690 { | |
| 691 return ((Cyg_Mbox *)mbox)->peek_item(); | |
| 692 } | |
| 693 | |
| 694 #ifdef CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT | |
| 695 externC cyg_bool_t cyg_mbox_put(cyg_handle_t mbox, void *item) | |
| 696 { | |
| 697 return ((Cyg_Mbox *)mbox)->put(item); | |
| 698 } | |
| 699 | |
| 700 #ifdef CYGFUN_KERNEL_THREADS_TIMER | |
| 701 externC cyg_bool_t cyg_mbox_timed_put( | |
| 702 cyg_handle_t mbox, | |
| 703 void *item, | |
| 704 cyg_tick_count_t abstime | |
| 705 ) | |
| 706 { | |
| 707 return ((Cyg_Mbox *)mbox)->put(item, abstime); | |
| 708 } | |
| 709 #endif | |
| 710 #endif | |
| 711 | |
| 712 externC cyg_bool_t cyg_mbox_tryput(cyg_handle_t mbox, void *item) | |
| 713 { | |
| 714 return ((Cyg_Mbox *)mbox)->tryput(item); | |
| 715 } | |
| 716 | |
| 717 externC cyg_count32 cyg_mbox_peek(cyg_handle_t mbox) | |
| 718 { | |
| 719 return ((Cyg_Mbox *)mbox)->peek(); | |
| 720 } | |
| 721 | |
| 722 externC cyg_bool_t cyg_mbox_waiting_to_get(cyg_handle_t mbox) | |
| 723 { | |
| 724 return ((Cyg_Mbox *)mbox)->waiting_to_get(); | |
| 725 } | |
| 726 | |
| 727 externC cyg_bool_t cyg_mbox_waiting_to_put(cyg_handle_t mbox) | |
| 728 { | |
| 729 return ((Cyg_Mbox *)mbox)->waiting_to_put(); | |
| 730 } | |
| 731 | |
| 732 | |
| 733 /*---------------------------------------------------------------------------*/ | |
| 734 /* Semaphores */ | |
| 735 | |
| 736 externC void cyg_semaphore_init( | |
| 737 cyg_sem_t *sem, /* Semaphore to init */ | |
| 2 | 738 cyg_count32 val /* Initial semaphore value */ |
| 0 | 739 ) |
| 740 { | |
| 741 CYG_ASSERT_SIZES( cyg_sem_t, Cyg_Counting_Semaphore ); | |
| 742 | |
| 743 Cyg_Counting_Semaphore *t = new((void *)sem) Cyg_Counting_Semaphore(val); | |
| 744 t=t; | |
| 745 } | |
| 746 | |
| 747 externC void cyg_semaphore_destroy( cyg_sem_t *sem ) | |
| 748 { | |
| 749 ((Cyg_Counting_Semaphore *)sem)->~Cyg_Counting_Semaphore(); | |
| 750 } | |
| 751 | |
|
115
6ed91473a1cd
Merge from eCos master repository on 2000-08-21-22:40:54-BST
jlarmour
parents:
105
diff
changeset
|
752 externC cyg_bool_t cyg_semaphore_wait( cyg_sem_t *sem ) |
| 0 | 753 { |
|
115
6ed91473a1cd
Merge from eCos master repository on 2000-08-21-22:40:54-BST
jlarmour
parents:
105
diff
changeset
|
754 return ((Cyg_Counting_Semaphore *)sem)->wait(); |
| 0 | 755 } |
| 756 | |
| 757 #ifdef CYGFUN_KERNEL_THREADS_TIMER | |
| 758 externC cyg_bool_t cyg_semaphore_timed_wait( | |
| 759 cyg_sem_t *sem, | |
| 760 cyg_tick_count_t abstime | |
| 761 ) | |
| 762 { | |
| 763 return ((Cyg_Counting_Semaphore *)sem)->wait(abstime); | |
| 764 } | |
| 765 #endif | |
| 766 | |
| 767 | |
| 768 externC int cyg_semaphore_trywait( cyg_sem_t *sem ) | |
| 769 { | |
| 770 return ((Cyg_Counting_Semaphore *)sem)->trywait(); | |
| 771 } | |
| 772 | |
| 773 externC void cyg_semaphore_post( cyg_sem_t *sem ) | |
| 774 { | |
| 775 ((Cyg_Counting_Semaphore *)sem)->post(); | |
| 776 } | |
| 777 | |
| 2 | 778 externC void cyg_semaphore_peek( cyg_sem_t *sem, cyg_count32 *val ) |
| 0 | 779 { |
| 780 CYG_CHECK_DATA_PTR( val, "Bad val parameter" ); | |
| 781 | |
| 782 *val = ((Cyg_Counting_Semaphore *)sem)->peek(); | |
| 783 } | |
| 784 | |
| 785 | |
| 786 /*---------------------------------------------------------------------------*/ | |
| 787 /* Flags */ | |
| 788 | |
| 789 void cyg_flag_init( | |
| 790 cyg_flag_t *flag /* Flag to init */ | |
| 791 ) | |
| 792 { | |
| 793 CYG_ASSERT_SIZES( cyg_flag_t, Cyg_Flag ); | |
| 794 CYG_ASSERT( | |
| 795 ( Cyg_Flag::AND == CYG_FLAG_WAITMODE_AND ) && | |
| 796 ( Cyg_Flag::OR == CYG_FLAG_WAITMODE_OR ) && | |
| 797 ( Cyg_Flag::CLR == CYG_FLAG_WAITMODE_CLR ), | |
| 798 "CYG_FLAG_WAITMODE_xxx definition != C++ Cyg_Flag::xxx" ); | |
| 799 | |
| 800 Cyg_Flag *t = new((void *)flag) Cyg_Flag(); | |
| 801 t=t; | |
| 802 } | |
| 803 | |
| 804 void cyg_flag_destroy( cyg_flag_t *flag ) | |
| 805 { | |
| 806 ((Cyg_Flag *)flag)->~Cyg_Flag(); | |
| 807 } | |
| 808 | |
| 809 void cyg_flag_setbits( cyg_flag_t *flag, cyg_flag_value_t value) | |
| 810 { | |
| 811 ((Cyg_Flag *)flag)->setbits( value ); | |
| 812 } | |
| 813 | |
| 814 void cyg_flag_maskbits( cyg_flag_t *flag, cyg_flag_value_t value) | |
| 815 { | |
| 816 ((Cyg_Flag *)flag)->maskbits( value ); | |
| 817 } | |
| 818 | |
| 819 cyg_flag_value_t cyg_flag_wait( cyg_flag_t *flag, | |
| 820 cyg_flag_value_t pattern, | |
| 821 cyg_flag_mode_t mode ) | |
| 822 { | |
| 823 if ( 0 == pattern || 0 != (mode & ~3) ) | |
| 824 return 0; | |
| 825 return ((Cyg_Flag *)flag)->wait( pattern, mode ); | |
| 826 | |
| 827 } | |
| 828 | |
| 829 #ifdef CYGFUN_KERNEL_THREADS_TIMER | |
| 830 cyg_flag_value_t cyg_flag_timed_wait( cyg_flag_t *flag, | |
| 831 cyg_flag_value_t pattern, | |
| 832 cyg_flag_mode_t mode, | |
| 833 cyg_tick_count_t abstime ) | |
| 834 { | |
| 835 if ( 0 == pattern || 0 != (mode & ~3) ) | |
| 836 return 0; | |
| 837 return ((Cyg_Flag *)flag)->wait( pattern, mode, abstime ); | |
| 838 | |
| 839 } | |
| 840 #endif | |
| 841 | |
| 842 cyg_flag_value_t cyg_flag_poll( cyg_flag_t *flag, | |
| 843 cyg_flag_value_t pattern, | |
| 844 cyg_flag_mode_t mode ) | |
| 845 { | |
| 846 if ( 0 == pattern || 0 != (mode & ~3) ) | |
| 847 return 0; | |
| 848 return ((Cyg_Flag *)flag)->poll( pattern, mode ); | |
| 849 | |
| 850 } | |
| 851 | |
| 852 cyg_flag_value_t cyg_flag_peek( cyg_flag_t *flag ) | |
| 853 { | |
| 854 return ((Cyg_Flag *)flag)->peek(); | |
| 855 } | |
| 856 | |
| 857 cyg_bool_t cyg_flag_waiting( cyg_flag_t *flag ) | |
| 858 { | |
| 859 return ((Cyg_Flag *)flag)->waiting(); | |
| 860 } | |
| 861 | |
| 862 /*---------------------------------------------------------------------------*/ | |
| 863 /* Mutex */ | |
| 864 | |
| 865 externC void cyg_mutex_init( | |
| 866 cyg_mutex_t *mutex /* Mutex to init */ | |
| 867 ) | |
| 868 { | |
| 869 CYG_ASSERT_SIZES( cyg_mutex_t, Cyg_Mutex ); | |
| 870 | |
| 871 Cyg_Mutex *m = new((void *)mutex) Cyg_Mutex; | |
| 872 | |
| 873 m=m; | |
| 874 } | |
| 875 | |
| 876 externC void cyg_mutex_destroy( cyg_mutex_t *mutex ) | |
| 877 { | |
|
38
e7ba79f6d3a8
Merge from eCos master repository on 1999-09-23-20:10:25-BST
jlarmour
parents:
10
diff
changeset
|
878 ((Cyg_Mutex *)mutex)->~Cyg_Mutex(); |
| 0 | 879 } |
| 880 | |
| 2 | 881 externC cyg_bool_t cyg_mutex_lock( cyg_mutex_t *mutex ) |
| 0 | 882 { |
| 2 | 883 return ((Cyg_Mutex *)mutex)->lock(); |
| 0 | 884 } |
| 885 | |
| 886 externC cyg_bool_t cyg_mutex_trylock( cyg_mutex_t *mutex ) | |
| 887 { | |
| 888 return ((Cyg_Mutex *)mutex)->trylock(); | |
| 889 } | |
| 890 | |
| 891 externC void cyg_mutex_unlock( cyg_mutex_t *mutex ) | |
| 892 { | |
| 893 ((Cyg_Mutex *)mutex)->unlock(); | |
| 894 } | |
| 895 | |
| 2 | 896 externC void cyg_mutex_release( cyg_mutex_t *mutex ) |
| 897 { | |
| 898 ((Cyg_Mutex *)mutex)->release(); | |
| 899 } | |
| 900 | |
|
177
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
901 #ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
902 externC void cyg_mutex_set_ceiling( |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
903 cyg_mutex_t *mutex, |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
904 cyg_priority_t priority ) |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
905 { |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
906 ((Cyg_Mutex *)mutex)->set_ceiling(priority); |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
907 } |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
908 #endif |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
909 |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
910 #ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DYNAMIC |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
911 externC void cyg_mutex_set_protocol( |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
912 cyg_mutex_t *mutex, |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
913 enum cyg_protcol protocol ) |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
914 { |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
915 ((Cyg_Mutex *)mutex)->set_protocol((Cyg_Mutex::cyg_protcol)protocol); |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
916 } |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
917 #endif |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
918 |
| 0 | 919 /*---------------------------------------------------------------------------*/ |
| 920 /* Condition Variables */ | |
| 921 | |
| 922 externC void cyg_cond_init( | |
| 923 cyg_cond_t *cond, /* condition variable to init */ | |
| 924 cyg_mutex_t *mutex /* associated mutex */ | |
| 925 ) | |
| 926 { | |
| 927 CYG_ASSERT_SIZES( cyg_cond_t, Cyg_Condition_Variable ); | |
| 928 | |
| 929 Cyg_Condition_Variable *t = new((void *)cond) Cyg_Condition_Variable( | |
| 930 *(Cyg_Mutex *)mutex); | |
| 931 t=t; | |
| 932 } | |
| 933 | |
| 934 externC void cyg_cond_destroy( cyg_cond_t *cond ) | |
| 935 { | |
|
38
e7ba79f6d3a8
Merge from eCos master repository on 1999-09-23-20:10:25-BST
jlarmour
parents:
10
diff
changeset
|
936 ((Cyg_Condition_Variable *)cond)->~Cyg_Condition_Variable(); |
| 0 | 937 } |
| 938 | |
|
115
6ed91473a1cd
Merge from eCos master repository on 2000-08-21-22:40:54-BST
jlarmour
parents:
105
diff
changeset
|
939 externC cyg_bool_t cyg_cond_wait( cyg_cond_t *cond ) |
| 0 | 940 { |
|
115
6ed91473a1cd
Merge from eCos master repository on 2000-08-21-22:40:54-BST
jlarmour
parents:
105
diff
changeset
|
941 return ((Cyg_Condition_Variable *)cond)->wait(); |
| 0 | 942 } |
| 943 | |
| 944 externC void cyg_cond_signal( cyg_cond_t *cond ) | |
| 945 { | |
| 946 ((Cyg_Condition_Variable *)cond)->signal(); | |
| 947 } | |
| 948 | |
| 949 externC void cyg_cond_broadcast( cyg_cond_t *cond ) | |
| 950 { | |
| 951 ((Cyg_Condition_Variable *)cond)->broadcast(); | |
| 952 } | |
| 953 | |
| 954 #ifdef CYGMFN_KERNEL_SYNCH_CONDVAR_TIMED_WAIT | |
| 955 externC cyg_bool_t cyg_cond_timed_wait( | |
| 956 cyg_cond_t *cond, | |
| 957 cyg_tick_count_t abstime | |
| 958 ) | |
| 959 { | |
| 960 return ((Cyg_Condition_Variable *)cond)->wait(abstime); | |
| 961 } | |
| 962 | |
| 963 #endif | |
| 964 | |
|
177
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
965 /*---------------------------------------------------------------------------*/ |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
966 /* Spinlocks */ |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
967 |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
968 externC void cyg_spinlock_init( |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
969 cyg_spinlock_t *lock, /* spinlock to initialize */ |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
970 cyg_bool_t locked /* init locked or unlocked */ |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
971 ) |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
972 { |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
973 CYG_ASSERT_SIZES( cyg_spinlock_t, Cyg_SpinLock ); |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
974 |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
975 // Create the spinlock in cleared state |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
976 Cyg_SpinLock *t = new((void *)lock) Cyg_SpinLock(); |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
977 |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
978 // If the lock is to start locked, then lock it now. |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
979 if( locked ) |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
980 t->spin(); |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
981 } |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
982 |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
983 externC void cyg_spinlock_destroy( cyg_spinlock_t *lock ) |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
984 { |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
985 ((Cyg_SpinLock *)lock)->~Cyg_SpinLock(); |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
986 } |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
987 |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
988 externC void cyg_spinlock_spin( cyg_spinlock_t *lock ) |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
989 { |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
990 ((Cyg_SpinLock *)lock)->spin(); |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
991 } |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
992 |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
993 externC void cyg_spinlock_clear( cyg_spinlock_t *lock ) |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
994 { |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
995 ((Cyg_SpinLock *)lock)->clear(); |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
996 } |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
997 |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
998 externC cyg_bool_t cyg_spinlock_try( cyg_spinlock_t *lock ) |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
999 { |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1000 return ((Cyg_SpinLock *)lock)->trylock(); |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1001 } |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1002 |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1003 externC cyg_bool_t cyg_spinlock_test( cyg_spinlock_t *lock ) |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1004 { |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1005 return ((Cyg_SpinLock *)lock)->test(); |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1006 } |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1007 |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1008 externC void cyg_spinlock_spin_intsave( cyg_spinlock_t *lock, |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1009 cyg_addrword_t *istate ) |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1010 { |
|
178
aa8364213009
Merge from eCos master repository on 2001-08-15-01:50:29-BST
jlarmour
parents:
177
diff
changeset
|
1011 ((Cyg_SpinLock *)lock)->spin_intsave((CYG_INTERRUPT_STATE *)istate); |
|
177
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1012 } |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1013 |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1014 externC void cyg_spinlock_clear_intsave( cyg_spinlock_t *lock, |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1015 cyg_addrword_t istate ) |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1016 { |
|
178
aa8364213009
Merge from eCos master repository on 2001-08-15-01:50:29-BST
jlarmour
parents:
177
diff
changeset
|
1017 ((Cyg_SpinLock *)lock)->clear_intsave((CYG_INTERRUPT_STATE)istate); |
|
177
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1018 } |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1019 |
|
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1020 |
| 0 | 1021 // ------------------------------------------------------------------------- |
| 1022 // Check structure sizes. | |
| 1023 // This class and constructor get run automatically in debug versions | |
| 1024 // of the kernel and check that the structures configured in the C | |
| 1025 // code are the same size as the C++ classes they should match. | |
| 1026 | |
| 1027 #ifdef CYGPKG_INFRA_DEBUG | |
| 1028 | |
| 1029 class Cyg_Check_Structure_Sizes | |
| 1030 { | |
| 1031 int dummy; | |
| 1032 public: | |
| 1033 Cyg_Check_Structure_Sizes( int x ); | |
| 1034 | |
| 1035 }; | |
| 1036 | |
| 1037 #define CYG_CHECK_SIZES(cstruct, cxxstruct) \ | |
| 1038 if( sizeof(cstruct) != sizeof(cxxstruct) ) \ | |
| 1039 { \ | |
| 1040 char *fmt = "Size of C struct " #cstruct \ | |
| 1041 " != size of C++ struct " #cxxstruct ; \ | |
| 1042 CYG_TRACE2(1, fmt, sizeof(cstruct) , sizeof(cxxstruct) ); \ | |
| 1043 fail = true; \ | |
| 1044 fmt = fmt; \ | |
| 1045 } | |
| 1046 | |
| 1047 Cyg_Check_Structure_Sizes::Cyg_Check_Structure_Sizes(int x) | |
| 1048 { | |
| 1049 cyg_bool fail = false; | |
| 1050 | |
| 1051 dummy = x+1; | |
| 1052 | |
| 1053 CYG_CHECK_SIZES( cyg_thread, Cyg_Thread ); | |
| 1054 CYG_CHECK_SIZES( cyg_interrupt, Cyg_Interrupt ); | |
| 1055 CYG_CHECK_SIZES( cyg_counter, Cyg_Counter ); | |
| 1056 CYG_CHECK_SIZES( cyg_clock, Cyg_Clock ); | |
| 1057 CYG_CHECK_SIZES( cyg_alarm, Cyg_Alarm ); | |
| 1058 CYG_CHECK_SIZES( cyg_mbox, Cyg_Mbox ); | |
| 1059 CYG_CHECK_SIZES( cyg_sem_t, Cyg_Counting_Semaphore ); | |
| 1060 CYG_CHECK_SIZES( cyg_flag_t, Cyg_Flag ); | |
| 1061 CYG_CHECK_SIZES( cyg_mutex_t, Cyg_Mutex ); | |
| 1062 CYG_CHECK_SIZES( cyg_cond_t, Cyg_Condition_Variable ); | |
|
177
4c750ce71ae3
Merge from eCos master repository on 2001-08-10-19:22:57-BST
jlarmour
parents:
147
diff
changeset
|
1063 CYG_CHECK_SIZES( cyg_spinlock_t, Cyg_SpinLock ); |
| 0 | 1064 |
| 1065 CYG_ASSERT( !fail, "Size checks failed"); | |
| 1066 } | |
| 1067 | |
|
115
6ed91473a1cd
Merge from eCos master repository on 2000-08-21-22:40:54-BST
jlarmour
parents:
105
diff
changeset
|
1068 static Cyg_Check_Structure_Sizes cyg_kapi_check_structure_sizes(1); |
| 0 | 1069 |
| 1070 #endif | |
| 1071 | |
| 1072 | |
| 1073 // ------------------------------------------------------------------------- | |
| 1074 | |
| 1075 #endif | |
| 1076 // EOF common/kapi.cxx |