1 #undef TRACE_SYSTEM 2 #define TRACE_SYSTEM timer 3 4 #if !defined(_TRACE_TIMER_H) || defined(TRACE_HEADER_MULTI_READ) 5 #define _TRACE_TIMER_H 6 7 #include <linux/tracepoint.h> 8 #include <linux/hrtimer.h> 9 #include <linux/timer.h> 10 11 DECLARE_EVENT_CLASS(timer_class, 12 13 TP_PROTO(struct timer_list *timer), 14 15 TP_ARGS(timer), 16 17 TP_STRUCT__entry( 18 __field( void *, timer ) 19 ), 20 21 TP_fast_assign( 22 __entry->timer = timer; 23 ), 24 25 TP_printk("timer=%p", __entry->timer) 26 ); 27 28 /** 29 * timer_init - called when the timer is initialized 30 * @timer: pointer to struct timer_list 31 */ 32 DEFINE_EVENT(timer_class, timer_init, 33 34 TP_PROTO(struct timer_list *timer), 35 36 TP_ARGS(timer) 37 ); 38 39 /** 40 * timer_start - called when the timer is started 41 * @timer: pointer to struct timer_list 42 * @expires: the timers expiry time 43 */ 44 TRACE_EVENT(timer_start, 45 46 TP_PROTO(struct timer_list *timer, 47 unsigned long expires, 48 unsigned int flags), 49 50 TP_ARGS(timer, expires, flags), 51 52 TP_STRUCT__entry( 53 __field( void *, timer ) 54 __field( void *, function ) 55 __field( unsigned long, expires ) 56 __field( unsigned long, now ) 57 __field( unsigned int, flags ) 58 ), 59 60 TP_fast_assign( 61 __entry->timer = timer; 62 __entry->function = timer->function; 63 __entry->expires = expires; 64 __entry->now = jiffies; 65 __entry->flags = flags; 66 ), 67 68 TP_printk("timer=%p function=%pf expires=%lu [timeout=%ld] flags=0x%08x", 69 __entry->timer, __entry->function, __entry->expires, 70 (long)__entry->expires - __entry->now, __entry->flags) 71 ); 72 73 /** 74 * timer_expire_entry - called immediately before the timer callback 75 * @timer: pointer to struct timer_list 76 * 77 * Allows to determine the timer latency. 78 */ 79 TRACE_EVENT(timer_expire_entry, 80 81 TP_PROTO(struct timer_list *timer), 82 83 TP_ARGS(timer), 84 85 TP_STRUCT__entry( 86 __field( void *, timer ) 87 __field( unsigned long, now ) 88 __field( void *, function) 89 ), 90 91 TP_fast_assign( 92 __entry->timer = timer; 93 __entry->now = jiffies; 94 __entry->function = timer->function; 95 ), 96 97 TP_printk("timer=%p function=%pf now=%lu", __entry->timer, __entry->function,__entry->now) 98 ); 99 100 /** 101 * timer_expire_exit - called immediately after the timer callback returns 102 * @timer: pointer to struct timer_list 103 * 104 * When used in combination with the timer_expire_entry tracepoint we can 105 * determine the runtime of the timer callback function. 106 * 107 * NOTE: Do NOT derefernce timer in TP_fast_assign. The pointer might 108 * be invalid. We solely track the pointer. 109 */ 110 DEFINE_EVENT(timer_class, timer_expire_exit, 111 112 TP_PROTO(struct timer_list *timer), 113 114 TP_ARGS(timer) 115 ); 116 117 /** 118 * timer_cancel - called when the timer is canceled 119 * @timer: pointer to struct timer_list 120 */ 121 DEFINE_EVENT(timer_class, timer_cancel, 122 123 TP_PROTO(struct timer_list *timer), 124 125 TP_ARGS(timer) 126 ); 127 128 /** 129 * hrtimer_init - called when the hrtimer is initialized 130 * @hrtimer: pointer to struct hrtimer 131 * @clockid: the hrtimers clock 132 * @mode: the hrtimers mode 133 */ 134 TRACE_EVENT(hrtimer_init, 135 136 TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid, 137 enum hrtimer_mode mode), 138 139 TP_ARGS(hrtimer, clockid, mode), 140 141 TP_STRUCT__entry( 142 __field( void *, hrtimer ) 143 __field( clockid_t, clockid ) 144 __field( enum hrtimer_mode, mode ) 145 ), 146 147 TP_fast_assign( 148 __entry->hrtimer = hrtimer; 149 __entry->clockid = clockid; 150 __entry->mode = mode; 151 ), 152 153 TP_printk("hrtimer=%p clockid=%s mode=%s", __entry->hrtimer, 154 __entry->clockid == CLOCK_REALTIME ? 155 "CLOCK_REALTIME" : "CLOCK_MONOTONIC", 156 __entry->mode == HRTIMER_MODE_ABS ? 157 "HRTIMER_MODE_ABS" : "HRTIMER_MODE_REL") 158 ); 159 160 /** 161 * hrtimer_start - called when the hrtimer is started 162 * @hrtimer: pointer to struct hrtimer 163 */ 164 TRACE_EVENT(hrtimer_start, 165 166 TP_PROTO(struct hrtimer *hrtimer), 167 168 TP_ARGS(hrtimer), 169 170 TP_STRUCT__entry( 171 __field( void *, hrtimer ) 172 __field( void *, function ) 173 __field( s64, expires ) 174 __field( s64, softexpires ) 175 ), 176 177 TP_fast_assign( 178 __entry->hrtimer = hrtimer; 179 __entry->function = hrtimer->function; 180 __entry->expires = hrtimer_get_expires(hrtimer); 181 __entry->softexpires = hrtimer_get_softexpires(hrtimer); 182 ), 183 184 TP_printk("hrtimer=%p function=%pf expires=%llu softexpires=%llu", 185 __entry->hrtimer, __entry->function, 186 (unsigned long long) __entry->expires, 187 (unsigned long long) __entry->softexpires) 188 ); 189 190 /** 191 * hrtimer_expire_entry - called immediately before the hrtimer callback 192 * @hrtimer: pointer to struct hrtimer 193 * @now: pointer to variable which contains current time of the 194 * timers base. 195 * 196 * Allows to determine the timer latency. 197 */ 198 TRACE_EVENT(hrtimer_expire_entry, 199 200 TP_PROTO(struct hrtimer *hrtimer, ktime_t *now), 201 202 TP_ARGS(hrtimer, now), 203 204 TP_STRUCT__entry( 205 __field( void *, hrtimer ) 206 __field( s64, now ) 207 __field( void *, function) 208 ), 209 210 TP_fast_assign( 211 __entry->hrtimer = hrtimer; 212 __entry->now = *now; 213 __entry->function = hrtimer->function; 214 ), 215 216 TP_printk("hrtimer=%p function=%pf now=%llu", __entry->hrtimer, __entry->function, 217 (unsigned long long) __entry->now) 218 ); 219 220 DECLARE_EVENT_CLASS(hrtimer_class, 221 222 TP_PROTO(struct hrtimer *hrtimer), 223 224 TP_ARGS(hrtimer), 225 226 TP_STRUCT__entry( 227 __field( void *, hrtimer ) 228 ), 229 230 TP_fast_assign( 231 __entry->hrtimer = hrtimer; 232 ), 233 234 TP_printk("hrtimer=%p", __entry->hrtimer) 235 ); 236 237 /** 238 * hrtimer_expire_exit - called immediately after the hrtimer callback returns 239 * @hrtimer: pointer to struct hrtimer 240 * 241 * When used in combination with the hrtimer_expire_entry tracepoint we can 242 * determine the runtime of the callback function. 243 */ 244 DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit, 245 246 TP_PROTO(struct hrtimer *hrtimer), 247 248 TP_ARGS(hrtimer) 249 ); 250 251 /** 252 * hrtimer_cancel - called when the hrtimer is canceled 253 * @hrtimer: pointer to struct hrtimer 254 */ 255 DEFINE_EVENT(hrtimer_class, hrtimer_cancel, 256 257 TP_PROTO(struct hrtimer *hrtimer), 258 259 TP_ARGS(hrtimer) 260 ); 261 262 /** 263 * itimer_state - called when itimer is started or canceled 264 * @which: name of the interval timer 265 * @value: the itimers value, itimer is canceled if value->it_value is 266 * zero, otherwise it is started 267 * @expires: the itimers expiry time 268 */ 269 TRACE_EVENT(itimer_state, 270 271 TP_PROTO(int which, const struct itimerval *const value, 272 unsigned long long expires), 273 274 TP_ARGS(which, value, expires), 275 276 TP_STRUCT__entry( 277 __field( int, which ) 278 __field( unsigned long long, expires ) 279 __field( long, value_sec ) 280 __field( long, value_usec ) 281 __field( long, interval_sec ) 282 __field( long, interval_usec ) 283 ), 284 285 TP_fast_assign( 286 __entry->which = which; 287 __entry->expires = expires; 288 __entry->value_sec = value->it_value.tv_sec; 289 __entry->value_usec = value->it_value.tv_usec; 290 __entry->interval_sec = value->it_interval.tv_sec; 291 __entry->interval_usec = value->it_interval.tv_usec; 292 ), 293 294 TP_printk("which=%d expires=%llu it_value=%ld.%ld it_interval=%ld.%ld", 295 __entry->which, __entry->expires, 296 __entry->value_sec, __entry->value_usec, 297 __entry->interval_sec, __entry->interval_usec) 298 ); 299 300 /** 301 * itimer_expire - called when itimer expires 302 * @which: type of the interval timer 303 * @pid: pid of the process which owns the timer 304 * @now: current time, used to calculate the latency of itimer 305 */ 306 TRACE_EVENT(itimer_expire, 307 308 TP_PROTO(int which, struct pid *pid, unsigned long long now), 309 310 TP_ARGS(which, pid, now), 311 312 TP_STRUCT__entry( 313 __field( int , which ) 314 __field( pid_t, pid ) 315 __field( unsigned long long, now ) 316 ), 317 318 TP_fast_assign( 319 __entry->which = which; 320 __entry->now = now; 321 __entry->pid = pid_nr(pid); 322 ), 323 324 TP_printk("which=%d pid=%d now=%llu", __entry->which, 325 (int) __entry->pid, __entry->now) 326 ); 327 328 #ifdef CONFIG_NO_HZ_COMMON 329 330 #define TICK_DEP_NAMES \ 331 tick_dep_mask_name(NONE) \ 332 tick_dep_name(POSIX_TIMER) \ 333 tick_dep_name(PERF_EVENTS) \ 334 tick_dep_name(SCHED) \ 335 tick_dep_name_end(CLOCK_UNSTABLE) 336 337 #undef tick_dep_name 338 #undef tick_dep_mask_name 339 #undef tick_dep_name_end 340 341 /* The MASK will convert to their bits and they need to be processed too */ 342 #define tick_dep_name(sdep) TRACE_DEFINE_ENUM(TICK_DEP_BIT_##sdep); \ 343 TRACE_DEFINE_ENUM(TICK_DEP_MASK_##sdep); 344 #define tick_dep_name_end(sdep) TRACE_DEFINE_ENUM(TICK_DEP_BIT_##sdep); \ 345 TRACE_DEFINE_ENUM(TICK_DEP_MASK_##sdep); 346 /* NONE only has a mask defined for it */ 347 #define tick_dep_mask_name(sdep) TRACE_DEFINE_ENUM(TICK_DEP_MASK_##sdep); 348 349 TICK_DEP_NAMES 350 351 #undef tick_dep_name 352 #undef tick_dep_mask_name 353 #undef tick_dep_name_end 354 355 #define tick_dep_name(sdep) { TICK_DEP_MASK_##sdep, #sdep }, 356 #define tick_dep_mask_name(sdep) { TICK_DEP_MASK_##sdep, #sdep }, 357 #define tick_dep_name_end(sdep) { TICK_DEP_MASK_##sdep, #sdep } 358 359 #define show_tick_dep_name(val) \ 360 __print_symbolic(val, TICK_DEP_NAMES) 361 362 TRACE_EVENT(tick_stop, 363 364 TP_PROTO(int success, int dependency), 365 366 TP_ARGS(success, dependency), 367 368 TP_STRUCT__entry( 369 __field( int , success ) 370 __field( int , dependency ) 371 ), 372 373 TP_fast_assign( 374 __entry->success = success; 375 __entry->dependency = dependency; 376 ), 377 378 TP_printk("success=%d dependency=%s", __entry->success, \ 379 show_tick_dep_name(__entry->dependency)) 380 ); 381 #endif 382 383 #endif /* _TRACE_TIMER_H */ 384 385 /* This part must be outside protection */ 386 #include <trace/define_trace.h> 387