|
0
|
1 #ifndef CYGONCE_KERNEL_INSTRMNT_HXX |
|
|
2 #define CYGONCE_KERNEL_INSTRMNT_HXX |
|
|
3 |
|
|
4 //========================================================================== |
|
|
5 // |
|
2
|
6 // instrmnt.hxx |
|
0
|
7 // |
|
2
|
8 // Kernel Instrumentation mechanism |
|
0
|
9 // |
|
|
10 //========================================================================== |
|
|
11 //####COPYRIGHTBEGIN#### |
|
|
12 // |
|
|
13 // ------------------------------------------- |
|
|
14 // The contents of this file are subject to the Cygnus eCos Public License |
|
|
15 // Version 1.0 (the "License"); you may not use this file except in |
|
|
16 // compliance with the License. You may obtain a copy of the License at |
|
|
17 // http://sourceware.cygnus.com/ecos |
|
|
18 // |
|
|
19 // Software distributed under the License is distributed on an "AS IS" |
|
|
20 // basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the |
|
|
21 // License for the specific language governing rights and limitations under |
|
|
22 // the License. |
|
|
23 // |
|
|
24 // The Original Code is eCos - Embedded Cygnus Operating System, released |
|
|
25 // September 30, 1998. |
|
|
26 // |
|
|
27 // The Initial Developer of the Original Code is Cygnus. Portions created |
|
2
|
28 // by Cygnus are Copyright (C) 1998,1999 Cygnus Solutions. All Rights Reserved. |
|
0
|
29 // ------------------------------------------- |
|
|
30 // |
|
|
31 //####COPYRIGHTEND#### |
|
|
32 //========================================================================== |
|
|
33 //#####DESCRIPTIONBEGIN#### |
|
|
34 // |
|
2
|
35 // Author(s): nickg |
|
|
36 // Contributors: nickg |
|
|
37 // Date: 1997-10-24 |
|
|
38 // Purpose: Define kernel instrumentation |
|
|
39 // Description: A set of definitions and macros used to implement an |
|
0
|
40 // instrumentation interface for the kernel. |
|
2
|
41 // Usage: #include <cyg/kernel/instrmnt.hxx> |
|
0
|
42 // |
|
|
43 //####DESCRIPTIONEND#### |
|
|
44 // |
|
|
45 //========================================================================== |
|
|
46 |
|
|
47 #include <cyg/kernel/ktypes.h> |
|
|
48 #include <cyg/infra/cyg_ass.h> // assertion macros |
|
|
49 |
|
|
50 // ------------------------------------------------------------------------- |
|
|
51 // Underlying instrumentation function |
|
|
52 |
|
|
53 externC void cyg_instrument( cyg_uint32 type, CYG_ADDRWORD arg1, CYG_ADDRWORD arg2 ); |
|
|
54 |
|
|
55 // ------------------------------------------------------------------------- |
|
|
56 // The following functions are used to enable and disable specific |
|
|
57 // instrumentation classes and events. The class must be one of the |
|
|
58 // class defines below. The event may be one of the event defines below |
|
|
59 // or zero, in which case all of the events in the class are enabled or |
|
|
60 // disabled. |
|
|
61 |
|
|
62 #ifdef CYGDBG_KERNEL_INSTRUMENT_FLAGS |
|
|
63 |
|
|
64 externC void cyg_instrument_enable( cyg_uint32 cl, cyg_uint32 event ); |
|
|
65 |
|
|
66 externC void cyg_instrument_disable( cyg_uint32 cl, cyg_uint32 event ); |
|
|
67 |
|
|
68 #endif |
|
|
69 |
|
|
70 // ------------------------------------------------------------------------- |
|
|
71 // Instrumentation macros |
|
|
72 |
|
|
73 #ifdef CYGPKG_KERNEL_INSTRUMENT |
|
|
74 |
|
2
|
75 #define CYG_INSTRUMENT(_type_,_arg1_,_arg2_) cyg_instrument(_type_, (CYG_ADDRWORD)(_arg1_), (CYG_ADDRWORD)(_arg2_)) |
|
0
|
76 |
|
|
77 #else // ifdef CYGPKG_KERNEL_INSTRUMENT |
|
|
78 |
|
2
|
79 #define CYG_INSTRUMENT(_type_,_arg1_,_arg2_) \ |
|
|
80 CYG_MACRO_START \ |
|
|
81 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg1_)); \ |
|
|
82 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg2_)); \ |
|
|
83 CYG_MACRO_END |
|
0
|
84 |
|
|
85 #endif // ifdef CYGPKG_KERNEL_INSTRUMENT |
|
|
86 |
|
|
87 // ------------------------------------------------------------------------- |
|
|
88 // Type codes. |
|
|
89 // Each code is 16 bit with an event class in the top 8 bits |
|
|
90 // and an event code in the lower 8 bits. |
|
|
91 |
|
|
92 // Event classes |
|
|
93 #define CYG_INSTRUMENT_CLASS_SCHED 0x0100 |
|
|
94 #define CYG_INSTRUMENT_CLASS_THREAD 0x0200 |
|
|
95 #define CYG_INSTRUMENT_CLASS_INTR 0x0300 |
|
|
96 #define CYG_INSTRUMENT_CLASS_MUTEX 0x0400 |
|
|
97 #define CYG_INSTRUMENT_CLASS_CONDVAR 0x0500 |
|
|
98 #define CYG_INSTRUMENT_CLASS_BINSEM 0x0600 |
|
|
99 #define CYG_INSTRUMENT_CLASS_CNTSEM 0x0700 |
|
|
100 #define CYG_INSTRUMENT_CLASS_CLOCK 0x0800 |
|
|
101 #define CYG_INSTRUMENT_CLASS_ALARM 0x0900 |
|
|
102 #define CYG_INSTRUMENT_CLASS_MBOXT 0x0a00 |
|
|
103 |
|
|
104 #define CYG_INSTRUMENT_CLASS_USER 0x0f00 |
|
|
105 |
|
|
106 #define CYG_INSTRUMENT_CLASS_MAX CYG_INSTRUMENT_CLASS_USER |
|
|
107 |
|
|
108 // Scheduler events |
|
|
109 #define CYG_INSTRUMENT_EVENT_SCHED_LOCK 1 |
|
|
110 #define CYG_INSTRUMENT_EVENT_SCHED_UNLOCK 2 |
|
|
111 #define CYG_INSTRUMENT_EVENT_SCHED_RESCHEDULE 3 |
|
|
112 #define CYG_INSTRUMENT_EVENT_SCHED_TIMESLICE 4 |
|
|
113 |
|
|
114 // Thread events |
|
|
115 #define CYG_INSTRUMENT_EVENT_THREAD_SWITCH 1 |
|
|
116 #define CYG_INSTRUMENT_EVENT_THREAD_SLEEP 2 |
|
|
117 #define CYG_INSTRUMENT_EVENT_THREAD_WAKE 3 |
|
|
118 #define CYG_INSTRUMENT_EVENT_THREAD_SUSPEND 4 |
|
|
119 #define CYG_INSTRUMENT_EVENT_THREAD_RESUME 5 |
|
|
120 #define CYG_INSTRUMENT_EVENT_THREAD_PRIORITY 6 |
|
|
121 #define CYG_INSTRUMENT_EVENT_THREAD_DELAY 7 |
|
|
122 #define CYG_INSTRUMENT_EVENT_THREAD_ALARM 8 |
|
|
123 |
|
|
124 // Interrupt events |
|
|
125 #define CYG_INSTRUMENT_EVENT_INTR_RAISE 1 |
|
|
126 #define CYG_INSTRUMENT_EVENT_INTR_END 2 |
|
|
127 #define CYG_INSTRUMENT_EVENT_INTR_RESTORE 3 |
|
|
128 #define CYG_INSTRUMENT_EVENT_INTR_POST_DSR 4 |
|
|
129 #define CYG_INSTRUMENT_EVENT_INTR_CALL_DSR 5 |
|
|
130 #define CYG_INSTRUMENT_EVENT_INTR_ATTACH 6 |
|
|
131 #define CYG_INSTRUMENT_EVENT_INTR_DETACH 7 |
|
|
132 #define CYG_INSTRUMENT_EVENT_INTR_SET_VSR 8 |
|
|
133 #define CYG_INSTRUMENT_EVENT_INTR_DISABLE 9 |
|
|
134 #define CYG_INSTRUMENT_EVENT_INTR_ENABLE 10 |
|
|
135 #define CYG_INSTRUMENT_EVENT_INTR_MASK 11 |
|
|
136 #define CYG_INSTRUMENT_EVENT_INTR_UNMASK 12 |
|
|
137 #define CYG_INSTRUMENT_EVENT_INTR_CONFIGURE 13 |
|
|
138 #define CYG_INSTRUMENT_EVENT_INTR_ACK 14 |
|
|
139 #define CYG_INSTRUMENT_EVENT_INTR_CHAIN_ISR 15 |
|
|
140 |
|
|
141 // Mutex events |
|
|
142 #define CYG_INSTRUMENT_EVENT_MUTEX_LOCK 1 |
|
|
143 #define CYG_INSTRUMENT_EVENT_MUTEX_WAIT 2 |
|
|
144 #define CYG_INSTRUMENT_EVENT_MUTEX_LOCKED 3 |
|
|
145 #define CYG_INSTRUMENT_EVENT_MUTEX_TRY 4 |
|
|
146 #define CYG_INSTRUMENT_EVENT_MUTEX_UNLOCK 5 |
|
|
147 #define CYG_INSTRUMENT_EVENT_MUTEX_WAKE 6 |
|
2
|
148 #define CYG_INSTRUMENT_EVENT_MUTEX_RELEASE 7 |
|
|
149 #define CYG_INSTRUMENT_EVENT_MUTEX_RELEASED 8 |
|
0
|
150 |
|
|
151 // Condition variable events |
|
|
152 #define CYG_INSTRUMENT_EVENT_CONDVAR_WAIT 1 |
|
|
153 #define CYG_INSTRUMENT_EVENT_CONDVAR_WOKE 2 |
|
|
154 #define CYG_INSTRUMENT_EVENT_CONDVAR_SIGNAL 3 |
|
|
155 #define CYG_INSTRUMENT_EVENT_CONDVAR_WAKE 4 |
|
|
156 #define CYG_INSTRUMENT_EVENT_CONDVAR_BROADCAST 5 |
|
|
157 #define CYG_INSTRUMENT_EVENT_CONDVAR_TIMED_WAIT 6 |
|
|
158 |
|
|
159 // Binary semaphore events |
|
|
160 #define CYG_INSTRUMENT_EVENT_BINSEM_CLAIM 1 |
|
|
161 #define CYG_INSTRUMENT_EVENT_BINSEM_WAIT 2 |
|
|
162 #define CYG_INSTRUMENT_EVENT_BINSEM_WOKE 3 |
|
|
163 #define CYG_INSTRUMENT_EVENT_BINSEM_TRY 4 |
|
|
164 #define CYG_INSTRUMENT_EVENT_BINSEM_POST 5 |
|
|
165 #define CYG_INSTRUMENT_EVENT_BINSEM_WAKE 6 |
|
|
166 |
|
|
167 // Counting semaphore events |
|
|
168 #define CYG_INSTRUMENT_EVENT_CNTSEM_CLAIM 1 |
|
|
169 #define CYG_INSTRUMENT_EVENT_CNTSEM_WAIT 2 |
|
|
170 #define CYG_INSTRUMENT_EVENT_CNTSEM_WOKE 3 |
|
|
171 #define CYG_INSTRUMENT_EVENT_CNTSEM_TRY 4 |
|
|
172 #define CYG_INSTRUMENT_EVENT_CNTSEM_POST 5 |
|
|
173 #define CYG_INSTRUMENT_EVENT_CNTSEM_WAKE 6 |
|
|
174 #define CYG_INSTRUMENT_EVENT_CNTSEM_TIMEOUT 7 |
|
|
175 |
|
|
176 // Clock events |
|
|
177 #define CYG_INSTRUMENT_EVENT_CLOCK_TICK_START 1 |
|
|
178 #define CYG_INSTRUMENT_EVENT_CLOCK_TICK_END 2 |
|
|
179 #define CYG_INSTRUMENT_EVENT_CLOCK_ISR 3 |
|
|
180 |
|
|
181 // Alarm events |
|
|
182 #define CYG_INSTRUMENT_EVENT_ALARM_ADD 1 |
|
|
183 #define CYG_INSTRUMENT_EVENT_ALARM_REM 2 |
|
|
184 #define CYG_INSTRUMENT_EVENT_ALARM_CALL 3 |
|
|
185 #define CYG_INSTRUMENT_EVENT_ALARM_INIT 4 |
|
|
186 #define CYG_INSTRUMENT_EVENT_ALARM_TRIGGER 5 |
|
|
187 #define CYG_INSTRUMENT_EVENT_ALARM_INTERVAL 6 |
|
|
188 |
|
|
189 // Mboxt events |
|
2
|
190 #define CYG_INSTRUMENT_EVENT_MBOXT_WAIT 1 |
|
|
191 #define CYG_INSTRUMENT_EVENT_MBOXT_GET 2 |
|
|
192 #define CYG_INSTRUMENT_EVENT_MBOXT_GOT 3 |
|
|
193 #define CYG_INSTRUMENT_EVENT_MBOXT_TIMEOUT 4 |
|
|
194 #define CYG_INSTRUMENT_EVENT_MBOXT_WAKE 5 |
|
|
195 #define CYG_INSTRUMENT_EVENT_MBOXT_TRY 6 |
|
|
196 #define CYG_INSTRUMENT_EVENT_MBOXT_PUT 7 |
|
0
|
197 |
|
|
198 |
|
|
199 |
|
|
200 // User events |
|
|
201 |
|
|
202 #define CYG_INSTRUMENT_EVENT_USER_1 1 |
|
|
203 #define CYG_INSTRUMENT_EVENT_USER_2 2 |
|
|
204 #define CYG_INSTRUMENT_EVENT_USER_3 3 |
|
|
205 #define CYG_INSTRUMENT_EVENT_USER_4 4 |
|
|
206 #define CYG_INSTRUMENT_EVENT_USER_5 5 |
|
|
207 #define CYG_INSTRUMENT_EVENT_USER_6 6 |
|
|
208 #define CYG_INSTRUMENT_EVENT_USER_7 7 |
|
|
209 #define CYG_INSTRUMENT_EVENT_USER_8 8 |
|
|
210 #define CYG_INSTRUMENT_EVENT_USER_9 9 |
|
|
211 #define CYG_INSTRUMENT_EVENT_USER_10 10 |
|
|
212 #define CYG_INSTRUMENT_EVENT_USER_11 11 |
|
|
213 #define CYG_INSTRUMENT_EVENT_USER_12 12 |
|
|
214 #define CYG_INSTRUMENT_EVENT_USER_13 13 |
|
|
215 #define CYG_INSTRUMENT_EVENT_USER_14 14 |
|
|
216 #define CYG_INSTRUMENT_EVENT_USER_15 15 |
|
|
217 #define CYG_INSTRUMENT_EVENT_USER_16 16 |
|
|
218 #define CYG_INSTRUMENT_EVENT_USER_17 17 |
|
|
219 #define CYG_INSTRUMENT_EVENT_USER_18 18 |
|
|
220 #define CYG_INSTRUMENT_EVENT_USER_19 19 |
|
|
221 |
|
|
222 // ------------------------------------------------------------------------- |
|
|
223 // Handy-dandy macro to make event codes. |
|
|
224 // Note that this relies on the definitions above |
|
|
225 // having a well defined form. |
|
|
226 |
|
|
227 #define CYGINST_EVENT(_class_,_event_) \ |
|
|
228 ((CYG_INSTRUMENT_CLASS_##_class_)|(CYG_INSTRUMENT_EVENT_##_class_##_##_event_)) |
|
|
229 |
|
|
230 // ------------------------------------------------------------------------- |
|
|
231 // Scheduler instrumentation macros |
|
|
232 |
|
|
233 #ifdef CYGDBG_KERNEL_INSTRUMENT_SCHED |
|
|
234 |
|
|
235 #define CYG_INSTRUMENT_SCHED(_event_,_arg1_,_arg2_) \ |
|
|
236 CYG_INSTRUMENT(CYGINST_EVENT(SCHED,_event_),_arg1_,_arg2_) |
|
|
237 |
|
|
238 #else |
|
|
239 |
|
2
|
240 #define CYG_INSTRUMENT_SCHED(_event_,_arg1_,_arg2_) \ |
|
|
241 CYG_MACRO_START \ |
|
|
242 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg1_)); \ |
|
|
243 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg2_)); \ |
|
|
244 CYG_MACRO_END |
|
0
|
245 |
|
|
246 #endif |
|
|
247 |
|
|
248 // ------------------------------------------------------------------------- |
|
|
249 // Thread instrumentation macros |
|
|
250 |
|
|
251 #ifdef CYGDBG_KERNEL_INSTRUMENT_THREAD |
|
|
252 |
|
|
253 #define CYG_INSTRUMENT_THREAD(_event_,_arg1_,_arg2_) \ |
|
|
254 CYG_INSTRUMENT(CYGINST_EVENT(THREAD,_event_),_arg1_,_arg2_) |
|
|
255 |
|
|
256 #else |
|
|
257 |
|
2
|
258 #define CYG_INSTRUMENT_THREAD(_event_,_arg1_,_arg2_) \ |
|
|
259 CYG_MACRO_START \ |
|
|
260 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg1_)); \ |
|
|
261 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg2_)); \ |
|
|
262 CYG_MACRO_END |
|
0
|
263 |
|
|
264 #endif |
|
|
265 |
|
|
266 // ------------------------------------------------------------------------- |
|
|
267 // Interrupt instrumentation macros |
|
|
268 |
|
|
269 #ifdef CYGDBG_KERNEL_INSTRUMENT_INTR |
|
|
270 |
|
|
271 #define CYG_INSTRUMENT_INTR(_event_,_arg1_,_arg2_) \ |
|
|
272 CYG_INSTRUMENT(CYGINST_EVENT(INTR,_event_),_arg1_,_arg2_) |
|
|
273 |
|
|
274 #else |
|
|
275 |
|
2
|
276 #define CYG_INSTRUMENT_INTR(_event_,_arg1_,_arg2_) \ |
|
|
277 CYG_MACRO_START \ |
|
|
278 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg1_)); \ |
|
|
279 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg2_)); \ |
|
|
280 CYG_MACRO_END |
|
0
|
281 |
|
|
282 #endif |
|
|
283 |
|
|
284 // ------------------------------------------------------------------------- |
|
|
285 // Mutex instrumentation macros |
|
|
286 |
|
|
287 #ifdef CYGDBG_KERNEL_INSTRUMENT_MUTEX |
|
|
288 |
|
|
289 #define CYG_INSTRUMENT_MUTEX(_event_,_arg1_,_arg2_) \ |
|
|
290 CYG_INSTRUMENT(CYGINST_EVENT(MUTEX,_event_),_arg1_,_arg2_) |
|
|
291 |
|
|
292 #else |
|
|
293 |
|
2
|
294 #define CYG_INSTRUMENT_MUTEX(_event_,_arg1_,_arg2_) \ |
|
|
295 CYG_MACRO_START \ |
|
|
296 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg1_)); \ |
|
|
297 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg2_)); \ |
|
|
298 CYG_MACRO_END |
|
0
|
299 |
|
|
300 #endif |
|
|
301 |
|
|
302 // ------------------------------------------------------------------------- |
|
|
303 // Condition variable instrumentation macros |
|
|
304 |
|
|
305 #ifdef CYGDBG_KERNEL_INSTRUMENT_CONDVAR |
|
|
306 |
|
|
307 #define CYG_INSTRUMENT_CONDVAR(_event_,_arg1_,_arg2_) \ |
|
|
308 CYG_INSTRUMENT(CYGINST_EVENT(CONDVAR,_event_),_arg1_,_arg2_) |
|
|
309 |
|
|
310 #else |
|
|
311 |
|
2
|
312 #define CYG_INSTRUMENT_CONDVAR(_event_,_arg1_,_arg2_) \ |
|
|
313 CYG_MACRO_START \ |
|
|
314 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg1_)); \ |
|
|
315 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg2_)); \ |
|
|
316 CYG_MACRO_END |
|
0
|
317 |
|
|
318 #endif |
|
|
319 |
|
|
320 // ------------------------------------------------------------------------- |
|
|
321 // Binary semaphore instrumentation macros |
|
|
322 |
|
|
323 #ifdef CYGDBG_KERNEL_INSTRUMENT_BINSEM |
|
|
324 |
|
|
325 #define CYG_INSTRUMENT_BINSEM(_event_,_arg1_,_arg2_) \ |
|
|
326 CYG_INSTRUMENT(CYGINST_EVENT(BINSEM,_event_),_arg1_,_arg2_) |
|
|
327 |
|
|
328 #else |
|
|
329 |
|
2
|
330 #define CYG_INSTRUMENT_BINSEM(_event_,_arg1_,_arg2_) \ |
|
|
331 CYG_MACRO_START \ |
|
|
332 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg1_)); \ |
|
|
333 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg2_)); \ |
|
|
334 CYG_MACRO_END |
|
0
|
335 |
|
|
336 #endif |
|
|
337 |
|
|
338 // ------------------------------------------------------------------------- |
|
|
339 // Counting semaphore instrumentation macros |
|
|
340 |
|
|
341 #ifdef CYGDBG_KERNEL_INSTRUMENT_CNTSEM |
|
|
342 |
|
|
343 #define CYG_INSTRUMENT_CNTSEM(_event_,_arg1_,_arg2_) \ |
|
|
344 CYG_INSTRUMENT(CYGINST_EVENT(CNTSEM,_event_),_arg1_,_arg2_) |
|
|
345 |
|
|
346 #else |
|
|
347 |
|
2
|
348 #define CYG_INSTRUMENT_CNTSEM(_event_,_arg1_,_arg2_) \ |
|
|
349 CYG_MACRO_START \ |
|
|
350 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg1_)); \ |
|
|
351 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg2_)); \ |
|
|
352 CYG_MACRO_END |
|
0
|
353 |
|
|
354 #endif |
|
|
355 |
|
|
356 // ------------------------------------------------------------------------- |
|
|
357 // Clock instrumentation macros |
|
|
358 |
|
|
359 #ifdef CYGDBG_KERNEL_INSTRUMENT_CLOCK |
|
|
360 |
|
|
361 #define CYG_INSTRUMENT_CLOCK(_event_,_arg1_,_arg2_) \ |
|
|
362 CYG_INSTRUMENT(CYGINST_EVENT(CLOCK,_event_),_arg1_,_arg2_) |
|
|
363 |
|
|
364 #else |
|
|
365 |
|
2
|
366 #define CYG_INSTRUMENT_CLOCK(_event_,_arg1_,_arg2_) \ |
|
|
367 CYG_MACRO_START \ |
|
|
368 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg1_)); \ |
|
|
369 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg2_)); \ |
|
|
370 CYG_MACRO_END |
|
0
|
371 |
|
|
372 #endif |
|
|
373 |
|
|
374 // ------------------------------------------------------------------------- |
|
|
375 // Alarm instrumentation macros |
|
|
376 |
|
|
377 #ifdef CYGDBG_KERNEL_INSTRUMENT_ALARM |
|
|
378 |
|
|
379 #define CYG_INSTRUMENT_ALARM(_event_,_arg1_,_arg2_) \ |
|
|
380 CYG_INSTRUMENT(CYGINST_EVENT(ALARM,_event_),_arg1_,_arg2_) |
|
|
381 |
|
|
382 #else |
|
|
383 |
|
2
|
384 #define CYG_INSTRUMENT_ALARM(_event_,_arg1_,_arg2_) \ |
|
|
385 CYG_MACRO_START \ |
|
|
386 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg1_)); \ |
|
|
387 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg2_)); \ |
|
|
388 CYG_MACRO_END |
|
0
|
389 |
|
|
390 #endif |
|
|
391 |
|
|
392 // ------------------------------------------------------------------------- |
|
|
393 // Mboxt instrumentation macros |
|
|
394 |
|
|
395 #ifdef CYGDBG_KERNEL_INSTRUMENT_MBOXT |
|
|
396 |
|
|
397 #define CYG_INSTRUMENT_MBOXT(_event_,_arg1_,_arg2_) \ |
|
|
398 CYG_INSTRUMENT(CYGINST_EVENT(MBOXT,_event_),_arg1_,_arg2_) |
|
|
399 |
|
|
400 #else |
|
|
401 |
|
2
|
402 #define CYG_INSTRUMENT_MBOXT(_event_,_arg1_,_arg2_) \ |
|
|
403 CYG_MACRO_START \ |
|
|
404 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg1_)); \ |
|
|
405 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg2_)); \ |
|
|
406 CYG_MACRO_END |
|
0
|
407 |
|
|
408 #endif |
|
|
409 |
|
|
410 // ------------------------------------------------------------------------- |
|
|
411 // User instrumentation |
|
|
412 |
|
|
413 #ifdef CYGDBG_KERNEL_INSTRUMENT_USER |
|
|
414 |
|
|
415 #define CYG_INSTRUMENT_USER(_event_,_arg1_,_arg2_) \ |
|
|
416 CYG_INSTRUMENT(CYGINST_EVENT(USER,_event_),_arg1_,_arg2_) |
|
|
417 |
|
|
418 #else |
|
|
419 |
|
2
|
420 #define CYG_INSTRUMENT_USER(_event_,_arg1_,_arg2_) \ |
|
|
421 CYG_MACRO_START \ |
|
|
422 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg1_)); \ |
|
|
423 CYG_UNUSED_PARAM(CYG_ADDRWORD, (CYG_ADDRWORD)(_arg2_)); \ |
|
|
424 CYG_MACRO_END |
|
0
|
425 |
|
|
426 #endif |
|
|
427 |
|
|
428 |
|
|
429 // ------------------------------------------------------------------------- |
|
|
430 #endif // ifndef CYGONCE_KERNEL_INSTRMNT_HXX |
|
|
431 // EOF instrmnt.hxx |