3 files changed, 73 insertions, 7 deletions

diff --git a/drivers/xen/manage.c b/drivers/xen/manage.c
index c425d03d37d2..8835065029d3 100644
--- a/drivers/xen/manage.c
+++ b/drivers/xen/manage.c
@@ -72,18 +72,15 @@ static int xen_suspend(void *data)
         }
 
         gnttab_suspend();
+        xen_manage_runstate_time(-1);
         xen_arch_pre_suspend();
 
-        /*
-         * This hypercall returns 1 if suspend was cancelled
-         * or the domain was merely checkpointed, and 0 if it
-         * is resuming in a new domain.
-         */
         si->cancelled = HYPERVISOR_suspend(xen_pv_domain()
                                            ? virt_to_gfn(xen_start_info)
                                            : 0);
 
         xen_arch_post_suspend(si->cancelled);
+        xen_manage_runstate_time(si->cancelled ? 1 : 0);
         gnttab_resume();
 
         if (!si->cancelled) {
diff --git a/drivers/xen/time.c b/drivers/xen/time.c
index ac5f23fcafc2..8c46f555d82a 100644
--- a/drivers/xen/time.c
+++ b/drivers/xen/time.c
@@ -5,6 +5,7 @@
 #include <linux/kernel_stat.h>
 #include <linux/math64.h>
 #include <linux/gfp.h>
+#include <linux/slab.h>
 
 #include <asm/paravirt.h>
 #include <asm/xen/hypervisor.h>
@@ -19,6 +20,8 @@
 /* runstate info updated by Xen */
 static DEFINE_PER_CPU(struct vcpu_runstate_info, xen_runstate);
 
+static DEFINE_PER_CPU(u64[4], old_runstate_time);
+
 /* return an consistent snapshot of 64-bit time/counter value */
 static u64 get64(const u64 *p)
 {
@@ -47,8 +50,8 @@ static u64 get64(const u64 *p)
         return ret;
 }
 
-static void xen_get_runstate_snapshot_cpu(struct vcpu_runstate_info *res,
-                                          unsigned int cpu)
+static void xen_get_runstate_snapshot_cpu_delta(
+                              struct vcpu_runstate_info *res, unsigned int cpu)
 {
         u64 state_time;
         struct vcpu_runstate_info *state;
@@ -66,6 +69,71 @@ static void xen_get_runstate_snapshot_cpu(struct vcpu_runstate_info *res,
                  (state_time & XEN_RUNSTATE_UPDATE));
 }
 
+static void xen_get_runstate_snapshot_cpu(struct vcpu_runstate_info *res,
+                                          unsigned int cpu)
+{
+        int i;
+
+        xen_get_runstate_snapshot_cpu_delta(res, cpu);
+
+        for (i = 0; i < 4; i++)
+                res->time[i] += per_cpu(old_runstate_time, cpu)[i];
+}
+
+void xen_manage_runstate_time(int action)
+{
+        static struct vcpu_runstate_info *runstate_delta;
+        struct vcpu_runstate_info state;
+        int cpu, i;
+
+        switch (action) {
+        case -1: /* backup runstate time before suspend */
+                if (unlikely(runstate_delta))
+                        pr_warn_once("%s: memory leak as runstate_delta is not NULL\n",
+                                        __func__);
+
+                runstate_delta = kmalloc_array(num_possible_cpus(),
+                                        sizeof(*runstate_delta),
+                                        GFP_ATOMIC);
+                if (unlikely(!runstate_delta)) {
+                        pr_warn("%s: failed to allocate runstate_delta\n",
+                                        __func__);
+                        return;
+                }
+
+                for_each_possible_cpu(cpu) {
+                        xen_get_runstate_snapshot_cpu_delta(&state, cpu);
+                        memcpy(runstate_delta[cpu].time, state.time,
+                                        sizeof(runstate_delta[cpu].time));
+                }
+
+                break;
+
+        case 0: /* backup runstate time after resume */
+                if (unlikely(!runstate_delta)) {
+                        pr_warn("%s: cannot accumulate runstate time as runstate_delta is NULL\n",
+                                        __func__);
+                        return;
+                }
+
+                for_each_possible_cpu(cpu) {
+                        for (i = 0; i < 4; i++)
+                                per_cpu(old_runstate_time, cpu)[i] +=
+                                        runstate_delta[cpu].time[i];
+                }
+
+                break;
+
+        default: /* do not accumulate runstate time for checkpointing */
+                break;
+        }
+
+        if (action != -1 && runstate_delta) {
+                kfree(runstate_delta);
+                runstate_delta = NULL;
+        }
+}
+
 /*
  * Runstate accounting
  */
diff --git a/include/xen/xen-ops.h b/include/xen/xen-ops.h
index 218e6aae5433..09072271f122 100644
--- a/include/xen/xen-ops.h
+++ b/include/xen/xen-ops.h
@@ -32,6 +32,7 @@ void xen_resume_notifier_unregister(struct notifier_block *nb);
 bool xen_vcpu_stolen(int vcpu);
 void xen_setup_runstate_info(int cpu);
 void xen_time_setup_guest(void);
+void xen_manage_runstate_time(int action);
 void xen_get_runstate_snapshot(struct vcpu_runstate_info *res);
 u64 xen_steal_clock(int cpu);