hrtimer: Add tracepoint for hrtimers
[linux-2.6.git] / include / trace / events / timer.h
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 /**
12  * timer_init - called when the timer is initialized
13  * @timer:      pointer to struct timer_list
14  */
15 TRACE_EVENT(timer_init,
16
17         TP_PROTO(struct timer_list *timer),
18
19         TP_ARGS(timer),
20
21         TP_STRUCT__entry(
22                 __field( void *,        timer   )
23         ),
24
25         TP_fast_assign(
26                 __entry->timer  = timer;
27         ),
28
29         TP_printk("timer %p", __entry->timer)
30 );
31
32 /**
33  * timer_start - called when the timer is started
34  * @timer:      pointer to struct timer_list
35  * @expires:    the timers expiry time
36  */
37 TRACE_EVENT(timer_start,
38
39         TP_PROTO(struct timer_list *timer, unsigned long expires),
40
41         TP_ARGS(timer, expires),
42
43         TP_STRUCT__entry(
44                 __field( void *,        timer           )
45                 __field( void *,        function        )
46                 __field( unsigned long, expires         )
47                 __field( unsigned long, now             )
48         ),
49
50         TP_fast_assign(
51                 __entry->timer          = timer;
52                 __entry->function       = timer->function;
53                 __entry->expires        = expires;
54                 __entry->now            = jiffies;
55         ),
56
57         TP_printk("timer %p: func %pf, expires %lu, timeout %ld",
58                   __entry->timer, __entry->function, __entry->expires,
59                   (long)__entry->expires - __entry->now)
60 );
61
62 /**
63  * timer_expire_entry - called immediately before the timer callback
64  * @timer:      pointer to struct timer_list
65  *
66  * Allows to determine the timer latency.
67  */
68 TRACE_EVENT(timer_expire_entry,
69
70         TP_PROTO(struct timer_list *timer),
71
72         TP_ARGS(timer),
73
74         TP_STRUCT__entry(
75                 __field( void *,        timer   )
76                 __field( unsigned long, now     )
77         ),
78
79         TP_fast_assign(
80                 __entry->timer          = timer;
81                 __entry->now            = jiffies;
82         ),
83
84         TP_printk("timer %p: now %lu", __entry->timer, __entry->now)
85 );
86
87 /**
88  * timer_expire_exit - called immediately after the timer callback returns
89  * @timer:      pointer to struct timer_list
90  *
91  * When used in combination with the timer_expire_entry tracepoint we can
92  * determine the runtime of the timer callback function.
93  *
94  * NOTE: Do NOT derefernce timer in TP_fast_assign. The pointer might
95  * be invalid. We solely track the pointer.
96  */
97 TRACE_EVENT(timer_expire_exit,
98
99         TP_PROTO(struct timer_list *timer),
100
101         TP_ARGS(timer),
102
103         TP_STRUCT__entry(
104                 __field(void *, timer   )
105         ),
106
107         TP_fast_assign(
108                 __entry->timer  = timer;
109         ),
110
111         TP_printk("timer %p", __entry->timer)
112 );
113
114 /**
115  * timer_cancel - called when the timer is canceled
116  * @timer:      pointer to struct timer_list
117  */
118 TRACE_EVENT(timer_cancel,
119
120         TP_PROTO(struct timer_list *timer),
121
122         TP_ARGS(timer),
123
124         TP_STRUCT__entry(
125                 __field( void *,        timer   )
126         ),
127
128         TP_fast_assign(
129                 __entry->timer  = timer;
130         ),
131
132         TP_printk("timer %p", __entry->timer)
133 );
134
135 /**
136  * hrtimer_init - called when the hrtimer is initialized
137  * @timer:      pointer to struct hrtimer
138  * @clockid:    the hrtimers clock
139  * @mode:       the hrtimers mode
140  */
141 TRACE_EVENT(hrtimer_init,
142
143         TP_PROTO(struct hrtimer *timer, clockid_t clockid,
144                  enum hrtimer_mode mode),
145
146         TP_ARGS(timer, clockid, mode),
147
148         TP_STRUCT__entry(
149                 __field( void *,                timer           )
150                 __field( clockid_t,             clockid         )
151                 __field( enum hrtimer_mode,     mode            )
152         ),
153
154         TP_fast_assign(
155                 __entry->timer          = timer;
156                 __entry->clockid        = clockid;
157                 __entry->mode           = mode;
158         ),
159
160         TP_printk("hrtimer %p, clockid %s, mode %s", __entry->timer,
161                   __entry->clockid == CLOCK_REALTIME ?
162                         "CLOCK_REALTIME" : "CLOCK_MONOTONIC",
163                   __entry->mode == HRTIMER_MODE_ABS ?
164                         "HRTIMER_MODE_ABS" : "HRTIMER_MODE_REL")
165 );
166
167 /**
168  * hrtimer_start - called when the hrtimer is started
169  * @timer: pointer to struct hrtimer
170  */
171 TRACE_EVENT(hrtimer_start,
172
173         TP_PROTO(struct hrtimer *timer),
174
175         TP_ARGS(timer),
176
177         TP_STRUCT__entry(
178                 __field( void *,        timer           )
179                 __field( void *,        function        )
180                 __field( s64,           expires         )
181                 __field( s64,           softexpires     )
182         ),
183
184         TP_fast_assign(
185                 __entry->timer          = timer;
186                 __entry->function       = timer->function;
187                 __entry->expires        = hrtimer_get_expires(timer).tv64;
188                 __entry->softexpires    = hrtimer_get_softexpires(timer).tv64;
189         ),
190
191         TP_printk("hrtimer %p, func %pf, expires %llu, softexpires %llu",
192                   __entry->timer, __entry->function,
193                   (unsigned long long)ktime_to_ns((ktime_t) {
194                                   .tv64 = __entry->expires }),
195                   (unsigned long long)ktime_to_ns((ktime_t) {
196                                   .tv64 = __entry->softexpires }))
197 );
198
199 /**
200  * htimmer_expire_entry - called immediately before the hrtimer callback
201  * @timer:      pointer to struct hrtimer
202  * @now:        pointer to variable which contains current time of the
203  *              timers base.
204  *
205  * Allows to determine the timer latency.
206  */
207 TRACE_EVENT(hrtimer_expire_entry,
208
209         TP_PROTO(struct hrtimer *timer, ktime_t *now),
210
211         TP_ARGS(timer, now),
212
213         TP_STRUCT__entry(
214                 __field( void *,        timer   )
215                 __field( s64,           now     )
216         ),
217
218         TP_fast_assign(
219                 __entry->timer  = timer;
220                 __entry->now    = now->tv64;
221         ),
222
223         TP_printk("hrtimer %p, now %llu", __entry->timer,
224                   (unsigned long long)ktime_to_ns((ktime_t) {
225                                   .tv64 = __entry->now }))
226  );
227
228 /**
229  * hrtimer_expire_exit - called immediately after the hrtimer callback returns
230  * @timer:      pointer to struct hrtimer
231  *
232  * When used in combination with the hrtimer_expire_entry tracepoint we can
233  * determine the runtime of the callback function.
234  */
235 TRACE_EVENT(hrtimer_expire_exit,
236
237         TP_PROTO(struct hrtimer *timer),
238
239         TP_ARGS(timer),
240
241         TP_STRUCT__entry(
242                 __field( void *,        timer   )
243         ),
244
245         TP_fast_assign(
246                 __entry->timer  = timer;
247         ),
248
249         TP_printk("hrtimer %p", __entry->timer)
250 );
251
252 /**
253  * hrtimer_cancel - called when the hrtimer is canceled
254  * @timer:      pointer to struct hrtimer
255  */
256 TRACE_EVENT(hrtimer_cancel,
257
258         TP_PROTO(struct hrtimer *timer),
259
260         TP_ARGS(timer),
261
262         TP_STRUCT__entry(
263                 __field( void *,        timer   )
264         ),
265
266         TP_fast_assign(
267                 __entry->timer  = timer;
268         ),
269
270         TP_printk("hrtimer %p", __entry->timer)
271 );
272
273 #endif /*  _TRACE_TIMER_H */
274
275 /* This part must be outside protection */
276 #include <trace/define_trace.h>