X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=instrumentation%2Fevents%2Flttng-module%2Ftimer.h;h=503c5bc2bf7656867698a4c82c732da6a777f3a7;hb=3b4aafcbbef722c5d04f2fe06a47c47d4d23eda0;hp=8bd67e509bd7c394ca98627935bbfeb3737e14f4;hpb=3bc29f0a41b3c803245b845db2e1909042e72e9c;p=lttng-modules.git diff --git a/instrumentation/events/lttng-module/timer.h b/instrumentation/events/lttng-module/timer.h index 8bd67e50..503c5bc2 100644 --- a/instrumentation/events/lttng-module/timer.h +++ b/instrumentation/events/lttng-module/timer.h @@ -1,35 +1,37 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ #undef TRACE_SYSTEM #define TRACE_SYSTEM timer #if !defined(LTTNG_TRACE_TIMER_H) || defined(TRACE_HEADER_MULTI_READ) #define LTTNG_TRACE_TIMER_H -#include "../../../probes/lttng-tracepoint-event.h" +#include #ifndef _TRACE_TIMER_DEF_ #define _TRACE_TIMER_DEF_ #include #include +#include struct timer_list; #endif /* _TRACE_TIMER_DEF_ */ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) +#define lttng_ktime_get_tv64(kt) (kt) +#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */ +#define lttng_ktime_get_tv64(kt) ((kt).tv64) +#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */ + LTTNG_TRACEPOINT_EVENT_CLASS(timer_class, TP_PROTO(struct timer_list *timer), TP_ARGS(timer), - TP_STRUCT__entry( - __field( void *, timer ) - ), - - TP_fast_assign( - tp_assign(timer, timer) - ), - - TP_printk("timer=%p", __entry->timer) + TP_FIELDS( + ctf_integer_hex(void *, timer, timer) + ) ) /** @@ -43,6 +45,30 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(timer_class, timer_init, TP_ARGS(timer) ) +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,2,0) || \ + LTTNG_RHEL_KERNEL_RANGE(3,10,0,957,0,0, 3,11,0,0,0,0)) +/** + * timer_start - called when the timer is started + * @timer: pointer to struct timer_list + * @expires: the timers expiry time + * @flags: the timers expiry time + */ +LTTNG_TRACEPOINT_EVENT(timer_start, + + TP_PROTO(struct timer_list *timer, unsigned long expires, + unsigned int flags), + + TP_ARGS(timer, expires, flags), + + TP_FIELDS( + ctf_integer_hex(void *, timer, timer) + ctf_integer_hex(void *, function, timer->function) + ctf_integer(unsigned long, expires, expires) + ctf_integer(unsigned long, now, jiffies) + ctf_integer(unsigned int, flags, flags) + ) +) +#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,2,0)) */ /** * timer_start - called when the timer is started * @timer: pointer to struct timer_list @@ -54,25 +80,16 @@ LTTNG_TRACEPOINT_EVENT(timer_start, TP_ARGS(timer, expires), - TP_STRUCT__entry( - __field( void *, timer ) - __field( void *, function ) - __field( unsigned long, expires ) - __field( unsigned long, now ) - ), - - TP_fast_assign( - tp_assign(timer, timer) - tp_assign(function, timer->function) - tp_assign(expires, expires) - tp_assign(now, jiffies) - ), - - TP_printk("timer=%p function=%pf expires=%lu [timeout=%ld]", - __entry->timer, __entry->function, __entry->expires, - (long)__entry->expires - __entry->now) + TP_FIELDS( + ctf_integer_hex(void *, timer, timer) + ctf_integer_hex(void *, function, timer->function) + ctf_integer(unsigned long, expires, expires) + ctf_integer(unsigned long, now, jiffies) + ) ) +#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,2,0)) */ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,2,0)) /** * timer_expire_entry - called immediately before the timer callback * @timer: pointer to struct timer_list @@ -81,24 +98,37 @@ LTTNG_TRACEPOINT_EVENT(timer_start, */ LTTNG_TRACEPOINT_EVENT(timer_expire_entry, - TP_PROTO(struct timer_list *timer), + TP_PROTO(struct timer_list *timer, unsigned long baseclk), - TP_ARGS(timer), + TP_ARGS(timer, baseclk), - TP_STRUCT__entry( - __field( void *, timer ) - __field( unsigned long, now ) - __field( void *, function) - ), + TP_FIELDS( + ctf_integer_hex(void *, timer, timer) + ctf_integer(unsigned long, now, jiffies) + ctf_integer_hex(void *, function, timer->function) + ctf_integer(unsigned long, baseclk, baseclk) + ) +) +#else +/** + * timer_expire_entry - called immediately before the timer callback + * @timer: pointer to struct timer_list + * + * Allows to determine the timer latency. + */ +LTTNG_TRACEPOINT_EVENT(timer_expire_entry, - TP_fast_assign( - tp_assign(timer, timer) - tp_assign(now, jiffies) - tp_assign(function, timer->function) - ), + TP_PROTO(struct timer_list *timer), - TP_printk("timer=%p function=%pf now=%lu", __entry->timer, __entry->function,__entry->now) + TP_ARGS(timer), + + TP_FIELDS( + ctf_integer_hex(void *, timer, timer) + ctf_integer(unsigned long, now, jiffies) + ctf_integer_hex(void *, function, timer->function) + ) ) +#endif /** * timer_expire_exit - called immediately after the timer callback returns @@ -134,63 +164,65 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(timer_class, timer_cancel, * @clockid: the hrtimers clock * @mode: the hrtimers mode */ -LTTNG_TRACEPOINT_EVENT(hrtimer_init, +LTTNG_TRACEPOINT_EVENT_MAP(hrtimer_init, + + timer_hrtimer_init, TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid, enum hrtimer_mode mode), TP_ARGS(hrtimer, clockid, mode), - TP_STRUCT__entry( - __field( void *, hrtimer ) - __field( clockid_t, clockid ) - __field( enum hrtimer_mode, mode ) - ), - - TP_fast_assign( - tp_assign(hrtimer, hrtimer) - tp_assign(clockid, clockid) - tp_assign(mode, mode) - ), - - TP_printk("hrtimer=%p clockid=%s mode=%s", __entry->hrtimer, - __entry->clockid == CLOCK_REALTIME ? - "CLOCK_REALTIME" : "CLOCK_MONOTONIC", - __entry->mode == HRTIMER_MODE_ABS ? - "HRTIMER_MODE_ABS" : "HRTIMER_MODE_REL") + TP_FIELDS( + ctf_integer_hex(void *, hrtimer, hrtimer) + ctf_integer(clockid_t, clockid, clockid) + ctf_integer(enum hrtimer_mode, mode, mode) + ) ) /** * hrtimer_start - called when the hrtimer is started * @timer: pointer to struct hrtimer */ -LTTNG_TRACEPOINT_EVENT(hrtimer_start, +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,16,0) || \ + LTTNG_RT_KERNEL_RANGE(4,14,0,0, 4,15,0,0)) +LTTNG_TRACEPOINT_EVENT_MAP(hrtimer_start, + + timer_hrtimer_start, + + TP_PROTO(struct hrtimer *hrtimer, enum hrtimer_mode mode), + + TP_ARGS(hrtimer, mode), + + TP_FIELDS( + ctf_integer_hex(void *, hrtimer, hrtimer) + ctf_integer_hex(void *, function, hrtimer->function) + ctf_integer(s64, expires, + lttng_ktime_get_tv64(hrtimer_get_expires(hrtimer))) + ctf_integer(s64, softexpires, + lttng_ktime_get_tv64(hrtimer_get_softexpires(hrtimer))) + ctf_integer(enum hrtimer_mode, mode, mode) + ) +) +#else +LTTNG_TRACEPOINT_EVENT_MAP(hrtimer_start, + + timer_hrtimer_start, TP_PROTO(struct hrtimer *hrtimer), TP_ARGS(hrtimer), - TP_STRUCT__entry( - __field( void *, hrtimer ) - __field( void *, function ) - __field( s64, expires ) - __field( s64, softexpires ) - ), - - TP_fast_assign( - tp_assign(hrtimer, hrtimer) - tp_assign(function, hrtimer->function) - tp_assign(expires, hrtimer_get_expires(hrtimer).tv64) - tp_assign(softexpires, hrtimer_get_softexpires(hrtimer).tv64) - ), - - TP_printk("hrtimer=%p function=%pf expires=%llu softexpires=%llu", - __entry->hrtimer, __entry->function, - (unsigned long long)ktime_to_ns((ktime_t) { - .tv64 = __entry->expires }), - (unsigned long long)ktime_to_ns((ktime_t) { - .tv64 = __entry->softexpires })) + TP_FIELDS( + ctf_integer_hex(void *, hrtimer, hrtimer) + ctf_integer_hex(void *, function, hrtimer->function) + ctf_integer(s64, expires, + lttng_ktime_get_tv64(hrtimer_get_expires(hrtimer))) + ctf_integer(s64, softexpires, + lttng_ktime_get_tv64(hrtimer_get_softexpires(hrtimer))) + ) ) +#endif /** * htimmer_expire_entry - called immediately before the hrtimer callback @@ -200,43 +232,30 @@ LTTNG_TRACEPOINT_EVENT(hrtimer_start, * * Allows to determine the timer latency. */ -LTTNG_TRACEPOINT_EVENT(hrtimer_expire_entry, +LTTNG_TRACEPOINT_EVENT_MAP(hrtimer_expire_entry, + + timer_hrtimer_expire_entry, TP_PROTO(struct hrtimer *hrtimer, ktime_t *now), TP_ARGS(hrtimer, now), - TP_STRUCT__entry( - __field( void *, hrtimer ) - __field( s64, now ) - __field( void *, function) - ), - - TP_fast_assign( - tp_assign(hrtimer, hrtimer) - tp_assign(now, now->tv64) - tp_assign(function, hrtimer->function) - ), - - TP_printk("hrtimer=%p function=%pf now=%llu", __entry->hrtimer, __entry->function, - (unsigned long long)ktime_to_ns((ktime_t) { .tv64 = __entry->now })) + TP_FIELDS( + ctf_integer_hex(void *, hrtimer, hrtimer) + ctf_integer(s64, now, lttng_ktime_get_tv64(*now)) + ctf_integer_hex(void *, function, hrtimer->function) + ) ) -LTTNG_TRACEPOINT_EVENT_CLASS(hrtimer_class, +LTTNG_TRACEPOINT_EVENT_CLASS(timer_hrtimer_class, TP_PROTO(struct hrtimer *hrtimer), TP_ARGS(hrtimer), - TP_STRUCT__entry( - __field( void *, hrtimer ) - ), - - TP_fast_assign( - tp_assign(hrtimer, hrtimer) - ), - - TP_printk("hrtimer=%p", __entry->hrtimer) + TP_FIELDS( + ctf_integer_hex(void *, hrtimer, hrtimer) + ) ) /** @@ -246,7 +265,9 @@ LTTNG_TRACEPOINT_EVENT_CLASS(hrtimer_class, * When used in combination with the hrtimer_expire_entry tracepoint we can * determine the runtime of the callback function. */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(hrtimer_class, hrtimer_expire_exit, +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(timer_hrtimer_class, hrtimer_expire_exit, + + timer_hrtimer_expire_exit, TP_PROTO(struct hrtimer *hrtimer), @@ -257,7 +278,9 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(hrtimer_class, hrtimer_expire_exit, * hrtimer_cancel - called when the hrtimer is canceled * @hrtimer: pointer to struct hrtimer */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(hrtimer_class, hrtimer_cancel, +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(timer_hrtimer_class, hrtimer_cancel, + + timer_hrtimer_cancel, TP_PROTO(struct hrtimer *hrtimer), @@ -271,36 +294,64 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(hrtimer_class, hrtimer_cancel, * zero, otherwise it is started * @expires: the itimers expiry time */ -LTTNG_TRACEPOINT_EVENT(itimer_state, +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,5,0)) +LTTNG_TRACEPOINT_EVENT_MAP(itimer_state, + + timer_itimer_state, + + TP_PROTO(int which, const struct itimerspec64 *const value, + unsigned long long expires), + + TP_ARGS(which, value, expires), + + TP_FIELDS( + ctf_integer(int, which, which) + ctf_integer(unsigned long long, expires, expires) + ctf_integer(long, value_sec, value->it_value.tv_sec) + ctf_integer(long, value_nsec, value->it_value.tv_nsec) + ctf_integer(long, interval_sec, value->it_interval.tv_sec) + ctf_integer(long, interval_nsec, value->it_interval.tv_nsec) + ) +) +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) +LTTNG_TRACEPOINT_EVENT_MAP(itimer_state, + + timer_itimer_state, + + TP_PROTO(int which, const struct itimerval *const value, + unsigned long long expires), + + TP_ARGS(which, value, expires), + + TP_FIELDS( + ctf_integer(int, which, which) + ctf_integer(unsigned long long, expires, expires) + ctf_integer(long, value_sec, value->it_value.tv_sec) + ctf_integer(long, value_usec, value->it_value.tv_usec) + ctf_integer(long, interval_sec, value->it_interval.tv_sec) + ctf_integer(long, interval_usec, value->it_interval.tv_usec) + ) +) +#else /* if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) */ +LTTNG_TRACEPOINT_EVENT_MAP(itimer_state, + + timer_itimer_state, TP_PROTO(int which, const struct itimerval *const value, cputime_t expires), TP_ARGS(which, value, expires), - TP_STRUCT__entry( - __field( int, which ) - __field( cputime_t, expires ) - __field( long, value_sec ) - __field( long, value_usec ) - __field( long, interval_sec ) - __field( long, interval_usec ) - ), - - TP_fast_assign( - tp_assign(which, which) - tp_assign(expires, expires) - tp_assign(value_sec, value->it_value.tv_sec) - tp_assign(value_usec, value->it_value.tv_usec) - tp_assign(interval_sec, value->it_interval.tv_sec) - tp_assign(interval_usec, value->it_interval.tv_usec) - ), - - TP_printk("which=%d expires=%llu it_value=%ld.%ld it_interval=%ld.%ld", - __entry->which, (unsigned long long)__entry->expires, - __entry->value_sec, __entry->value_usec, - __entry->interval_sec, __entry->interval_usec) + TP_FIELDS( + ctf_integer(int, which, which) + ctf_integer(cputime_t, expires, expires) + ctf_integer(long, value_sec, value->it_value.tv_sec) + ctf_integer(long, value_usec, value->it_value.tv_usec) + ctf_integer(long, interval_sec, value->it_interval.tv_sec) + ctf_integer(long, interval_usec, value->it_interval.tv_usec) + ) ) +#endif /* #else (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) */ /** * itimer_expire - called when itimer expires @@ -308,29 +359,39 @@ LTTNG_TRACEPOINT_EVENT(itimer_state, * @pid: pid of the process which owns the timer * @now: current time, used to calculate the latency of itimer */ -LTTNG_TRACEPOINT_EVENT(itimer_expire, +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) +LTTNG_TRACEPOINT_EVENT_MAP(itimer_expire, - TP_PROTO(int which, struct pid *pid, cputime_t now), + timer_itimer_expire, + + TP_PROTO(int which, struct pid *pid, unsigned long long now), TP_ARGS(which, pid, now), - TP_STRUCT__entry( - __field( int , which ) - __field( pid_t, pid ) - __field( cputime_t, now ) - ), + TP_FIELDS( + ctf_integer(int , which, which) + ctf_integer(pid_t, pid, pid_nr(pid)) + ctf_integer(unsigned long long, now, now) + ) +) +#else /* if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) */ +LTTNG_TRACEPOINT_EVENT_MAP(itimer_expire, + + timer_itimer_expire, - TP_fast_assign( - tp_assign(which, which) - tp_assign(now, now) - tp_assign(pid, pid_nr(pid)) - ), + TP_PROTO(int which, struct pid *pid, cputime_t now), + + TP_ARGS(which, pid, now), - TP_printk("which=%d pid=%d now=%llu", __entry->which, - (int) __entry->pid, (unsigned long long)__entry->now) + TP_FIELDS( + ctf_integer(int , which, which) + ctf_integer(pid_t, pid, pid_nr(pid)) + ctf_integer(cputime_t, now, now) + ) ) +#endif /* #else (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)) */ #endif /* LTTNG_TRACE_TIMER_H */ /* This part must be outside protection */ -#include "../../../probes/define_trace.h" +#include