src/trace.h

   1 /*
   2  * Copyright (c) 2010-2013 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_APACHE_LICENSE_HEADER_START@
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * @APPLE_APACHE_LICENSE_HEADER_END@
  19  */
  20
  21 /*
  22  * IMPORTANT: This header file describes INTERNAL interfaces to libdispatch
  23  * which are subject to change in future releases of Mac OS X. Any applications
  24  * relying on these interfaces WILL break.
  25  */
  26
  27 #ifndef __DISPATCH_TRACE__
  28 #define __DISPATCH_TRACE__
  29
  30 #if DISPATCH_USE_DTRACE && !__OBJC2__
  31
  32 typedef struct dispatch_trace_timer_params_s {
  33         int64_t deadline, interval, leeway;
  34 } *dispatch_trace_timer_params_t;
  35
  36 #include "provider.h"
  37
  38 #if DISPATCH_USE_DTRACE_INTROSPECTION
  39
  40 #define _dispatch_trace_callout(_c, _f, _dcc) do { \
  41                 if (slowpath(DISPATCH_CALLOUT_ENTRY_ENABLED()) || \
  42                                 slowpath(DISPATCH_CALLOUT_RETURN_ENABLED())) { \
  43                         dispatch_queue_t _dq = _dispatch_queue_get_current(); \
  44                         const char *_label = _dq && _dq->dq_label ? _dq->dq_label : ""; \
  45                         dispatch_function_t _func = (dispatch_function_t)(_f); \
  46                         void *_ctxt = (_c); \
  47                         DISPATCH_CALLOUT_ENTRY(_dq, _label, _func, _ctxt); \
  48                         _dcc; \
  49                         DISPATCH_CALLOUT_RETURN(_dq, _label, _func, _ctxt); \
  50                 } else { \
  51                         _dcc; \
  52                 } \
  53         } while (0)
  54
  55 DISPATCH_ALWAYS_INLINE
  56 static inline void
  57 _dispatch_trace_client_callout(void *ctxt, dispatch_function_t f)
  58 {
  59         dispatch_function_t func = (f == _dispatch_call_block_and_release &&
  60                         ctxt ? _dispatch_Block_invoke(ctxt) : f);
  61         _dispatch_introspection_callout_entry(ctxt, func);
  62         _dispatch_trace_callout(ctxt, func, _dispatch_client_callout(ctxt, f));
  63         _dispatch_introspection_callout_return(ctxt, func);
  64 }
  65
  66 DISPATCH_ALWAYS_INLINE
  67 static inline void
  68 _dispatch_trace_client_callout2(void *ctxt, size_t i, void (*f)(void *, size_t))
  69 {
  70         dispatch_function_t func = (dispatch_function_t)f;
  71         _dispatch_introspection_callout_entry(ctxt, func);
  72         _dispatch_trace_callout(ctxt, func, _dispatch_client_callout2(ctxt, i, f));
  73         _dispatch_introspection_callout_return(ctxt, func);
  74 }
  75
  76 #ifdef __BLOCKS__
  77 DISPATCH_ALWAYS_INLINE
  78 static inline void
  79 _dispatch_trace_client_callout_block(dispatch_block_t b)
  80 {
  81         dispatch_function_t func = _dispatch_Block_invoke(b);
  82         _dispatch_introspection_callout_entry(b, func);
  83         _dispatch_trace_callout(b, func, _dispatch_client_callout(b, func));
  84         _dispatch_introspection_callout_return(b, func);
  85 }
  86 #endif
  87
  88 #define _dispatch_client_callout                _dispatch_trace_client_callout
  89 #define _dispatch_client_callout2               _dispatch_trace_client_callout2
  90 #define _dispatch_client_callout_block  _dispatch_trace_client_callout_block
  91
  92 #define _dispatch_trace_continuation(_q, _o, _t) do { \
  93                 dispatch_queue_t _dq = (_q); \
  94                 const char *_label = _dq && _dq->dq_label ? _dq->dq_label : ""; \
  95                 struct dispatch_object_s *_do = (_o); \
  96                 char *_kind; \
  97                 dispatch_function_t _func; \
  98                 void *_ctxt; \
  99                 if (DISPATCH_OBJ_IS_VTABLE(_do)) { \
 100                         _ctxt = _do->do_ctxt; \
 101                         _kind = (char*)dx_kind(_do); \
 102                         if ((dx_type(_do) & _DISPATCH_META_TYPE_MASK) == \
 103                                         _DISPATCH_SOURCE_TYPE && (_dq) != &_dispatch_mgr_q) { \
 104                                 _func = ((dispatch_source_t)_do)->ds_refs->ds_handler_func; \
 105                         } else { \
 106                                 _func = (dispatch_function_t)_dispatch_queue_invoke; \
 107                         } \
 108                 } else { \
 109                         struct dispatch_continuation_s *_dc = (void*)(_do); \
 110                         _ctxt = _dc->dc_ctxt; \
 111                         if ((long)_dc->do_vtable & DISPATCH_OBJ_SYNC_SLOW_BIT) { \
 112                                 _kind = "semaphore"; \
 113                                 _func = (dispatch_function_t)dispatch_semaphore_signal; \
 114                         } else if (_dc->dc_func == _dispatch_call_block_and_release) { \
 115                                 _kind = "block"; \
 116                                 _func = _dispatch_Block_invoke(_dc->dc_ctxt); \
 117                         } else { \
 118                                 _kind = "function"; \
 119                                 _func = _dc->dc_func; \
 120                         } \
 121                 } \
 122                 _t(_dq, _label, _do, _kind, _func, _ctxt); \
 123         } while (0)
 124
 125 DISPATCH_ALWAYS_INLINE
 126 static inline void
 127 _dispatch_trace_queue_push_list(dispatch_queue_t dq, dispatch_object_t _head,
 128                 dispatch_object_t _tail, unsigned int n)
 129 {
 130         if (slowpath(DISPATCH_QUEUE_PUSH_ENABLED())) {
 131                 struct dispatch_object_s *dou = _head._do;
 132                 do {
 133                         _dispatch_trace_continuation(dq, dou, DISPATCH_QUEUE_PUSH);
 134                 } while (dou != _tail._do && (dou = dou->do_next));
 135         }
 136         _dispatch_introspection_queue_push_list(dq, _head, _tail);
 137         _dispatch_queue_push_list(dq, _head, _tail, n);
 138 }
 139
 140 DISPATCH_ALWAYS_INLINE
 141 static inline void
 142 _dispatch_trace_queue_push(dispatch_queue_t dq, dispatch_object_t _tail)
 143 {
 144         if (slowpath(DISPATCH_QUEUE_PUSH_ENABLED())) {
 145                 struct dispatch_object_s *dou = _tail._do;
 146                 _dispatch_trace_continuation(dq, dou, DISPATCH_QUEUE_PUSH);
 147         }
 148         _dispatch_introspection_queue_push(dq, _tail);
 149         _dispatch_queue_push(dq, _tail);
 150 }
 151
 152 DISPATCH_ALWAYS_INLINE
 153 static inline void
 154 _dispatch_trace_queue_push_wakeup(dispatch_queue_t dq, dispatch_object_t _tail,
 155                 bool wakeup)
 156 {
 157         if (slowpath(DISPATCH_QUEUE_PUSH_ENABLED())) {
 158                 struct dispatch_object_s *dou = _tail._do;
 159                 _dispatch_trace_continuation(dq, dou, DISPATCH_QUEUE_PUSH);
 160         }
 161         _dispatch_introspection_queue_push(dq, _tail);
 162         _dispatch_queue_push_wakeup(dq, _tail, wakeup);
 163 }
 164
 165 DISPATCH_ALWAYS_INLINE
 166 static inline void
 167 _dispatch_queue_push_notrace(dispatch_queue_t dq, dispatch_object_t dou)
 168 {
 169         _dispatch_queue_push(dq, dou);
 170 }
 171
 172 #define _dispatch_queue_push_list _dispatch_trace_queue_push_list
 173 #define _dispatch_queue_push _dispatch_trace_queue_push
 174 #define _dispatch_queue_push_wakeup _dispatch_trace_queue_push_wakeup
 175
 176 DISPATCH_ALWAYS_INLINE
 177 static inline void
 178 _dispatch_trace_continuation_pop(dispatch_queue_t dq,
 179                 dispatch_object_t dou)
 180 {
 181         if (slowpath(DISPATCH_QUEUE_POP_ENABLED())) {
 182                 _dispatch_trace_continuation(dq, dou._do, DISPATCH_QUEUE_POP);
 183         }
 184         _dispatch_introspection_queue_pop(dq, dou);
 185 }
 186
 187 #endif // DISPATCH_USE_DTRACE_INTROSPECTION
 188
 189 static inline dispatch_function_t
 190 _dispatch_trace_timer_function(dispatch_source_t ds, dispatch_source_refs_t dr)
 191 {
 192         dispatch_function_t func = dr->ds_handler_func;
 193         if (func == _dispatch_after_timer_callback) {
 194                 dispatch_continuation_t dc = ds->do_ctxt;
 195                 func = dc->dc_func != _dispatch_call_block_and_release ? dc->dc_func :
 196                                 dc->dc_ctxt ? _dispatch_Block_invoke(dc->dc_ctxt) : NULL;
 197         }
 198         return func;
 199 }
 200
 201 DISPATCH_ALWAYS_INLINE
 202 static inline dispatch_trace_timer_params_t
 203 _dispatch_trace_timer_params(uintptr_t ident,
 204                 struct dispatch_timer_source_s *values, uint64_t deadline,
 205                 dispatch_trace_timer_params_t params)
 206 {
 207         #define _dispatch_trace_time2nano3(t) (DISPATCH_TIMER_KIND(ident) \
 208                         == DISPATCH_TIMER_KIND_MACH ? _dispatch_time_mach2nano(t) : (t))
 209         #define _dispatch_trace_time2nano2(v, t) ({ uint64_t _t = (t); \
 210                         (v) >= INT64_MAX ? -1ll : (int64_t)_dispatch_trace_time2nano3(_t);})
 211         #define _dispatch_trace_time2nano(v) ({ uint64_t _t; \
 212                         _t = _dispatch_trace_time2nano3(v); _t >= INT64_MAX ? -1ll : \
 213                         (int64_t)_t; })
 214         if (deadline) {
 215                 params->deadline = (int64_t)deadline;
 216         } else {
 217                 uint64_t now = (DISPATCH_TIMER_KIND(ident) ==
 218                                 DISPATCH_TIMER_KIND_MACH ? _dispatch_absolute_time() :
 219                                  _dispatch_get_nanoseconds());
 220                 params->deadline = _dispatch_trace_time2nano2(values->target,
 221                                 values->target < now ? 0 : values->target - now);
 222         }
 223         params->interval = _dispatch_trace_time2nano(values->interval);
 224         params->leeway = _dispatch_trace_time2nano(values->leeway);
 225         return params;
 226 }
 227
 228 DISPATCH_ALWAYS_INLINE
 229 static inline bool
 230 _dispatch_trace_timer_configure_enabled(void)
 231 {
 232         return slowpath(DISPATCH_TIMER_CONFIGURE_ENABLED());
 233 }
 234
 235 DISPATCH_ALWAYS_INLINE
 236 static inline void
 237 _dispatch_trace_timer_configure(dispatch_source_t ds, uintptr_t ident,
 238                 struct dispatch_timer_source_s *values)
 239 {
 240         struct dispatch_trace_timer_params_s params;
 241         DISPATCH_TIMER_CONFIGURE(ds, _dispatch_trace_timer_function(ds,
 242                         ds->ds_refs), _dispatch_trace_timer_params(ident, values, 0,
 243                         &params));
 244 }
 245
 246 DISPATCH_ALWAYS_INLINE
 247 static inline void
 248 _dispatch_trace_timer_program(dispatch_source_refs_t dr, uint64_t deadline)
 249 {
 250         if (slowpath(DISPATCH_TIMER_PROGRAM_ENABLED())) {
 251                 if (deadline && dr) {
 252                         dispatch_source_t ds = _dispatch_source_from_refs(dr);
 253                         struct dispatch_trace_timer_params_s params;
 254                         DISPATCH_TIMER_PROGRAM(ds, _dispatch_trace_timer_function(ds, dr),
 255                                         _dispatch_trace_timer_params(ds->ds_ident_hack,
 256                                         &ds_timer(dr), deadline, &params));
 257                 }
 258         }
 259 }
 260
 261 DISPATCH_ALWAYS_INLINE
 262 static inline void
 263 _dispatch_trace_timer_wake(dispatch_source_refs_t dr)
 264 {
 265         if (slowpath(DISPATCH_TIMER_WAKE_ENABLED())) {
 266                 if (dr) {
 267                         dispatch_source_t ds = _dispatch_source_from_refs(dr);
 268                         DISPATCH_TIMER_WAKE(ds, _dispatch_trace_timer_function(ds, dr));
 269                 }
 270         }
 271 }
 272
 273 DISPATCH_ALWAYS_INLINE
 274 static inline void
 275 _dispatch_trace_timer_fire(dispatch_source_refs_t dr, unsigned long data,
 276                 unsigned long missed)
 277 {
 278         if (slowpath(DISPATCH_TIMER_FIRE_ENABLED())) {
 279                 if (!(data - missed) && dr) {
 280                         dispatch_source_t ds = _dispatch_source_from_refs(dr);
 281                         DISPATCH_TIMER_FIRE(ds, _dispatch_trace_timer_function(ds, dr));
 282                 }
 283         }
 284 }
 285
 286 #else
 287
 288 #define _dispatch_trace_timer_configure_enabled() false
 289 #define _dispatch_trace_timer_configure(ds, ident, values) \
 290                 do { (void)(ds); (void)(ident); (void)(values); } while(0)
 291 #define _dispatch_trace_timer_program(dr, deadline) \
 292                 do { (void)(dr); (void)(deadline); } while(0)
 293 #define _dispatch_trace_timer_wake(dr) \
 294                 do { (void)(dr); } while(0)
 295 #define _dispatch_trace_timer_fire(dr, data, missed) \
 296                 do { (void)(dr); (void)(data); (void)(missed); } while(0)
 297
 298 #endif // DISPATCH_USE_DTRACE && !__OBJC2__
 299
 300 #if !DISPATCH_USE_DTRACE_INTROSPECTION
 301
 302 #define _dispatch_queue_push_notrace _dispatch_queue_push
 303 #define _dispatch_trace_continuation_pop(dq, dou) \
 304                 do { (void)(dq); (void)(dou); } while(0)
 305
 306 #endif // !DISPATCH_USE_DTRACE_INTROSPECTION
 307
 308 #endif // __DISPATCH_TRACE__