8 files changed, 115 insertions, 32 deletions

diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c
index c11e3795431b..b3e3cc73ba79 100644
--- a/drivers/acpi/sleep.c
+++ b/drivers/acpi/sleep.c
@@ -19,6 +19,7 @@
 #include <linux/acpi.h>
 #include <linux/module.h>
 #include <asm/io.h>
+#include <trace/events/power.h>
 
 #include "internal.h"
 #include "sleep.h"
@@ -501,6 +502,7 @@ static int acpi_suspend_enter(suspend_state_t pm_state)
 
         ACPI_FLUSH_CPU_CACHE();
 
+        trace_suspend_resume(TPS("acpi_suspend"), acpi_state, true);
         switch (acpi_state) {
         case ACPI_STATE_S1:
                 barrier();
@@ -516,6 +518,7 @@ static int acpi_suspend_enter(suspend_state_t pm_state)
                 pr_info(PREFIX "Low-level resume complete\n");
                 break;
         }
+        trace_suspend_resume(TPS("acpi_suspend"), acpi_state, false);
 
         /* This violates the spec but is required for bug compatibility. */
         acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1);
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 343ffad59377..bf412961a934 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -214,9 +214,6 @@ static void initcall_debug_report(struct device *dev, ktime_t calltime,
                 pr_info("call %s+ returned %d after %Ld usecs\n", dev_name(dev),
                         error, (unsigned long long)nsecs >> 10);
         }
-
-        trace_device_pm_report_time(dev, info, nsecs, pm_verb(state.event),
-                                    error);
 }
 
 /**
@@ -387,7 +384,9 @@ static int dpm_run_callback(pm_callback_t cb, struct device *dev,
         calltime = initcall_debug_start(dev);
 
         pm_dev_dbg(dev, state, info);
+        trace_device_pm_callback_start(dev, info, state.event);
         error = cb(dev);
+        trace_device_pm_callback_end(dev, error);
         suspend_report_result(cb, error);
 
         initcall_debug_report(dev, calltime, error, state, info);
@@ -545,6 +544,7 @@ static void dpm_resume_noirq(pm_message_t state)
         struct device *dev;
         ktime_t starttime = ktime_get();
 
+        trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, true);
         mutex_lock(&dpm_list_mtx);
         pm_transition = state;
 
@@ -587,6 +587,7 @@ static void dpm_resume_noirq(pm_message_t state)
         dpm_show_time(starttime, state, "noirq");
         resume_device_irqs();
         cpuidle_resume();
+        trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, false);
 }
 
 /**
@@ -664,6 +665,7 @@ static void dpm_resume_early(pm_message_t state)
         struct device *dev;
         ktime_t starttime = ktime_get();
 
+        trace_suspend_resume(TPS("dpm_resume_early"), state.event, true);
         mutex_lock(&dpm_list_mtx);
         pm_transition = state;
 
@@ -703,6 +705,7 @@ static void dpm_resume_early(pm_message_t state)
         mutex_unlock(&dpm_list_mtx);
         async_synchronize_full();
         dpm_show_time(starttime, state, "early");
+        trace_suspend_resume(TPS("dpm_resume_early"), state.event, false);
 }
 
 /**
@@ -834,6 +837,7 @@ void dpm_resume(pm_message_t state)
         struct device *dev;
         ktime_t starttime = ktime_get();
 
+        trace_suspend_resume(TPS("dpm_resume"), state.event, true);
         might_sleep();
 
         mutex_lock(&dpm_list_mtx);
@@ -875,6 +879,7 @@ void dpm_resume(pm_message_t state)
         dpm_show_time(starttime, state, NULL);
 
         cpufreq_resume();
+        trace_suspend_resume(TPS("dpm_resume"), state.event, false);
 }
 
 /**
@@ -913,7 +918,9 @@ static void device_complete(struct device *dev, pm_message_t state)
 
         if (callback) {
                 pm_dev_dbg(dev, state, info);
+                trace_device_pm_callback_start(dev, info, state.event);
                 callback(dev);
+                trace_device_pm_callback_end(dev, 0);
         }
 
         device_unlock(dev);
@@ -932,6 +939,7 @@ void dpm_complete(pm_message_t state)
 {
         struct list_head list;
 
+        trace_suspend_resume(TPS("dpm_complete"), state.event, true);
         might_sleep();
 
         INIT_LIST_HEAD(&list);
@@ -951,6 +959,7 @@ void dpm_complete(pm_message_t state)
         }
         list_splice(&list, &dpm_list);
         mutex_unlock(&dpm_list_mtx);
+        trace_suspend_resume(TPS("dpm_complete"), state.event, false);
 }
 
 /**
@@ -1086,6 +1095,7 @@ static int dpm_suspend_noirq(pm_message_t state)
         ktime_t starttime = ktime_get();
         int error = 0;
 
+        trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, true);
         cpuidle_pause();
         suspend_device_irqs();
         mutex_lock(&dpm_list_mtx);
@@ -1126,6 +1136,7 @@ static int dpm_suspend_noirq(pm_message_t state)
         } else {
                 dpm_show_time(starttime, state, "noirq");
         }
+        trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, false);
         return error;
 }
 
@@ -1222,6 +1233,7 @@ static int dpm_suspend_late(pm_message_t state)
         ktime_t starttime = ktime_get();
         int error = 0;
 
+        trace_suspend_resume(TPS("dpm_suspend_late"), state.event, true);
         mutex_lock(&dpm_list_mtx);
         pm_transition = state;
         async_error = 0;
@@ -1257,6 +1269,7 @@ static int dpm_suspend_late(pm_message_t state)
         } else {
                 dpm_show_time(starttime, state, "late");
         }
+        trace_suspend_resume(TPS("dpm_suspend_late"), state.event, false);
         return error;
 }
 
@@ -1295,7 +1308,9 @@ static int legacy_suspend(struct device *dev, pm_message_t state,
 
         calltime = initcall_debug_start(dev);
 
+        trace_device_pm_callback_start(dev, info, state.event);
         error = cb(dev, state);
+        trace_device_pm_callback_end(dev, error);
         suspend_report_result(cb, error);
 
         initcall_debug_report(dev, calltime, error, state, info);
@@ -1461,6 +1476,7 @@ int dpm_suspend(pm_message_t state)
         ktime_t starttime = ktime_get();
         int error = 0;
 
+        trace_suspend_resume(TPS("dpm_suspend"), state.event, true);
         might_sleep();
 
         cpufreq_suspend();
@@ -1498,6 +1514,7 @@ int dpm_suspend(pm_message_t state)
                 dpm_save_failed_step(SUSPEND_SUSPEND);
         } else
                 dpm_show_time(starttime, state, NULL);
+        trace_suspend_resume(TPS("dpm_suspend"), state.event, false);
         return error;
 }
 
@@ -1549,8 +1566,11 @@ static int device_prepare(struct device *dev, pm_message_t state)
                 callback = dev->driver->pm->prepare;
         }
 
-        if (callback)
+        if (callback) {
+                trace_device_pm_callback_start(dev, info, state.event);
                 ret = callback(dev);
+                trace_device_pm_callback_end(dev, ret);
+        }
 
         device_unlock(dev);
 
@@ -1582,6 +1602,7 @@ int dpm_prepare(pm_message_t state)
 {
         int error = 0;
 
+        trace_suspend_resume(TPS("dpm_prepare"), state.event, true);
         might_sleep();
 
         mutex_lock(&dpm_list_mtx);
@@ -1612,6 +1633,7 @@ int dpm_prepare(pm_message_t state)
                 put_device(dev);
         }
         mutex_unlock(&dpm_list_mtx);
+        trace_suspend_resume(TPS("dpm_prepare"), state.event, false);
         return error;
 }
 
diff --git a/drivers/base/syscore.c b/drivers/base/syscore.c
index e8d11b6630ee..dbb8350ea8dc 100644
--- a/drivers/base/syscore.c
+++ b/drivers/base/syscore.c
@@ -10,6 +10,7 @@
 #include <linux/mutex.h>
 #include <linux/module.h>
 #include <linux/interrupt.h>
+#include <trace/events/power.h>
 
 static LIST_HEAD(syscore_ops_list);
 static DEFINE_MUTEX(syscore_ops_lock);
@@ -49,6 +50,7 @@ int syscore_suspend(void)
         struct syscore_ops *ops;
         int ret = 0;
 
+        trace_suspend_resume(TPS("syscore_suspend"), 0, true);
         pr_debug("Checking wakeup interrupts\n");
 
         /* Return error code if there are any wakeup interrupts pending. */
@@ -70,6 +72,7 @@ int syscore_suspend(void)
                                 "Interrupts enabled after %pF\n", ops->suspend);
                 }
 
+        trace_suspend_resume(TPS("syscore_suspend"), 0, false);
         return 0;
 
  err_out:
@@ -92,6 +95,7 @@ void syscore_resume(void)
 {
         struct syscore_ops *ops;
 
+        trace_suspend_resume(TPS("syscore_resume"), 0, true);
         WARN_ONCE(!irqs_disabled(),
                 "Interrupts enabled before system core resume.\n");
 
@@ -103,6 +107,7 @@ void syscore_resume(void)
                         WARN_ONCE(!irqs_disabled(),
                                 "Interrupts enabled after %pF\n", ops->resume);
                 }
+        trace_suspend_resume(TPS("syscore_resume"), 0, false);
 }
 EXPORT_SYMBOL_GPL(syscore_resume);
 #endif /* CONFIG_PM_SLEEP */
diff --git a/include/trace/events/power.h b/include/trace/events/power.h
index 9a7e08d61258..d19840b0cac8 100644
--- a/include/trace/events/power.h
+++ b/include/trace/events/power.h
@@ -7,6 +7,9 @@
 #include <linux/ktime.h>
 #include <linux/pm_qos.h>
 #include <linux/tracepoint.h>
+#include <linux/ftrace_event.h>
+
+#define TPS(x)  tracepoint_string(x)
 
 DECLARE_EVENT_CLASS(cpu,
 
@@ -90,6 +93,17 @@ TRACE_EVENT(pstate_sample,
 #define PWR_EVENT_EXIT -1
 #endif
 
+#define pm_verb_symbolic(event) \
+        __print_symbolic(event, \
+                { PM_EVENT_SUSPEND, "suspend" }, \
+                { PM_EVENT_RESUME, "resume" }, \
+                { PM_EVENT_FREEZE, "freeze" }, \
+                { PM_EVENT_QUIESCE, "quiesce" }, \
+                { PM_EVENT_HIBERNATE, "hibernate" }, \
+                { PM_EVENT_THAW, "thaw" }, \
+                { PM_EVENT_RESTORE, "restore" }, \
+                { PM_EVENT_RECOVER, "recover" })
+
 DEFINE_EVENT(cpu, cpu_frequency,
 
         TP_PROTO(unsigned int frequency, unsigned int cpu_id),
@@ -97,58 +111,76 @@ DEFINE_EVENT(cpu, cpu_frequency,
         TP_ARGS(frequency, cpu_id)
 );
 
-TRACE_EVENT(machine_suspend,
+TRACE_EVENT(device_pm_callback_start,
 
-        TP_PROTO(unsigned int state),
+        TP_PROTO(struct device *dev, const char *pm_ops, int event),
 
-        TP_ARGS(state),
+        TP_ARGS(dev, pm_ops, event),
 
         TP_STRUCT__entry(
-                __field(        u32,            state           )
+                __string(device, dev_name(dev))
+                __string(driver, dev_driver_string(dev))
+                __string(parent, dev->parent ? dev_name(dev->parent) : "none")
+                __string(pm_ops, pm_ops ? pm_ops : "none ")
+                __field(int, event)
         ),
 
         TP_fast_assign(
-                __entry->state = state;
+                __assign_str(device, dev_name(dev));
+                __assign_str(driver, dev_driver_string(dev));
+                __assign_str(parent,
+                        dev->parent ? dev_name(dev->parent) : "none");
+                __assign_str(pm_ops, pm_ops ? pm_ops : "none ");
+                __entry->event = event;
         ),
 
-        TP_printk("state=%lu", (unsigned long)__entry->state)
+        TP_printk("%s %s, parent: %s, %s[%s]", __get_str(driver),
+                __get_str(device), __get_str(parent), __get_str(pm_ops),
+                pm_verb_symbolic(__entry->event))
 );
 
-TRACE_EVENT(device_pm_report_time,
+TRACE_EVENT(device_pm_callback_end,
 
-        TP_PROTO(struct device *dev, const char *pm_ops, s64 ops_time,
-                 char *pm_event_str, int error),
+        TP_PROTO(struct device *dev, int error),
 
-        TP_ARGS(dev, pm_ops, ops_time, pm_event_str, error),
+        TP_ARGS(dev, error),
 
         TP_STRUCT__entry(
                 __string(device, dev_name(dev))
                 __string(driver, dev_driver_string(dev))
-                __string(parent, dev->parent ? dev_name(dev->parent) : "none")
-                __string(pm_ops, pm_ops ? pm_ops : "none ")
-                __string(pm_event_str, pm_event_str)
-                __field(s64, ops_time)
                 __field(int, error)
         ),
 
         TP_fast_assign(
-                const char *tmp = dev->parent ? dev_name(dev->parent) : "none";
-                const char *tmp_i = pm_ops ? pm_ops : "none ";
-
                 __assign_str(device, dev_name(dev));
                 __assign_str(driver, dev_driver_string(dev));
-                __assign_str(parent, tmp);
-                __assign_str(pm_ops, tmp_i);
-                __assign_str(pm_event_str, pm_event_str);
-                __entry->ops_time = ops_time;
                 __entry->error = error;
         ),
 
-        /* ops_str has an extra space at the end */
-        TP_printk("%s %s parent=%s state=%s ops=%snsecs=%lld err=%d",
-                __get_str(driver), __get_str(device), __get_str(parent),
-                __get_str(pm_event_str), __get_str(pm_ops),
-                __entry->ops_time, __entry->error)
+        TP_printk("%s %s, err=%d",
+                __get_str(driver), __get_str(device), __entry->error)
+);
+
+TRACE_EVENT(suspend_resume,
+
+        TP_PROTO(const char *action, int val, bool start),
+
+        TP_ARGS(action, val, start),
+
+        TP_STRUCT__entry(
+                __field(const char *, action)
+                __field(int, val)
+                __field(bool, start)
+        ),
+
+        TP_fast_assign(
+                __entry->action = action;
+                __entry->val = val;
+                __entry->start = start;
+        ),
+
+        TP_printk("%s[%u] %s", __entry->action, (unsigned int)__entry->val,
+                (__entry->start)?"begin":"end")
 );
 
 DECLARE_EVENT_CLASS(wakeup_source,
diff --git a/kernel/cpu.c b/kernel/cpu.c
index 247979a1b815..759feaaa9bb0 100644
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -20,6 +20,7 @@
 #include <linux/gfp.h>
 #include <linux/suspend.h>
 #include <linux/lockdep.h>
+#include <trace/events/power.h>
 
 #include "smpboot.h"
 
@@ -522,7 +523,9 @@ int disable_nonboot_cpus(void)
         for_each_online_cpu(cpu) {
                 if (cpu == first_cpu)
                         continue;
+                trace_suspend_resume(TPS("CPU_OFF"), cpu, true);
                 error = _cpu_down(cpu, 1);
+                trace_suspend_resume(TPS("CPU_OFF"), cpu, false);
                 if (!error)
                         cpumask_set_cpu(cpu, frozen_cpus);
                 else {
@@ -566,7 +569,9 @@ void __ref enable_nonboot_cpus(void)
         arch_enable_nonboot_cpus_begin();
 
         for_each_cpu(cpu, frozen_cpus) {
+                trace_suspend_resume(TPS("CPU_ON"), cpu, true);
                 error = _cpu_up(cpu, 1);
+                trace_suspend_resume(TPS("CPU_ON"), cpu, false);
                 if (!error) {
                         printk(KERN_INFO "CPU%d is up\n", cpu);
                         continue;
diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c
index df88d55dc436..49e0a20fd010 100644
--- a/kernel/power/hibernate.c
+++ b/kernel/power/hibernate.c
@@ -28,6 +28,7 @@
 #include <linux/syscore_ops.h>
 #include <linux/ctype.h>
 #include <linux/genhd.h>
+#include <trace/events/power.h>
 
 #include "power.h"
 
@@ -292,7 +293,9 @@ static int create_image(int platform_mode)
 
         in_suspend = 1;
         save_processor_state();
+        trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, true);
         error = swsusp_arch_suspend();
+        trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, false);
         if (error)
                 printk(KERN_ERR "PM: Error %d creating hibernation image\n",
                         error);
diff --git a/kernel/power/process.c b/kernel/power/process.c
index 06ec8869dbf1..0ca8d83e2369 100644
--- a/kernel/power/process.c
+++ b/kernel/power/process.c
@@ -17,6 +17,7 @@
 #include <linux/delay.h>
 #include <linux/workqueue.h>
 #include <linux/kmod.h>
+#include <trace/events/power.h>
 
 /* 
  * Timeout for stopping processes
@@ -175,6 +176,7 @@ void thaw_processes(void)
         struct task_struct *g, *p;
         struct task_struct *curr = current;
 
+        trace_suspend_resume(TPS("thaw_processes"), 0, true);
         if (pm_freezing)
                 atomic_dec(&system_freezing_cnt);
         pm_freezing = false;
@@ -201,6 +203,7 @@ void thaw_processes(void)
 
         schedule();
         printk("done.\n");
+        trace_suspend_resume(TPS("thaw_processes"), 0, false);
 }
 
 void thaw_kernel_threads(void)
diff --git a/kernel/power/suspend.c b/kernel/power/suspend.c
index 963e6d0f050b..4dd8822f732a 100644
--- a/kernel/power/suspend.c
+++ b/kernel/power/suspend.c
@@ -177,7 +177,9 @@ static int suspend_prepare(suspend_state_t state)
         if (error)
                 goto Finish;
 
+        trace_suspend_resume(TPS("freeze_processes"), 0, true);
         error = suspend_freeze_processes();
+        trace_suspend_resume(TPS("freeze_processes"), 0, false);
         if (!error)
                 return 0;
 
@@ -240,7 +242,9 @@ static int suspend_enter(suspend_state_t state, bool *wakeup)
          * all the devices are suspended.
          */
         if (state == PM_SUSPEND_FREEZE) {
+                trace_suspend_resume(TPS("machine_suspend"), state, true);
                 freeze_enter();
+                trace_suspend_resume(TPS("machine_suspend"), state, false);
                 goto Platform_wake;
         }
 
@@ -256,7 +260,11 @@ static int suspend_enter(suspend_state_t state, bool *wakeup)
         if (!error) {
                 *wakeup = pm_wakeup_pending();
                 if (!(suspend_test(TEST_CORE) || *wakeup)) {
+                        trace_suspend_resume(TPS("machine_suspend"),
+                                state, true);
                         error = suspend_ops->enter(state);
+                        trace_suspend_resume(TPS("machine_suspend"),
+                                state, false);
                         events_check_enabled = false;
                 }
                 syscore_resume();
@@ -294,7 +302,6 @@ int suspend_devices_and_enter(suspend_state_t state)
         if (need_suspend_ops(state) && !suspend_ops)
                 return -ENOSYS;
 
-        trace_machine_suspend(state);
         if (need_suspend_ops(state) && suspend_ops->begin) {
                 error = suspend_ops->begin(state);
                 if (error)
@@ -331,7 +338,6 @@ int suspend_devices_and_enter(suspend_state_t state)
         else if (state == PM_SUSPEND_FREEZE && freeze_ops->end)
                 freeze_ops->end();
 
-        trace_machine_suspend(PWR_EVENT_EXIT);
         return error;
 
  Recover_platform:
@@ -365,6 +371,7 @@ static int enter_state(suspend_state_t state)
 {
         int error;
 
+        trace_suspend_resume(TPS("suspend_enter"), state, true);
         if (state == PM_SUSPEND_FREEZE) {
 #ifdef CONFIG_PM_DEBUG
                 if (pm_test_level != TEST_NONE && pm_test_level <= TEST_CPUS) {
@@ -382,9 +389,11 @@ static int enter_state(suspend_state_t state)
         if (state == PM_SUSPEND_FREEZE)
                 freeze_begin();
 
+        trace_suspend_resume(TPS("sync_filesystems"), 0, true);
         printk(KERN_INFO "PM: Syncing filesystems ... ");
         sys_sync();
         printk("done.\n");
+        trace_suspend_resume(TPS("sync_filesystems"), 0, false);
 
         pr_debug("PM: Preparing system for %s sleep\n", pm_states[state].label);
         error = suspend_prepare(state);
@@ -394,6 +403,7 @@ static int enter_state(suspend_state_t state)
         if (suspend_test(TEST_FREEZER))
                 goto Finish;
 
+        trace_suspend_resume(TPS("suspend_enter"), state, false);
         pr_debug("PM: Entering %s sleep\n", pm_states[state].label);
         pm_restrict_gfp_mask();
         error = suspend_devices_and_enter(state);