From patchwork Mon Nov 28 22:35:21 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 84465 Delivered-To: patches@linaro.org Received: by 10.140.20.101 with SMTP id 92csp1348545qgi; Mon, 28 Nov 2016 14:35:31 -0800 (PST) X-Received: by 10.84.176.100 with SMTP id u91mr53517988plb.7.1480372531658; Mon, 28 Nov 2016 14:35:31 -0800 (PST) Return-Path: Received: from mail-pg0-x235.google.com (mail-pg0-x235.google.com. [2607:f8b0:400e:c05::235]) by mx.google.com with ESMTPS id c186si56766935pga.181.2016.11.28.14.35.31 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Nov 2016 14:35:31 -0800 (PST) Received-SPF: pass (google.com: domain of john.stultz@linaro.org designates 2607:f8b0:400e:c05::235 as permitted sender) client-ip=2607:f8b0:400e:c05::235; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org; spf=pass (google.com: domain of john.stultz@linaro.org designates 2607:f8b0:400e:c05::235 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE dis=NONE) header.from=linaro.org Received: by mail-pg0-x235.google.com with SMTP id f188so61230526pgc.3 for ; Mon, 28 Nov 2016 14:35:31 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=1YWGN25/V/UUgbYkwSxUqInPxXmwC521ejUdvPh/fLI=; b=GQR5cBL1imyZrmQaepkLC22WhWoC1AksSJ16OJr0Q7ZvxtD1nWxDAKJNCrXWDpu1Ta eImvD03YUH7l/MaOBUHGll+eM2rgdF56wHXw4246qo+fY886mmeyF22oYvMMEnVxjzD/ eLrPD6Arzp03yeG8PVdedd1QL67JCuvSc85nY= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=1YWGN25/V/UUgbYkwSxUqInPxXmwC521ejUdvPh/fLI=; b=gGXtYx/1kghfQd1R2YUi9b3ES1FKzCyLA6l9Kwm97+fHqcXaCxjLYxCfmD3f7cQQW8 7NzRPGtPoBdAeRMxMRSeg7Mzw2A3o2/CTks2RJBCywDAOVWP6GWmNztHB7l8wJ2Hpo6A hqTRKXo7n0exH0qgTQhZZFk2NSU3HVMX9w71yD7gWua6t7OceAJa6I0I4egY65Pljp9N hy11dY0KLEXnNfFlbqP3GpqhYO9b85DNot5n75ZTQNYaeBz6gE9HOfzsV1Bw4PKSqXN0 cf206vd1IFCoz6ig211o8UHoNfTbqspCovwwQDvFQM3xvGaUjrQufO8HvN3w9YUJCpzt YeIw== X-Gm-Message-State: AKaTC03Bx9YgmEFiXfCL7r9k406iaTMvk1UjSJ2yYHMAnu91I91ooul5DHttxcJBNc2iGjbIhf8= X-Received: by 10.99.222.85 with SMTP id y21mr44041469pgi.119.1480372531291; Mon, 28 Nov 2016 14:35:31 -0800 (PST) Return-Path: Received: from localhost.localdomain ([2601:1c2:1002:83f0:4e72:b9ff:fe99:466a]) by smtp.gmail.com with ESMTPSA id r74sm89537352pfl.79.2016.11.28.14.35.30 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 28 Nov 2016 14:35:30 -0800 (PST) From: John Stultz To: lkml Cc: Baolin Wang , Thomas Gleixner , Richard Cochran , Prarit Bhargava , Ingo Molnar , Steven Rostedt , John Stultz Subject: [PATCH 4/7] time: alarmtimer: Add the tracepoints for alarmtimer Date: Mon, 28 Nov 2016 14:35:21 -0800 Message-Id: <1480372524-15181-5-git-send-email-john.stultz@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1480372524-15181-1-git-send-email-john.stultz@linaro.org> References: <1480372524-15181-1-git-send-email-john.stultz@linaro.org> From: Baolin Wang For system debugging, we sometimes want to know who sets one alarm timer, the time of the timer, when the timer started and fired and so on. Thus adding tracepoints can help us trace the alarmtimer information. For example, when we debug the system supend/resume, if the system is always resumed by RTC alarm, we can find out which process set the alarm timer to resume system by below trace log: ...... Binder:3292_2-3304 [000] d..2 149.981123: alarmtimer_cancel: alarmtimer:ffffffc1319a7800 type:REALTIME expires:1325463120000000000 now:1325376810370370245 Binder:3292_2-3304 [000] d..2 149.981136: alarmtimer_start: alarmtimer:ffffffc1319a7800 type:REALTIME expires:1325376840000000000 now:1325376810370384591 Binder:3292_9-3953 [000] d..2 150.212991: alarmtimer_cancel: alarmtimer:ffffffc1319a5a00 type:BOOTTIME expires:179552000000 now:150154008122 Binder:3292_9-3953 [000] d..2 150.213006: alarmtimer_start: alarmtimer:ffffffc1319a5a00 type:BOOTTIME expires:179551000000 now:150154025622 ...... system_server-3000 [002] ...1 162.701940: alarmtimer_suspend: alarmtimer type:REALTIME expires:1325376839802714584 ...... >From the trace log, we can find out the 'Binder:3292_2' process set one alarm timer which resumes the system. Cc: Thomas Gleixner Cc: Richard Cochran Cc: Prarit Bhargava Cc: Ingo Molnar Cc: Steven Rostedt Signed-off-by: Baolin Wang Acked-by: Steven Rostedt Signed-off-by: John Stultz --- Changes since v4: - Initialize 'type' to -1 and rename it in alarmtimer_suspend(). - Fix typo in subject line. Changes since v3: - Remove the "ALARM_" prefix in the string. - Add the ACK by Steven Rostedt. Changes since v2: - Save time as s64 type. - Remove 'process_name' parameter and add 'now' parameter. - Rename the trace event name. - Remove restart trace event. - Other optimization. --- include/trace/events/alarmtimer.h | 92 +++++++++++++++++++++++++++++++++++++++ kernel/time/alarmtimer.c | 16 ++++++- 2 files changed, 106 insertions(+), 2 deletions(-) create mode 100644 include/trace/events/alarmtimer.h -- 2.7.4 Tested-by: Baolin Wang diff --git a/include/trace/events/alarmtimer.h b/include/trace/events/alarmtimer.h new file mode 100644 index 0000000..61ea556 --- /dev/null +++ b/include/trace/events/alarmtimer.h @@ -0,0 +1,92 @@ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM alarmtimer + +#if !defined(_TRACE_ALARMTIMER_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_ALARMTIMER_H + +#include +#include +#include + +TRACE_DEFINE_ENUM(ALARM_REALTIME); +TRACE_DEFINE_ENUM(ALARM_BOOTTIME); + +#define show_alarm_type(type) __print_flags(type, " | ", \ + { 1 << ALARM_REALTIME, "REALTIME" }, \ + { 1 << ALARM_BOOTTIME, "BOOTTIME" }) + +TRACE_EVENT(alarmtimer_suspend, + + TP_PROTO(ktime_t expires, int flag), + + TP_ARGS(expires, flag), + + TP_STRUCT__entry( + __field(s64, expires) + __field(unsigned char, alarm_type) + ), + + TP_fast_assign( + __entry->expires = expires.tv64; + __entry->alarm_type = flag; + ), + + TP_printk("alarmtimer type:%s expires:%llu", + show_alarm_type((1 << __entry->alarm_type)), + __entry->expires + ) +); + +DECLARE_EVENT_CLASS(alarm_class, + + TP_PROTO(struct alarm *alarm, ktime_t now), + + TP_ARGS(alarm, now), + + TP_STRUCT__entry( + __field(void *, alarm) + __field(unsigned char, alarm_type) + __field(s64, expires) + __field(s64, now) + ), + + TP_fast_assign( + __entry->alarm = alarm; + __entry->alarm_type = alarm->type; + __entry->expires = alarm->node.expires.tv64; + __entry->now = now.tv64; + ), + + TP_printk("alarmtimer:%p type:%s expires:%llu now:%llu", + __entry->alarm, + show_alarm_type((1 << __entry->alarm_type)), + __entry->expires, + __entry->now + ) +); + +DEFINE_EVENT(alarm_class, alarmtimer_fired, + + TP_PROTO(struct alarm *alarm, ktime_t now), + + TP_ARGS(alarm, now) +); + +DEFINE_EVENT(alarm_class, alarmtimer_start, + + TP_PROTO(struct alarm *alarm, ktime_t now), + + TP_ARGS(alarm, now) +); + +DEFINE_EVENT(alarm_class, alarmtimer_cancel, + + TP_PROTO(struct alarm *alarm, ktime_t now), + + TP_ARGS(alarm, now) +); + +#endif /* _TRACE_ALARMTIMER_H */ + +/* This part must be outside protection */ +#include diff --git a/kernel/time/alarmtimer.c b/kernel/time/alarmtimer.c index 12dd190..4590f23 100644 --- a/kernel/time/alarmtimer.c +++ b/kernel/time/alarmtimer.c @@ -26,6 +26,9 @@ #include #include +#define CREATE_TRACE_POINTS +#include + /** * struct alarm_base - Alarm timer bases * @lock: Lock for syncrhonized access to the base @@ -194,6 +197,7 @@ static enum hrtimer_restart alarmtimer_fired(struct hrtimer *timer) } spin_unlock_irqrestore(&base->lock, flags); + trace_alarmtimer_fired(alarm, base->gettime()); return ret; } @@ -222,7 +226,7 @@ static int alarmtimer_suspend(struct device *dev) ktime_t min, now; unsigned long flags; struct rtc_device *rtc; - int i; + int i, min_type = -1; int ret; spin_lock_irqsave(&freezer_delta_lock, flags); @@ -247,8 +251,10 @@ static int alarmtimer_suspend(struct device *dev) if (!next) continue; delta = ktime_sub(next->expires, base->gettime()); - if (!min.tv64 || (delta.tv64 < min.tv64)) + if (!min.tv64 || (delta.tv64 < min.tv64)) { min = delta; + min_type = i; + } } if (min.tv64 == 0) return 0; @@ -264,6 +270,8 @@ static int alarmtimer_suspend(struct device *dev) now = rtc_tm_to_ktime(tm); now = ktime_add(now, min); + trace_alarmtimer_suspend(now, min_type); + /* Set alarm, if in the past reject suspend briefly to handle */ ret = rtc_timer_start(rtc, &rtctimer, now, ktime_set(0, 0)); if (ret < 0) @@ -342,6 +350,8 @@ void alarm_start(struct alarm *alarm, ktime_t start) alarmtimer_enqueue(base, alarm); hrtimer_start(&alarm->timer, alarm->node.expires, HRTIMER_MODE_ABS); spin_unlock_irqrestore(&base->lock, flags); + + trace_alarmtimer_start(alarm, base->gettime()); } EXPORT_SYMBOL_GPL(alarm_start); @@ -390,6 +400,8 @@ int alarm_try_to_cancel(struct alarm *alarm) if (ret >= 0) alarmtimer_dequeue(base, alarm); spin_unlock_irqrestore(&base->lock, flags); + + trace_alarmtimer_cancel(alarm, base->gettime()); return ret; } EXPORT_SYMBOL_GPL(alarm_try_to_cancel);