![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to etap_macros.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / kern|
Return to etap_macros.h CVS log | Up to [Apple XNU] / XNU / osfmk / kern |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * @OSF_COPYRIGHT@ ! 24: * ! 25: */ ! 26: /* ! 27: * The Event Trace Analysis Package ! 28: * ================================ ! 29: * ! 30: * Function: Traces micro-kernel events. ! 31: * ! 32: * Macro Notes: Several macros are added throughout the lock code. ! 33: * These macros allow for convenient configuration ! 34: * and code readability. ! 35: * ! 36: * The macro prefixes determine a specific trace ! 37: * configuration operation: ! 38: * ! 39: * CUM - Cumulative trace specific operation. ! 40: * MON - Monitored trace specific operation. ! 41: * ETAP - Both a cumulative and monitored trace ! 42: * operation. ! 43: */ ! 44: ! 45: ! 46: #ifndef _KERN_ETAP_MACROS_H_ ! 47: #define _KERN_ETAP_MACROS_H_ ! 48: ! 49: #include <kern/etap_options.h> ! 50: #include <kern/lock.h> ! 51: #include <mach/etap.h> ! 52: #include <mach/etap_events.h> ! 53: #include <kern/etap_pool.h> ! 54: ! 55: ! 56: #if ETAP ! 57: ! 58: #include <kern/macro_help.h> ! 59: #include <mach/vm_param.h> ! 60: #include <ipc/ipc_types.h> ! 61: #include <mach/message.h> ! 62: ! 63: extern void etap_init_phase1(void); ! 64: extern void etap_init_phase2(void); ! 65: extern void etap_event_table_assign(struct event_table_chain *, etap_event_t); ! 66: extern unsigned int etap_get_pc(void); ! 67: extern event_table_t event_table; ! 68: extern subs_table_t subs_table; ! 69: ! 70: /* ! 71: * Time Macros ! 72: */ ! 73: ! 74: #define ETAP_TIMESTAMP(t) rtc_gettime_interrupts_disabled(&t) ! 75: #define ETAP_TIME_SUM(t,sum_me) t += sum_me ! 76: #define ETAP_TIME_SUB(t,stop,start) \ ! 77: MACRO_BEGIN \ ! 78: (t) = (stop); \ ! 79: SUB_MACH_TIMESPEC(&(t), &(start)); \ ! 80: MACRO_END ! 81: #define ETAP_TIME_SQR(t,sqr_me) t += sqr_me*sqr_me ! 82: #define ETAP_TIME_DIV(r,n,d) r = (u_short) n/d ! 83: #define ETAP_TIME_IS_ZERO(t) ((t).tv_sec == 0) ! 84: #define ETAP_TIME_CLEAR(t) ((t).tv_sec = 0) ! 85: #define ETAP_TIME_GREATER(t1,t2) ((t1) > (t2)) ! 86: ! 87: #else /* ETAP */ ! 88: ! 89: #define etap_init_phase1() ! 90: #define etap_init_phase2() ! 91: #define etap_event_table_assign(event) ! 92: #define ETAP_TIMESTAMP(t) ! 93: #define ETAP_TIME_SUB(t,start,stop) ! 94: #define ETAP_TIME_CLEAR(t) ! 95: ! 96: #endif /* ETAP */ ! 97: ! 98: ! 99: /* ! 100: * =================================================== ! 101: * ETAP: cumulative trace specific macros ! 102: * =================================================== ! 103: */ ! 104: ! 105: #if ETAP_LOCK_ACCUMULATE ! 106: ! 107: extern cbuff_entry_t etap_cbuff_reserve(event_table_t); ! 108: #if MACH_LDEBUG ! 109: extern simple_lock_t cbuff_locks; ! 110: #else ! 111: extern simple_lock_data_t cbuff_locks; ! 112: #endif ! 113: extern int cbuff_width; ! 114: ! 115: /* ! 116: * If cumulative hold tracing is enabled for the event (i.e., acquired lock), ! 117: * the CUM_HOLD_ACCUMULATE macro will update the appropriate cumulative buffer ! 118: * entry with the newly collected hold data. ! 119: */ ! 120: ! 121: #define CUM_HOLD_ACCUMULATE(cp,total_time,dynamic,trace) \ ! 122: MACRO_BEGIN \ ! 123: u_short _bucket; \ ! 124: if ((cp) != CBUFF_ENTRY_NULL && ((trace) & CUM_DURATION)) { \ ! 125: if (dynamic) \ ! 126: simple_lock_no_trace(&cbuff_locks[dynamic-1]); \ ! 127: (cp)->hold.triggered++; \ ! 128: ETAP_TIME_SUM((cp)->hold.time,(total_time)); \ ! 129: ETAP_TIME_SQR((cp)->hold.time_sq,(total_time)); \ ! 130: if (ETAP_TIME_IS_ZERO((cp)->hold.min_time) || \ ! 131: ETAP_TIME_GREATER((cp)->hold.min_time,(total_time))) \ ! 132: (cp)->hold.min_time = (total_time); \ ! 133: if (ETAP_TIME_GREATER((total_time),(cp)->hold.max_time)) \ ! 134: (cp)->hold.max_time = (total_time); \ ! 135: ETAP_TIME_DIV(_bucket,(total_time),cbuff_width); \ ! 136: if (_bucket >= ETAP_CBUFF_IBUCKETS) \ ! 137: (cp)->hold_interval[ETAP_CBUFF_IBUCKETS-1]++; \ ! 138: else \ ! 139: (cp)->hold_interval[_bucket]++; \ ! 140: if (dynamic) \ ! 141: simple_unlock_no_trace(&cbuff_locks[dynamic-1]); \ ! 142: } \ ! 143: MACRO_END ! 144: ! 145: /* ! 146: * If cumulative wait tracing is enabled for the event (i.e., acquired lock), ! 147: * the CUM_WAIT_ACCUMULATE macro will update the appropriate cumulative ! 148: * buffer entry with the newly collected wait data. ! 149: */ ! 150: ! 151: #define CUM_WAIT_ACCUMULATE(cp,total_time,dynamic,trace) \ ! 152: MACRO_BEGIN \ ! 153: u_short _bucket; \ ! 154: if ((cp) != CBUFF_ENTRY_NULL && ((trace) & CUM_CONTENTION)) { \ ! 155: if (dynamic) \ ! 156: simple_lock_no_trace(&cbuff_locks[dynamic-1]); \ ! 157: (cp)->wait.triggered++; \ ! 158: ETAP_TIME_SUM((cp)->wait.time,(total_time)); \ ! 159: ETAP_TIME_SQR((cp)->wait.time_sq,(total_time)); \ ! 160: if (ETAP_TIME_IS_ZERO((cp)->wait.min_time) || \ ! 161: ETAP_TIME_GREATER((cp)->wait.min_time,(total_time))) \ ! 162: (cp)->wait.min_time = (total_time); \ ! 163: if (ETAP_TIME_GREATER((total_time),(cp)->wait.max_time)) \ ! 164: (cp)->wait.max_time = (total_time); \ ! 165: ETAP_TIME_DIV(_bucket,(total_time),cbuff_width); \ ! 166: if (_bucket >= ETAP_CBUFF_IBUCKETS) \ ! 167: (cp)->wait_interval[ETAP_CBUFF_IBUCKETS-1]++; \ ! 168: else \ ! 169: (cp)->wait_interval[_bucket]++; \ ! 170: if (dynamic) \ ! 171: simple_unlock_no_trace(&cbuff_locks[dynamic-1]); \ ! 172: } \ ! 173: MACRO_END ! 174: ! 175: /* ! 176: * Initially a lock's cbuff_read pointer is set to CBUFF_ENTRY_NULL. This ! 177: * saves space in the cumulative buffer in the event that a read lock is ! 178: * not acquired. In the case that a read lock is acquired, the ! 179: * CUM_READ_ENTRY_RESERVE macro is called. Here a cumulative ! 180: * record is reserved and initialized. ! 181: */ ! 182: ! 183: #define CUM_READ_ENTRY_RESERVE(l,cp,trace) \ ! 184: MACRO_BEGIN \ ! 185: if ((cp) == CBUFF_ENTRY_NULL && (trace) & ETAP_CUMULATIVE) { \ ! 186: (cp) = etap_cbuff_reserve(lock_event_table(l)); \ ! 187: if ((cp) != CBUFF_ENTRY_NULL) { \ ! 188: (cp)->event = lock_event_table(l)->event; \ ! 189: (cp)->instance = (u_int) l; \ ! 190: (cp)->kind = READ_LOCK; \ ! 191: } \ ! 192: } \ ! 193: MACRO_END ! 194: ! 195: #else /* ETAP_LOCK_ACCUMULATE */ ! 196: #define etap_cbuff_reserve(et) ! 197: #define CUM_HOLD_ACCUMULATE(cp,t,d,tr) ! 198: #define CUM_WAIT_ACCUMULATE(cp,t,d,tr) ! 199: #define CUM_READ_ENTRY_RESERVE(l,rep,tr) ! 200: #endif /* ETAP_LOCK_ACCUMULATE */ ! 201: ! 202: /* ! 203: * =============================================== ! 204: * ETAP: monitor trace specific macros ! 205: * =============================================== ! 206: */ ! 207: ! 208: #if ETAP_MONITOR ! 209: extern int mbuff_entries; ! 210: extern monitor_buffer_t mbuff[]; ! 211: #endif /* ETAP_MONITOR */ ! 212: ! 213: ! 214: #if ETAP_LOCK_MONITOR ! 215: ! 216: /* ! 217: * If monitor tracing is enabled for the lock, the ! 218: * MON_DATA_COLLECT macro will write collected lock data to ! 219: * the next slot in a cpu specific monitor buffer. Circular ! 220: * buffer maintenance is also performed here. ! 221: */ ! 222: ! 223: #define MON_DATA_COLLECT(l,e,total_time,type,op,trace) \ ! 224: MACRO_BEGIN \ ! 225: mbuff_entry_t _mp; \ ! 226: int _cpu, _ent, _s; \ ! 227: if ((trace) & op) { \ ! 228: mp_disable_preemption(); \ ! 229: _cpu = cpu_number(); \ ! 230: _s = splhigh(); \ ! 231: _ent = mbuff[_cpu]->free; \ ! 232: _mp = &mbuff[_cpu]->entry[_ent]; \ ! 233: _mp->event = lock_event_table(l)->event; \ ! 234: _mp->flags = ((op) | (type)); \ ! 235: _mp->instance = (u_int) (l); \ ! 236: _mp->time = (total_time); \ ! 237: _mp->data[0] = (e)->start_pc; \ ! 238: _mp->data[1] = (e)->end_pc; \ ! 239: mbuff[_cpu]->free = (_ent+1) % mbuff_entries; \ ! 240: if (mbuff[_cpu]->free == 0) \ ! 241: mbuff[_cpu]->timestamp++; \ ! 242: splx(_s); \ ! 243: mp_enable_preemption(); \ ! 244: } \ ! 245: MACRO_END ! 246: ! 247: #define MON_CLEAR_PCS(l) \ ! 248: MACRO_BEGIN \ ! 249: (l)->start_pc = 0; \ ! 250: (l)->end_pc = 0; \ ! 251: MACRO_END ! 252: ! 253: #define MON_ASSIGN_PC(target,source,trace) \ ! 254: if ((trace) & ETAP_MONITORED) target = source ! 255: ! 256: #else /* ETAP_LOCK_MONITOR */ ! 257: #define MON_DATA_COLLECT(l,le,tt,t,o,tr) ! 258: #define MON_GET_PC(pc,tr) ! 259: #define MON_CLEAR_PCS(l) ! 260: #define MON_ASSIGN_PC(t,s,tr) ! 261: #endif /* ETAP_LOCK_MONITOR */ ! 262: ! 263: ! 264: #if ETAP_EVENT_MONITOR ! 265: ! 266: #define ETAP_PROBE_DATA_COND(_event, _flags, _thread, _data, _size, _cond) \ ! 267: MACRO_BEGIN \ ! 268: mbuff_entry_t _mp; \ ! 269: int _cpu, _ent, _s; \ ! 270: if (event_table[_event].status && (_cond)) { \ ! 271: mp_disable_preemption(); \ ! 272: _cpu = cpu_number(); \ ! 273: _s = splhigh(); \ ! 274: _ent = mbuff[_cpu]->free; \ ! 275: _mp = &mbuff[_cpu]->entry[_ent]; \ ! 276: ETAP_TIMESTAMP(_mp->time); \ ! 277: _mp->pc = etap_get_pc(); \ ! 278: _mp->event = _event; \ ! 279: _mp->flags = KERNEL_EVENT | _flags; \ ! 280: _mp->instance = (u_int) _thread; \ ! 281: bcopy((char *) _data, (char *) _mp->data, _size); \ ! 282: mbuff[_cpu]->free = (_ent+1) % mbuff_entries; \ ! 283: if (mbuff[_cpu]->free == 0) \ ! 284: mbuff[_cpu]->timestamp++; \ ! 285: splx(_s); \ ! 286: mp_enable_preemption(); \ ! 287: } \ ! 288: MACRO_END ! 289: ! 290: #define ETAP_PROBE(_event, _flags, _thread) \ ! 291: ETAP_PROBE_DATA_COND(_event, _flags, _thread, 0, 0, 1) ! 292: ! 293: #define ETAP_PROBE_DATA(_event, _flags, _thread, _data, _size) \ ! 294: ETAP_PROBE_DATA_COND(_event, _flags, _thread, _data, _size, \ ! 295: (_thread)->etap_trace) ! 296: ! 297: #define ETAP_DATA_LOAD(ed, x) ((ed) = (u_int) (x)) ! 298: #define ETAP_SET_REASON(_th, _reason) ((_th)->etap_reason = (_reason)) ! 299: ! 300: #else /* ETAP_EVENT_MONITOR */ ! 301: #define ETAP_PROBE(e,f,th) ! 302: #define ETAP_PROBE_DATA(e,f,th,d,s) ! 303: #define ETAP_PROBE_DATA_COND(e,f,th,d,s,c) ! 304: #define ETAP_DATA_LOAD(d,x); ! 305: #define ETAP_SET_REASON(t,r) ! 306: #endif /* ETAP_EVENT_MONITOR */ ! 307: ! 308: /* ! 309: * ================================= ! 310: * ETAP: general lock macros ! 311: * ================================= ! 312: */ ! 313: ! 314: #if ETAP_LOCK_TRACE ! 315: ! 316: #define ETAP_TOTAL_TIME(t,stop,start) \ ! 317: ETAP_TIME_SUB((t),(stop),(start)) ! 318: ! 319: #define ETAP_DURATION_TIMESTAMP(e,trace) \ ! 320: MACRO_BEGIN \ ! 321: if ((trace) & ETAP_DURATION) \ ! 322: ETAP_TIMESTAMP((e)->start_hold_time); \ ! 323: MACRO_END ! 324: ! 325: #define ETAP_COPY_START_HOLD_TIME(entry,time,trace) \ ! 326: MACRO_BEGIN \ ! 327: if ((trace) & ETAP_DURATION) \ ! 328: (entry)->start_hold_time = time; \ ! 329: MACRO_END ! 330: ! 331: #define ETAP_CONTENTION_TIMESTAMP(e,trace) \ ! 332: MACRO_BEGIN \ ! 333: if ((trace) & ETAP_CONTENTION) \ ! 334: ETAP_TIMESTAMP((e)->start_wait_time); \ ! 335: MACRO_END ! 336: ! 337: #define ETAP_STAMP(event_table,trace,dynamic) \ ! 338: MACRO_BEGIN \ ! 339: if ((event_table) != EVENT_TABLE_NULL) { \ ! 340: (dynamic) = (event_table)->dynamic; \ ! 341: (trace) = (event_table)->status; \ ! 342: } \ ! 343: MACRO_END ! 344: ! 345: #define ETAP_WHOLE_OP(l) \ ! 346: (!(ETAP_TIME_IS_ZERO((l)->u.s.start_hold_time))) ! 347: #define ETAP_DURATION_ENABLED(trace) ((trace) & ETAP_DURATION) ! 348: #define ETAP_CONTENTION_ENABLED(trace) ((trace) & ETAP_CONTENTION) ! 349: ! 350: /* ! 351: * The ETAP_CLEAR_TRACE_DATA macro sets the etap specific fields ! 352: * of the simple_lock_t structure to zero. ! 353: * ! 354: * This is always done just before a simple lock is released. ! 355: */ ! 356: ! 357: #define ETAP_CLEAR_TRACE_DATA(l) \ ! 358: MACRO_BEGIN \ ! 359: ETAP_TIME_CLEAR((l)->u.s.start_hold_time); \ ! 360: MON_CLEAR_PCS((l)); \ ! 361: MACRO_END ! 362: ! 363: ! 364: /* ================================================== ! 365: * The ETAP_XXX_ENTRY macros manipulate the locks ! 366: * start_list (a linked list of start data). ! 367: * ================================================== ! 368: */ ! 369: ! 370: #define ETAP_CREATE_ENTRY(entry,trace) \ ! 371: MACRO_BEGIN \ ! 372: if ((trace) & ETAP_TRACE_ON) \ ! 373: (entry) = get_start_data_node(); \ ! 374: MACRO_END ! 375: ! 376: #define ETAP_LINK_ENTRY(l,entry,trace) \ ! 377: MACRO_BEGIN \ ! 378: if ((trace) & ETAP_TRACE_ON) { \ ! 379: (entry)->next = (l)->u.s.start_list; \ ! 380: (l)->u.s.start_list = (entry); \ ! 381: (entry)->thread_id = (u_int) current_thread(); \ ! 382: ETAP_TIME_CLEAR((entry)->start_wait_time); \ ! 383: } \ ! 384: MACRO_END ! 385: ! 386: #define ETAP_FIND_ENTRY(l,entry,trace) \ ! 387: MACRO_BEGIN \ ! 388: u_int _ct; \ ! 389: _ct = (u_int) current_thread(); \ ! 390: (entry) = (l)->u.s.start_list; \ ! 391: while ((entry) != SD_ENTRY_NULL && (entry)->thread_id != _ct) \ ! 392: (entry) = (entry)->next; \ ! 393: if ((entry) == SD_ENTRY_NULL) \ ! 394: (trace) = 0; \ ! 395: MACRO_END ! 396: ! 397: #define ETAP_UNLINK_ENTRY(l,entry) \ ! 398: MACRO_BEGIN \ ! 399: boolean_t _first = TRUE; \ ! 400: start_data_node_t _prev; \ ! 401: u_int _ct; \ ! 402: _ct = (u_int) current_thread(); \ ! 403: (entry) = (l)->u.s.start_list; \ ! 404: while ((entry) != SD_ENTRY_NULL && (entry)->thread_id != _ct){ \ ! 405: _prev = (entry); \ ! 406: (entry) = (entry)->next; \ ! 407: _first = FALSE; \ ! 408: } \ ! 409: if (entry != SD_ENTRY_NULL) { \ ! 410: if (_first) \ ! 411: (l)->u.s.start_list = (entry)->next; \ ! 412: else \ ! 413: _prev->next = (entry)->next; \ ! 414: (entry)->next = SD_ENTRY_NULL; \ ! 415: } \ ! 416: MACRO_END ! 417: ! 418: #define ETAP_DESTROY_ENTRY(entry) \ ! 419: MACRO_BEGIN \ ! 420: if ((entry) != SD_ENTRY_NULL) \ ! 421: free_start_data_node ((entry)); \ ! 422: MACRO_END ! 423: ! 424: #else /* ETAP_LOCK_TRACE */ ! 425: #define ETAP_TOTAL_TIME(t,stop,start) ! 426: #define ETAP_DURATION_TIMESTAMP(le,tr) ! 427: #define ETAP_CONTENTION_TIMESTAMP(le,tr) ! 428: #define ETAP_COPY_START_HOLD_TIME(le,t,tr) ! 429: #define ETAP_STAMP(tt,tr,d) ! 430: #define ETAP_DURATION_ENABLED(tr) (0) /* always fails */ ! 431: #define ETAP_CONTENTION_ENABLED(tr) (0) /* always fails */ ! 432: #define ETAP_CLEAR_TRACE_DATA(l) ! 433: #define ETAP_CREATE_ENTRY(e,tr) ! 434: #define ETAP_LINK_ENTRY(l,e,tr) ! 435: #define ETAP_FIND_ENTRY(l,e,tr) ! 436: #define ETAP_UNLINK_ENTRY(l,e) ! 437: #define ETAP_DESTROY_ENTRY(e) ! 438: #endif /* ETAP_LOCK_TRACE */ ! 439: ! 440: #endif /* _KERN_ETAP_MACROS_H_ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.