Skip to contentSkip to conversation

xen: maintain an accurate persistent clock in more cases

PATCH Superseded David Vrabel 5 participants 27 messages May 28, 2013 – Jun 4, 2013

Subsystems (2)

v2 of 6 Superseded Latest is v6 →

lore
Share & tools
lore
#0 lore raw

v2 cover xen: maintain an accurate persistent clock in more cases

The kernel has limited support for updating the persistent clock or RTC when NTP is synced. This has the following limitations:

* The persistent clock is not updated on step changes. This leaves a window where it will be incorrect (while NTP resyncs).

* Xen guests use the Xen wallclock as their persistent clock. dom0 maintains this clock so it is persistent for domUs and not dom0 itself.

These series fixes the above limitations and depends on "x86: increase precision of x86_platform.get/set_wallclock()" which was previously posted.

Changes since v1:

Reworked to use the pvclock_gtod notifier to sync the wallclock (this looked similar to what a KVM host does). update_persistent_clock() will now only update the CMOS RTC.

David

[1] http://lists.xen.org/archives/html/xen-devel/2013-05/msg01402.html

#1 lore raw

PATCH v2 1/2 x86/xen: sync the CMOS RTC as well as the Xen wallclock

From: David Vrabel <[email protected]>

Adjustments to Xen's persistent_clock via update_persistent_clock() don't actually persist, as the xen_set_walltime() just notifies other domN guests that it has been updated, and does not modify the underlying CMOS clock.

Thus, this patch modifies xen_set_wallclock() so it will set the underlying CMOS clock when called from dom0, ensuring the persistent_clock will be correct on the next hardware boot.

Dom0 does not support accessing EFI runtime services and Xen does not run on Moorsetown platforms so the CMOS RTC is the only supported hardware clock.

---
 arch/x86/xen/time.c |   11 ++++++++++-
 1 files changed, 10 insertions(+), 1 deletions(-)
arch/x86/xen/time.c +10 -1
index a1947ac..4656165 100644
@@ -14,6 +14,7 @@
 #include <linux/kernel_stat.h>
 #include <linux/math64.h>
 #include <linux/gfp.h>
+#include <linux/mc146818rtc.h>
 
 #include <asm/pvclock.h>
 #include <asm/xen/hypervisor.h>
@@ -199,17 +200,25 @@ static void xen_get_wallclock(struct timespec *now)
 static int xen_set_wallclock(const struct timespec *now)
 {
 	struct xen_platform_op op;
+	int ret;
 
 	/* do nothing for domU */
 	if (!xen_initial_domain())
 		return -1;
 
+	/* Set the Xen wallclock. */
 	op.cmd = XENPF_settime;
 	op.u.settime.secs = now->tv_sec;
 	op.u.settime.nsecs = now->tv_nsec;
 	op.u.settime.system_time = xen_clocksource_read();
 
-	return HYPERVISOR_dom0_op(&op);
+	ret = HYPERVISOR_dom0_op(&op);
+	if (ret)
+		return ret;
+
+	/* Set the hardware RTC. */
+	return mach_set_rtc_mmss(now);
+
 }
 
 static struct clocksource xen_clocksource __read_mostly = {
Signature · 1 line
1.7.2.5
#2 lore raw

PATCH v2 1/2 x86/xen: sync the CMOS RTC as well as the Xen wallclock

In reply to David Vrabel

From: David Vrabel <[email protected]>

Adjustments to Xen's persistent_clock via update_persistent_clock() don't actually persist, as the xen_set_walltime() just notifies other domN guests that it has been updated, and does not modify the underlying CMOS clock.

Thus, this patch modifies xen_set_wallclock() so it will set the underlying CMOS clock when called from dom0, ensuring the persistent_clock will be correct on the next hardware boot.

Dom0 does not support accessing EFI runtime services and Xen does not run on Moorsetown platforms so the CMOS RTC is the only supported hardware clock.

---
 arch/x86/xen/time.c |   11 ++++++++++-
 1 files changed, 10 insertions(+), 1 deletions(-)
arch/x86/xen/time.c +10 -1
index a1947ac..4656165 100644
@@ -14,6 +14,7 @@
 #include <linux/kernel_stat.h>
 #include <linux/math64.h>
 #include <linux/gfp.h>
+#include <linux/mc146818rtc.h>
 
 #include <asm/pvclock.h>
 #include <asm/xen/hypervisor.h>
@@ -199,17 +200,25 @@ static void xen_get_wallclock(struct timespec *now)
 static int xen_set_wallclock(const struct timespec *now)
 {
 	struct xen_platform_op op;
+	int ret;
 
 	/* do nothing for domU */
 	if (!xen_initial_domain())
 		return -1;
 
+	/* Set the Xen wallclock. */
 	op.cmd = XENPF_settime;
 	op.u.settime.secs = now->tv_sec;
 	op.u.settime.nsecs = now->tv_nsec;
 	op.u.settime.system_time = xen_clocksource_read();
 
-	return HYPERVISOR_dom0_op(&op);
+	ret = HYPERVISOR_dom0_op(&op);
+	if (ret)
+		return ret;
+
+	/* Set the hardware RTC. */
+	return mach_set_rtc_mmss(now);
+
 }
 
 static struct clocksource xen_clocksource __read_mostly = {
Signature · 1 line
1.7.2.5
#3 lore raw

Re: [PATCH 1/2] x86/xen: sync the CMOS RTC as well as the Xen wallclock

Quoted 11 lines · David Vrabel

From: David Vrabel <[email protected]>

Adjustments to Xen's persistent_clock via update_persistent_clock() don't actually persist, as the xen_set_walltime() just notifies other domN guests that it has been updated, and does not modify the underlying CMOS clock.

Thus, this patch modifies xen_set_wallclock() so it will set the underlying CMOS clock when called from dom0, ensuring the persistent_clock will be correct on the next hardware boot.

Quoted 6 lines

Dom0 does not support accessing EFI runtime services and Xen does not run on Moorsetown platforms so the CMOS RTC is the only supported hardware clock.

Ok, I've queued this for 3.11.

thanks
-john

#4 lore raw

Re: [PATCH 1/2] x86/xen: sync the CMOS RTC as well as the Xen wallclock

In reply to David Vrabel
Quoted 11 lines · David Vrabel

From: David Vrabel <[email protected]>

Adjustments to Xen's persistent_clock via update_persistent_clock() don't actually persist, as the xen_set_walltime() just notifies other domN guests that it has been updated, and does not modify the underlying CMOS clock.

Thus, this patch modifies xen_set_wallclock() so it will set the underlying CMOS clock when called from dom0, ensuring the persistent_clock will be correct on the next hardware boot.

Quoted 6 lines

Dom0 does not support accessing EFI runtime services and Xen does not run on Moorsetown platforms so the CMOS RTC is the only supported hardware clock.

Ok, I've queued this for 3.11.

thanks
-john

#5 lore raw

Re: [PATCH 1/2] x86/xen: sync the CMOS RTC as well as the Xen wallclock

Quoted 12 lines · John Stultz
Quoted 11 lines · David Vrabel

From: David Vrabel <[email protected]>

Adjustments to Xen's persistent_clock via update_persistent_clock() don't actually persist, as the xen_set_walltime() just notifies other domN guests that it has been updated, and does not modify the underlying CMOS clock.

Thus, this patch modifies xen_set_wallclock() so it will set the underlying CMOS clock when called from dom0, ensuring the persistent_clock will be correct on the next hardware boot.

Quoted 8 lines
Quoted 6 lines

Dom0 does not support accessing EFI runtime services and Xen does not run on Moorsetown platforms so the CMOS RTC is the only supported hardware clock.

Ok, I've queued this for 3.11.

Thanks.

Quoted 4 lines

thanks
-john

#6 lore raw

Re: [PATCH 1/2] x86/xen: sync the CMOS RTC as well as the Xen wallclock

In reply to John Stultz
Quoted 12 lines · John Stultz
Quoted 11 lines · David Vrabel

From: David Vrabel <[email protected]>

Adjustments to Xen's persistent_clock via update_persistent_clock() don't actually persist, as the xen_set_walltime() just notifies other domN guests that it has been updated, and does not modify the underlying CMOS clock.

Thus, this patch modifies xen_set_wallclock() so it will set the underlying CMOS clock when called from dom0, ensuring the persistent_clock will be correct on the next hardware boot.

Quoted 8 lines
Quoted 6 lines

Dom0 does not support accessing EFI runtime services and Xen does not run on Moorsetown platforms so the CMOS RTC is the only supported hardware clock.

Ok, I've queued this for 3.11.

Thanks.

Quoted 4 lines

thanks
-john

#7 lore raw

PATCH v2 2/2 x86/xen: sync the wallclock when the system time changes

In reply to David Vrabel

From: David Vrabel <[email protected]>

Currently the Xen wallclock is only updated every 11 minutes if NTP is synchronized to its clock source. If a guest is started before NTP is synchronized it may see an incorrect wallclock time.

Use the pvclock_gtod notifier chain to receive a notification when the system time has changed and update the wallclock to match.

This chain is called on every timer tick and we want to avoid an extra (expensive) hypercall on every tick. Because dom0 has historically never provided a very accurate wallclock and guests do not expect one, we can do this simply. The wallclock is only updated if the difference between now and the last update is more than 0.5 s.

---
 arch/x86/xen/time.c |   54 ++++++++++++++++++++++++++++++++++++++++++--------
 1 files changed, 45 insertions(+), 9 deletions(-)
arch/x86/xen/time.c +45 -9
index 4656165..81027b5 100644
@@ -15,6 +15,8 @@
 #include <linux/math64.h>
 #include <linux/gfp.h>
 #include <linux/mc146818rtc.h>
+#include <linux/timekeeper_internal.h>
+#include <linux/pvclock_gtod.h>
 
 #include <asm/pvclock.h>
 #include <asm/xen/hypervisor.h>
@@ -199,28 +201,59 @@ static void xen_get_wallclock(struct timespec *now)
 
 static int xen_set_wallclock(const struct timespec *now)
 {
-	struct xen_platform_op op;
-	int ret;
-
 	/* do nothing for domU */
 	if (!xen_initial_domain())
 		return -1;
 
-	/* Set the Xen wallclock. */
+	/* Set the hardware RTC. */
+	return mach_set_rtc_mmss(now);
+
+}
+
+static int xen_pvclock_gtod_notify(struct notifier_block *nb, unsigned long unused,
+				   void *priv)
+{
+	static struct timespec last, next;
+	struct timespec now;
+	struct timekeeper *tk = priv;
+	struct xen_platform_op op;
+	int ret;
+
+	/*
+	 * Set the Xen wallclock from Linux system time.
+	 *
+	 * dom0 hasn't historically maintained a very accurate
+	 * wallclock so guests don't expect it. We can therefore
+	 * reduce the number of expensive hypercalls by only updating
+	 * the wallclock every 0.5 s.
+	 */
+
+	now.tv_sec = tk->xtime_sec;
+	now.tv_nsec = tk->xtime_nsec >> tk->shift;
+
+	if (timespec_compare(&now, &last) > 0
+	    && timespec_compare(&now, &next) < 0)
+		return 0;
+
 	op.cmd = XENPF_settime;
-	op.u.settime.secs = now->tv_sec;
-	op.u.settime.nsecs = now->tv_nsec;
+	op.u.settime.secs = now.tv_sec;
+	op.u.settime.nsecs = now.tv_nsec;
 	op.u.settime.system_time = xen_clocksource_read();
 
 	ret = HYPERVISOR_dom0_op(&op);
 	if (ret)
-		return ret;
+		return 0;
 
-	/* Set the hardware RTC. */
-	return mach_set_rtc_mmss(now);
+	last = now;
+	next = timespec_add(now, ns_to_timespec(NSEC_PER_SEC / 2));
 
+	return 0;
 }
 
+static struct notifier_block xen_pvclock_gtod_notifier = {
+	.notifier_call = xen_pvclock_gtod_notify,
+};
+
 static struct clocksource xen_clocksource __read_mostly = {
 	.name = "xen",
 	.rating = 400,
@@ -482,6 +515,9 @@ static void __init xen_time_init(void)
 	xen_setup_runstate_info(cpu);
 	xen_setup_timer(cpu);
 	xen_setup_cpu_clockevents();
+
+	if (xen_initial_domain())
+		pvclock_gtod_register_notifier(&xen_pvclock_gtod_notifier);
 }
 
 void __init xen_init_time_ops(void)
Signature · 1 line
1.7.2.5
#8 lore raw

PATCH v2 2/2 x86/xen: sync the wallclock when the system time changes

In reply to David Vrabel

From: David Vrabel <[email protected]>

Currently the Xen wallclock is only updated every 11 minutes if NTP is synchronized to its clock source. If a guest is started before NTP is synchronized it may see an incorrect wallclock time.

Use the pvclock_gtod notifier chain to receive a notification when the system time has changed and update the wallclock to match.

This chain is called on every timer tick and we want to avoid an extra (expensive) hypercall on every tick. Because dom0 has historically never provided a very accurate wallclock and guests do not expect one, we can do this simply. The wallclock is only updated if the difference between now and the last update is more than 0.5 s.

---
 arch/x86/xen/time.c |   54 ++++++++++++++++++++++++++++++++++++++++++--------
 1 files changed, 45 insertions(+), 9 deletions(-)
arch/x86/xen/time.c +45 -9
index 4656165..81027b5 100644
@@ -15,6 +15,8 @@
 #include <linux/math64.h>
 #include <linux/gfp.h>
 #include <linux/mc146818rtc.h>
+#include <linux/timekeeper_internal.h>
+#include <linux/pvclock_gtod.h>
 
 #include <asm/pvclock.h>
 #include <asm/xen/hypervisor.h>
@@ -199,28 +201,59 @@ static void xen_get_wallclock(struct timespec *now)
 
 static int xen_set_wallclock(const struct timespec *now)
 {
-	struct xen_platform_op op;
-	int ret;
-
 	/* do nothing for domU */
 	if (!xen_initial_domain())
 		return -1;
 
-	/* Set the Xen wallclock. */
+	/* Set the hardware RTC. */
+	return mach_set_rtc_mmss(now);
+
+}
+
+static int xen_pvclock_gtod_notify(struct notifier_block *nb, unsigned long unused,
+				   void *priv)
+{
+	static struct timespec last, next;
+	struct timespec now;
+	struct timekeeper *tk = priv;
+	struct xen_platform_op op;
+	int ret;
+
+	/*
+	 * Set the Xen wallclock from Linux system time.
+	 *
+	 * dom0 hasn't historically maintained a very accurate
+	 * wallclock so guests don't expect it. We can therefore
+	 * reduce the number of expensive hypercalls by only updating
+	 * the wallclock every 0.5 s.
+	 */
+
+	now.tv_sec = tk->xtime_sec;
+	now.tv_nsec = tk->xtime_nsec >> tk->shift;
+
+	if (timespec_compare(&now, &last) > 0
+	    && timespec_compare(&now, &next) < 0)
+		return 0;
+
 	op.cmd = XENPF_settime;
-	op.u.settime.secs = now->tv_sec;
-	op.u.settime.nsecs = now->tv_nsec;
+	op.u.settime.secs = now.tv_sec;
+	op.u.settime.nsecs = now.tv_nsec;
 	op.u.settime.system_time = xen_clocksource_read();
 
 	ret = HYPERVISOR_dom0_op(&op);
 	if (ret)
-		return ret;
+		return 0;
 
-	/* Set the hardware RTC. */
-	return mach_set_rtc_mmss(now);
+	last = now;
+	next = timespec_add(now, ns_to_timespec(NSEC_PER_SEC / 2));
 
+	return 0;
 }
 
+static struct notifier_block xen_pvclock_gtod_notifier = {
+	.notifier_call = xen_pvclock_gtod_notify,
+};
+
 static struct clocksource xen_clocksource __read_mostly = {
 	.name = "xen",
 	.rating = 400,
@@ -482,6 +515,9 @@ static void __init xen_time_init(void)
 	xen_setup_runstate_info(cpu);
 	xen_setup_timer(cpu);
 	xen_setup_cpu_clockevents();
+
+	if (xen_initial_domain())
+		pvclock_gtod_register_notifier(&xen_pvclock_gtod_notifier);
 }
 
 void __init xen_init_time_ops(void)
Signature · 1 line
1.7.2.5
#9 lore raw

Re: [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

Quoted 25 lines · David Vrabel

From: David Vrabel <[email protected]>

Currently the Xen wallclock is only updated every 11 minutes if NTP is synchronized to its clock source. If a guest is started before NTP is synchronized it may see an incorrect wallclock time.

Use the pvclock_gtod notifier chain to receive a notification when the system time has changed and update the wallclock to match.

This chain is called on every timer tick and we want to avoid an extra (expensive) hypercall on every tick. Because dom0 has historically never provided a very accurate wallclock and guests do not expect one, we can do this simply. The wallclock is only updated if the difference between now and the last update is more than 0.5 s.

---
  arch/x86/xen/time.c |   54 ++++++++++++++++++++++++++++++++++++++++++--------
  1 files changed, 45 insertions(+), 9 deletions(-)
arch/x86/xen/time.c +0 -0
index 4656165..81027b5 100644

arch/x86/xen/time.c line 18

Quoted 4 lines
arch/x86/xen/time.c +1 -0
@@ -15,6 +15,8 @@
  #include <linux/math64.h>
  #include <linux/gfp.h>
  #include <linux/mc146818rtc.h>
+#include <linux/timekeeper_internal.h>

Nope. You shouldn't be including this.

Quoted 17 lines
arch/x86/xen/time.c +2 -4
+#include <linux/pvclock_gtod.h>
 
  #include <asm/pvclock.h>
  #include <asm/xen/hypervisor.h>
@@ -199,28 +201,59 @@ static void xen_get_wallclock(struct timespec *now)
 
  static int xen_set_wallclock(const struct timespec *now)
  {
-	struct xen_platform_op op;
-	int ret;
-
  	/* do nothing for domU */
  	if (!xen_initial_domain())
  		return -1;
 
-	/* Set the Xen wallclock. */
+	/* Set the hardware RTC. */

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 218

Quoted 10 lines
arch/x86/xen/time.c +10 -0
+	return mach_set_rtc_mmss(now);
+
+}
+
+static int xen_pvclock_gtod_notify(struct notifier_block *nb, unsigned long unused,
+				   void *priv)
+{
+	static struct timespec last, next;
+	struct timespec now;
+	struct timekeeper *tk = priv;

Noooo.. don't export the timekeeper like that.

Quoted 4 lines
arch/x86/xen/time.c +4 -0
+	struct xen_platform_op op;
+	int ret;
+
+	/*

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 232

Quoted 10 lines
arch/x86/xen/time.c +10 -0
+	 * Set the Xen wallclock from Linux system time.
+	 *
+	 * dom0 hasn't historically maintained a very accurate
+	 * wallclock so guests don't expect it. We can therefore
+	 * reduce the number of expensive hypercalls by only updating
+	 * the wallclock every 0.5 s.
+	 */
+
+	now.tv_sec = tk->xtime_sec;
+	now.tv_nsec = tk->xtime_nsec >> tk->shift;

You probably want current_kernel_time() here.

Quoted 12 lines
arch/x86/xen/time.c +7 -2
+
+	if (timespec_compare(&now, &last) > 0
+	    && timespec_compare(&now, &next) < 0)
+		return 0;
+
  	op.cmd = XENPF_settime;
-	op.u.settime.secs = now->tv_sec;
-	op.u.settime.nsecs = now->tv_nsec;
+	op.u.settime.secs = now.tv_sec;
+	op.u.settime.nsecs = now.tv_nsec;
  	op.u.settime.system_time = xen_clocksource_read();
 

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 249

Quoted 10 lines
arch/x86/xen/time.c +3 -3
  	ret = HYPERVISOR_dom0_op(&op);
  	if (ret)
-		return ret;
+		return 0;
 
-	/* Set the hardware RTC. */
-	return mach_set_rtc_mmss(now);
+	last = now;
+	next = timespec_add(now, ns_to_timespec(NSEC_PER_SEC / 2));
 

Am I missing the xen_set_wallclock hook here? Your previous patch wanted to call the dom0 op and then set the hardware RTC.

And this notifier get called every timer tick? This seems out there...

thanks
-john

#10 lore raw

Re: [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

In reply to David Vrabel
Quoted 25 lines · David Vrabel

From: David Vrabel <[email protected]>

Currently the Xen wallclock is only updated every 11 minutes if NTP is synchronized to its clock source. If a guest is started before NTP is synchronized it may see an incorrect wallclock time.

Use the pvclock_gtod notifier chain to receive a notification when the system time has changed and update the wallclock to match.

This chain is called on every timer tick and we want to avoid an extra (expensive) hypercall on every tick. Because dom0 has historically never provided a very accurate wallclock and guests do not expect one, we can do this simply. The wallclock is only updated if the difference between now and the last update is more than 0.5 s.

---
  arch/x86/xen/time.c |   54 ++++++++++++++++++++++++++++++++++++++++++--------
  1 files changed, 45 insertions(+), 9 deletions(-)
arch/x86/xen/time.c +0 -0
index 4656165..81027b5 100644

arch/x86/xen/time.c line 18

Quoted 4 lines
arch/x86/xen/time.c +1 -0
@@ -15,6 +15,8 @@
  #include <linux/math64.h>
  #include <linux/gfp.h>
  #include <linux/mc146818rtc.h>
+#include <linux/timekeeper_internal.h>

Nope. You shouldn't be including this.

Quoted 17 lines
arch/x86/xen/time.c +2 -4
+#include <linux/pvclock_gtod.h>
 
  #include <asm/pvclock.h>
  #include <asm/xen/hypervisor.h>
@@ -199,28 +201,59 @@ static void xen_get_wallclock(struct timespec *now)
 
  static int xen_set_wallclock(const struct timespec *now)
  {
-	struct xen_platform_op op;
-	int ret;
-
  	/* do nothing for domU */
  	if (!xen_initial_domain())
  		return -1;
 
-	/* Set the Xen wallclock. */
+	/* Set the hardware RTC. */

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 218

Quoted 10 lines
arch/x86/xen/time.c +10 -0
+	return mach_set_rtc_mmss(now);
+
+}
+
+static int xen_pvclock_gtod_notify(struct notifier_block *nb, unsigned long unused,
+				   void *priv)
+{
+	static struct timespec last, next;
+	struct timespec now;
+	struct timekeeper *tk = priv;

Noooo.. don't export the timekeeper like that.

Quoted 4 lines
arch/x86/xen/time.c +4 -0
+	struct xen_platform_op op;
+	int ret;
+
+	/*

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 232

Quoted 10 lines
arch/x86/xen/time.c +10 -0
+	 * Set the Xen wallclock from Linux system time.
+	 *
+	 * dom0 hasn't historically maintained a very accurate
+	 * wallclock so guests don't expect it. We can therefore
+	 * reduce the number of expensive hypercalls by only updating
+	 * the wallclock every 0.5 s.
+	 */
+
+	now.tv_sec = tk->xtime_sec;
+	now.tv_nsec = tk->xtime_nsec >> tk->shift;

You probably want current_kernel_time() here.

Quoted 12 lines
arch/x86/xen/time.c +7 -2
+
+	if (timespec_compare(&now, &last) > 0
+	    && timespec_compare(&now, &next) < 0)
+		return 0;
+
  	op.cmd = XENPF_settime;
-	op.u.settime.secs = now->tv_sec;
-	op.u.settime.nsecs = now->tv_nsec;
+	op.u.settime.secs = now.tv_sec;
+	op.u.settime.nsecs = now.tv_nsec;
  	op.u.settime.system_time = xen_clocksource_read();
 

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 249

Quoted 10 lines
arch/x86/xen/time.c +3 -3
  	ret = HYPERVISOR_dom0_op(&op);
  	if (ret)
-		return ret;
+		return 0;
 
-	/* Set the hardware RTC. */
-	return mach_set_rtc_mmss(now);
+	last = now;
+	next = timespec_add(now, ns_to_timespec(NSEC_PER_SEC / 2));
 

Am I missing the xen_set_wallclock hook here? Your previous patch wanted to call the dom0 op and then set the hardware RTC.

And this notifier get called every timer tick? This seems out there...

thanks
-john

#11 lore raw

Re: [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

Quoted 14 lines
Quoted 1 line
Quoted 1 line · John Stultz
Quoted 12 lines · David Vrabel
  	op.cmd = XENPF_settime;
arch/x86/xen/time.c +3 -3
-	op.u.settime.secs = now->tv_sec;
-	op.u.settime.nsecs = now->tv_nsec;
+	op.u.settime.secs = now.tv_sec;
+	op.u.settime.nsecs = now.tv_nsec;
  	op.u.settime.system_time = xen_clocksource_read();
 
  	ret = HYPERVISOR_dom0_op(&op);
  	if (ret)
-		return ret;
+		return 0;
Quoted 8 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 248

Quoted 5 lines
arch/x86/xen/time.c +2 -2
-	/* Set the hardware RTC. */
-	return mach_set_rtc_mmss(now);
+	last = now;
+	next = timespec_add(now, ns_to_timespec(NSEC_PER_SEC / 2));

Am I missing the xen_set_wallclock hook here? Your previous patch wanted to call the dom0 op and then set the hardware RTC.

That ought to be intentional: We should update the hypervisor's software wall clock here, but limit updating of the RTC to whenever a native kernel would do this (i.e. among other things subject to CONFIG_RTC_SYSTOHC).

Jan

#12 lore raw

Re: [Xen-devel] [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

In reply to John Stultz
Quoted 14 lines
Quoted 1 line
Quoted 1 line · John Stultz
Quoted 12 lines · David Vrabel
  	op.cmd = XENPF_settime;
arch/x86/xen/time.c +3 -3
-	op.u.settime.secs = now->tv_sec;
-	op.u.settime.nsecs = now->tv_nsec;
+	op.u.settime.secs = now.tv_sec;
+	op.u.settime.nsecs = now.tv_nsec;
  	op.u.settime.system_time = xen_clocksource_read();
 
  	ret = HYPERVISOR_dom0_op(&op);
  	if (ret)
-		return ret;
+		return 0;
Quoted 8 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 248

Quoted 5 lines
arch/x86/xen/time.c +2 -2
-	/* Set the hardware RTC. */
-	return mach_set_rtc_mmss(now);
+	last = now;
+	next = timespec_add(now, ns_to_timespec(NSEC_PER_SEC / 2));

Am I missing the xen_set_wallclock hook here? Your previous patch wanted to call the dom0 op and then set the hardware RTC.

That ought to be intentional: We should update the hypervisor's software wall clock here, but limit updating of the RTC to whenever a native kernel would do this (i.e. among other things subject to CONFIG_RTC_SYSTOHC).

Jan

#13 lore raw

Re: [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

In reply to John Stultz
Quoted 15 lines · John Stultz
Quoted 14 lines · David Vrabel

From: David Vrabel <[email protected]>

Currently the Xen wallclock is only updated every 11 minutes if NTP is synchronized to its clock source. If a guest is started before NTP is synchronized it may see an incorrect wallclock time.

Use the pvclock_gtod notifier chain to receive a notification when the system time has changed and update the wallclock to match.

This chain is called on every timer tick and we want to avoid an extra (expensive) hypercall on every tick. Because dom0 has historically never provided a very accurate wallclock and guests do not expect one, we can do this simply. The wallclock is only updated if the difference between now and the last update is more than 0.5 s.

[...]

Quoted 3 lines
Quoted 3 lines

index 4656165..81027b5 100644

arch/x86/xen/time.c +0 -0

[...]

Quoted 8 lines
Quoted 8 lines
arch/x86/xen/time.c +8 -0
+    struct xen_platform_op op;
+    int ret;
+
+    /*
+     * Set the Xen wallclock from Linux system time.
+     *
+     * dom0 hasn't historically maintained a very accurate
+     * wallclock so guests don't expect it. We can therefore
Quoted 8 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 232

Quoted 6 lines
arch/x86/xen/time.c +6 -0
+     * reduce the number of expensive hypercalls by only updating
+     * the wallclock every 0.5 s.
+     */
+
+    now.tv_sec = tk->xtime_sec;
+    now.tv_nsec = tk->xtime_nsec >> tk->shift;

You probably want current_kernel_time() here.

Ah. I was looking for something like this but since the notifier chain is called with various locks held stuff kept deadlocking. It looks like I can use __current_kernel_time() though.

Quoted 15 lines
Quoted 15 lines
arch/x86/xen/time.c +8 -3
+
+    if (timespec_compare(&now, &last) > 0
+        && timespec_compare(&now, &next) < 0)
+        return 0;
+
      op.cmd = XENPF_settime;
-    op.u.settime.secs = now->tv_sec;
-    op.u.settime.nsecs = now->tv_nsec;
+    op.u.settime.secs = now.tv_sec;
+    op.u.settime.nsecs = now.tv_nsec;
      op.u.settime.system_time = xen_clocksource_read();
        ret = HYPERVISOR_dom0_op(&op);
      if (ret)
-        return ret;
+        return 0;
Quoted 8 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 248

Quoted 5 lines

- /* Set the hardware RTC. */

arch/x86/xen/time.c +2 -1
-    return mach_set_rtc_mmss(now);
+    last = now;
+    next = timespec_add(now, ns_to_timespec(NSEC_PER_SEC / 2));

Am I missing the xen_set_wallclock hook here? Your previous patch wanted to call the dom0 op and then set the hardware RTC.

As Jan says, this is deliberate. We now update the hardware CMOS RTC in the same way as bare metal and then use this notifier to only maintain the Xen wallclock for guests.

Quoted 1 line

And this notifier get called every timer tick? This seems out there...

This notifier was added to support similar functionality for KVM and I'm just reusing what's there.

See e0b306fef (time: export time information for KVM pvclock) [1] and 16e8d74d2 (KVM: x86: notifier for clocksource changes) [2].

Perhaps Marcelo can comment on why it was necessary for this to be called on every timer tick.

David

[1]
https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=e0b306fef90556233797d2e1747bd6a3ae35ea93
[2]
https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=16e8d74d2da9920f874b10a3d979fb25c01f518f

#14 lore raw

Re: [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

In reply to John Stultz
Quoted 15 lines · John Stultz
Quoted 14 lines · David Vrabel

From: David Vrabel <[email protected]>

Currently the Xen wallclock is only updated every 11 minutes if NTP is synchronized to its clock source. If a guest is started before NTP is synchronized it may see an incorrect wallclock time.

Use the pvclock_gtod notifier chain to receive a notification when the system time has changed and update the wallclock to match.

This chain is called on every timer tick and we want to avoid an extra (expensive) hypercall on every tick. Because dom0 has historically never provided a very accurate wallclock and guests do not expect one, we can do this simply. The wallclock is only updated if the difference between now and the last update is more than 0.5 s.

[...]

Quoted 3 lines
Quoted 3 lines

index 4656165..81027b5 100644

arch/x86/xen/time.c +0 -0

[...]

Quoted 8 lines
Quoted 8 lines
arch/x86/xen/time.c +8 -0
+    struct xen_platform_op op;
+    int ret;
+
+    /*
+     * Set the Xen wallclock from Linux system time.
+     *
+     * dom0 hasn't historically maintained a very accurate
+     * wallclock so guests don't expect it. We can therefore
Quoted 8 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 232

Quoted 6 lines
arch/x86/xen/time.c +6 -0
+     * reduce the number of expensive hypercalls by only updating
+     * the wallclock every 0.5 s.
+     */
+
+    now.tv_sec = tk->xtime_sec;
+    now.tv_nsec = tk->xtime_nsec >> tk->shift;

You probably want current_kernel_time() here.

Ah. I was looking for something like this but since the notifier chain is called with various locks held stuff kept deadlocking. It looks like I can use __current_kernel_time() though.

Quoted 15 lines
Quoted 15 lines
arch/x86/xen/time.c +8 -3
+
+    if (timespec_compare(&now, &last) > 0
+        && timespec_compare(&now, &next) < 0)
+        return 0;
+
      op.cmd = XENPF_settime;
-    op.u.settime.secs = now->tv_sec;
-    op.u.settime.nsecs = now->tv_nsec;
+    op.u.settime.secs = now.tv_sec;
+    op.u.settime.nsecs = now.tv_nsec;
      op.u.settime.system_time = xen_clocksource_read();
        ret = HYPERVISOR_dom0_op(&op);
      if (ret)
-        return ret;
+        return 0;
Quoted 8 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 248

Quoted 5 lines

- /* Set the hardware RTC. */

arch/x86/xen/time.c +2 -1
-    return mach_set_rtc_mmss(now);
+    last = now;
+    next = timespec_add(now, ns_to_timespec(NSEC_PER_SEC / 2));

Am I missing the xen_set_wallclock hook here? Your previous patch wanted to call the dom0 op and then set the hardware RTC.

As Jan says, this is deliberate. We now update the hardware CMOS RTC in the same way as bare metal and then use this notifier to only maintain the Xen wallclock for guests.

Quoted 1 line

And this notifier get called every timer tick? This seems out there...

This notifier was added to support similar functionality for KVM and I'm just reusing what's there.

See e0b306fef (time: export time information for KVM pvclock) [1] and 16e8d74d2 (KVM: x86: notifier for clocksource changes) [2].

Perhaps Marcelo can comment on why it was necessary for this to be called on every timer tick.

David

[1]
https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=e0b306fef90556233797d2e1747bd6a3ae35ea93
[2]
https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=16e8d74d2da9920f874b10a3d979fb25c01f518f

#15 lore raw

Re: [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

Quoted 72 lines · David Vrabel
Quoted 15 lines · John Stultz
Quoted 14 lines · David Vrabel

From: David Vrabel <[email protected]>

Currently the Xen wallclock is only updated every 11 minutes if NTP is synchronized to its clock source. If a guest is started before NTP is synchronized it may see an incorrect wallclock time.

Use the pvclock_gtod notifier chain to receive a notification when the system time has changed and update the wallclock to match.

This chain is called on every timer tick and we want to avoid an extra (expensive) hypercall on every tick. Because dom0 has historically never provided a very accurate wallclock and guests do not expect one, we can do this simply. The wallclock is only updated if the difference between now and the last update is more than 0.5 s.

[...]

Quoted 3 lines
Quoted 3 lines

index 4656165..81027b5 100644

arch/x86/xen/time.c +0 -0

[...]

Quoted 8 lines
Quoted 8 lines
arch/x86/xen/time.c +8 -0
+    struct xen_platform_op op;
+    int ret;
+
+    /*
+     * Set the Xen wallclock from Linux system time.
+     *
+     * dom0 hasn't historically maintained a very accurate
+     * wallclock so guests don't expect it. We can therefore
Quoted 8 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 232

Quoted 6 lines
arch/x86/xen/time.c +6 -0
+     * reduce the number of expensive hypercalls by only updating
+     * the wallclock every 0.5 s.
+     */
+
+    now.tv_sec = tk->xtime_sec;
+    now.tv_nsec = tk->xtime_nsec >> tk->shift;

You probably want current_kernel_time() here.

Ah. I was looking for something like this but since the notifier chain is called with various locks held stuff kept deadlocking. It looks like I can use __current_kernel_time() though.

Quoted 15 lines
Quoted 15 lines
arch/x86/xen/time.c +7 -3
+
 +    if (timespec_compare(&now, &last) > 0
+        && timespec_compare(&now, &next) < 0)
+        return 0;
+
      op.cmd = XENPF_settime;
-    op.u.settime.secs = now->tv_sec;
-    op.u.settime.nsecs = now->tv_nsec;
+    op.u.settime.secs = now.tv_sec;
+    op.u.settime.nsecs = now.tv_nsec;
      op.u.settime.system_time = xen_clocksource_read();
        ret = HYPERVISOR_dom0_op(&op);
      if (ret)
-        return ret;
+        return 0;
Quoted 8 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 248

Quoted 5 lines

- /* Set the hardware RTC. */

arch/x86/xen/time.c +2 -1
-    return mach_set_rtc_mmss(now);
+    last = now;
+    next = timespec_add(now, ns_to_timespec(NSEC_PER_SEC / 2));

Am I missing the xen_set_wallclock hook here? Your previous patch wanted to call the dom0 op and then set the hardware RTC.

As Jan says, this is deliberate. We now update the hardware CMOS RTC in the same way as bare metal and then use this notifier to only maintain the Xen wallclock for guests.

Quoted 1 line

And this notifier get called every timer tick? This seems out there...

Quoted 8 lines

This notifier was added to support similar functionality for KVM and I'm just reusing what's there.

See e0b306fef (time: export time information for KVM pvclock) [1] and 16e8d74d2 (KVM: x86: notifier for clocksource changes) [2].

Perhaps Marcelo can comment on why it was necessary for this to be called on every timer tick.

Just so to maintain similarity with the vsyscall notifier (as in updates all fields the vsyscall notifier uses).

KVM only actually makes use of the clocksource change case.

#16 lore raw

Re: [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

In reply to David Vrabel
Quoted 72 lines · David Vrabel
Quoted 15 lines · John Stultz
Quoted 14 lines · David Vrabel

From: David Vrabel <[email protected]>

Currently the Xen wallclock is only updated every 11 minutes if NTP is synchronized to its clock source. If a guest is started before NTP is synchronized it may see an incorrect wallclock time.

Use the pvclock_gtod notifier chain to receive a notification when the system time has changed and update the wallclock to match.

This chain is called on every timer tick and we want to avoid an extra (expensive) hypercall on every tick. Because dom0 has historically never provided a very accurate wallclock and guests do not expect one, we can do this simply. The wallclock is only updated if the difference between now and the last update is more than 0.5 s.

[...]

Quoted 3 lines
Quoted 3 lines

index 4656165..81027b5 100644

arch/x86/xen/time.c +0 -0

[...]

Quoted 8 lines
Quoted 8 lines
arch/x86/xen/time.c +8 -0
+    struct xen_platform_op op;
+    int ret;
+
+    /*
+     * Set the Xen wallclock from Linux system time.
+     *
+     * dom0 hasn't historically maintained a very accurate
+     * wallclock so guests don't expect it. We can therefore
Quoted 8 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 232

Quoted 6 lines
arch/x86/xen/time.c +6 -0
+     * reduce the number of expensive hypercalls by only updating
+     * the wallclock every 0.5 s.
+     */
+
+    now.tv_sec = tk->xtime_sec;
+    now.tv_nsec = tk->xtime_nsec >> tk->shift;

You probably want current_kernel_time() here.

Ah. I was looking for something like this but since the notifier chain is called with various locks held stuff kept deadlocking. It looks like I can use __current_kernel_time() though.

Quoted 15 lines
Quoted 15 lines
arch/x86/xen/time.c +7 -3
+
 +    if (timespec_compare(&now, &last) > 0
+        && timespec_compare(&now, &next) < 0)
+        return 0;
+
      op.cmd = XENPF_settime;
-    op.u.settime.secs = now->tv_sec;
-    op.u.settime.nsecs = now->tv_nsec;
+    op.u.settime.secs = now.tv_sec;
+    op.u.settime.nsecs = now.tv_nsec;
      op.u.settime.system_time = xen_clocksource_read();
        ret = HYPERVISOR_dom0_op(&op);
      if (ret)
-        return ret;
+        return 0;
Quoted 8 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 248

Quoted 5 lines

- /* Set the hardware RTC. */

arch/x86/xen/time.c +2 -1
-    return mach_set_rtc_mmss(now);
+    last = now;
+    next = timespec_add(now, ns_to_timespec(NSEC_PER_SEC / 2));

Am I missing the xen_set_wallclock hook here? Your previous patch wanted to call the dom0 op and then set the hardware RTC.

As Jan says, this is deliberate. We now update the hardware CMOS RTC in the same way as bare metal and then use this notifier to only maintain the Xen wallclock for guests.

Quoted 1 line

And this notifier get called every timer tick? This seems out there...

Quoted 8 lines

This notifier was added to support similar functionality for KVM and I'm just reusing what's there.

See e0b306fef (time: export time information for KVM pvclock) [1] and 16e8d74d2 (KVM: x86: notifier for clocksource changes) [2].

Perhaps Marcelo can comment on why it was necessary for this to be called on every timer tick.

Just so to maintain similarity with the vsyscall notifier (as in updates all fields the vsyscall notifier uses).

KVM only actually makes use of the clocksource change case.

#17 lore raw

Re: [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

In reply to David Vrabel
Quoted 14 lines
Quoted 1 line
Quoted 1 line · David Vrabel
arch/x86/xen/time.c +13 -0
+static int xen_pvclock_gtod_notify(struct notifier_block *nb, unsigned long unused,
+				   void *priv)
+{
+	static struct timespec last, next;
+	struct timespec now;
+	struct timekeeper *tk = priv;
+	struct xen_platform_op op;
+	int ret;
+
+	/*
+	 * Set the Xen wallclock from Linux system time.
+	 *
+	 * dom0 hasn't historically maintained a very accurate

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 235

Quoted 10 lines
arch/x86/xen/time.c +10 -0
+	 * wallclock so guests don't expect it. We can therefore
+	 * reduce the number of expensive hypercalls by only updating
+	 * the wallclock every 0.5 s.
+	 */
+
+	now.tv_sec = tk->xtime_sec;
+	now.tv_nsec = tk->xtime_nsec >> tk->shift;
+
+	if (timespec_compare(&now, &last) > 0
+	    && timespec_compare(&now, &next) < 0)

Is this really working the first time through (when both last and next are still all zeros)?

Jan

Quoted 21 lines
arch/x86/xen/time.c +8 -5
+		return 0;
+
 	op.cmd = XENPF_settime;
-	op.u.settime.secs = now->tv_sec;
-	op.u.settime.nsecs = now->tv_nsec;
+	op.u.settime.secs = now.tv_sec;
+	op.u.settime.nsecs = now.tv_nsec;
 	op.u.settime.system_time = xen_clocksource_read();
 
 	ret = HYPERVISOR_dom0_op(&op);
 	if (ret)
-		return ret;
+		return 0;
 
-	/* Set the hardware RTC. */
-	return mach_set_rtc_mmss(now);
+	last = now;
+	next = timespec_add(now, ns_to_timespec(NSEC_PER_SEC / 2));
 
+	return 0;
 }
#18 lore raw

Re: [Xen-devel] [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

In reply to David Vrabel
Quoted 14 lines
Quoted 1 line
Quoted 1 line · David Vrabel
arch/x86/xen/time.c +13 -0
+static int xen_pvclock_gtod_notify(struct notifier_block *nb, unsigned long unused,
+				   void *priv)
+{
+	static struct timespec last, next;
+	struct timespec now;
+	struct timekeeper *tk = priv;
+	struct xen_platform_op op;
+	int ret;
+
+	/*
+	 * Set the Xen wallclock from Linux system time.
+	 *
+	 * dom0 hasn't historically maintained a very accurate

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 235

Quoted 10 lines
arch/x86/xen/time.c +10 -0
+	 * wallclock so guests don't expect it. We can therefore
+	 * reduce the number of expensive hypercalls by only updating
+	 * the wallclock every 0.5 s.
+	 */
+
+	now.tv_sec = tk->xtime_sec;
+	now.tv_nsec = tk->xtime_nsec >> tk->shift;
+
+	if (timespec_compare(&now, &last) > 0
+	    && timespec_compare(&now, &next) < 0)

Is this really working the first time through (when both last and next are still all zeros)?

Jan

Quoted 21 lines
arch/x86/xen/time.c +8 -5
+		return 0;
+
 	op.cmd = XENPF_settime;
-	op.u.settime.secs = now->tv_sec;
-	op.u.settime.nsecs = now->tv_nsec;
+	op.u.settime.secs = now.tv_sec;
+	op.u.settime.nsecs = now.tv_nsec;
 	op.u.settime.system_time = xen_clocksource_read();
 
 	ret = HYPERVISOR_dom0_op(&op);
 	if (ret)
-		return ret;
+		return 0;
 
-	/* Set the hardware RTC. */
-	return mach_set_rtc_mmss(now);
+	last = now;
+	next = timespec_add(now, ns_to_timespec(NSEC_PER_SEC / 2));
 
+	return 0;
 }
#19 lore raw

Re: [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

Quoted 19 lines · Jan Beulich
Quoted 19 lines
Quoted 1 line
Quoted 1 line · David Vrabel
arch/x86/xen/time.c +18 -0
+static int xen_pvclock_gtod_notify(struct notifier_block *nb, unsigned long unused,
+				   void *priv)
+{
+	static struct timespec last, next;
+	struct timespec now;
+	struct timekeeper *tk = priv;
+	struct xen_platform_op op;
+	int ret;
+
+	/*
+	 * Set the Xen wallclock from Linux system time.
+	 *
+	 * dom0 hasn't historically maintained a very accurate
+	 * wallclock so guests don't expect it. We can therefore
+	 * reduce the number of expensive hypercalls by only updating
+	 * the wallclock every 0.5 s.
+	 */
+
Quoted 8 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 235

Quoted 5 lines
arch/x86/xen/time.c +5 -0
+	now.tv_sec = tk->xtime_sec;
+	now.tv_nsec = tk->xtime_nsec >> tk->shift;
+
+	if (timespec_compare(&now, &last) > 0
+	    && timespec_compare(&now, &next) < 0)

Is this really working the first time through (when both last and next are still all zeros)?

Yes. The first time through we want to set the wallclock and this test is always false when last == next.

David

#20 lore raw

Re: [Xen-devel] [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

In reply to Jan Beulich
Quoted 19 lines · Jan Beulich
Quoted 19 lines
Quoted 1 line
Quoted 1 line · David Vrabel
arch/x86/xen/time.c +18 -0
+static int xen_pvclock_gtod_notify(struct notifier_block *nb, unsigned long unused,
+				   void *priv)
+{
+	static struct timespec last, next;
+	struct timespec now;
+	struct timekeeper *tk = priv;
+	struct xen_platform_op op;
+	int ret;
+
+	/*
+	 * Set the Xen wallclock from Linux system time.
+	 *
+	 * dom0 hasn't historically maintained a very accurate
+	 * wallclock so guests don't expect it. We can therefore
+	 * reduce the number of expensive hypercalls by only updating
+	 * the wallclock every 0.5 s.
+	 */
+
Quoted 8 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 235

Quoted 5 lines
arch/x86/xen/time.c +5 -0
+	now.tv_sec = tk->xtime_sec;
+	now.tv_nsec = tk->xtime_nsec >> tk->shift;
+
+	if (timespec_compare(&now, &last) > 0
+	    && timespec_compare(&now, &next) < 0)

Is this really working the first time through (when both last and next are still all zeros)?

Yes. The first time through we want to set the wallclock and this test is always false when last == next.

David

#21 lore raw

Re: [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

In reply to David Vrabel
Quoted 7 lines
Quoted 1 line
Quoted 1 line · David Vrabel
arch/x86/xen/time.c +0 -2
@@ -199,28 +201,59 @@ static void xen_get_wallclock(struct timespec *now)
 
 static int xen_set_wallclock(const struct timespec *now)
 {
-	struct xen_platform_op op;
-	int ret;

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 211

Quoted 10 lines
arch/x86/xen/time.c +4 -2
-
 	/* do nothing for domU */
 	if (!xen_initial_domain())
 		return -1;
 
-	/* Set the Xen wallclock. */
+	/* Set the hardware RTC. */
+	return mach_set_rtc_mmss(now);
+
+}

Can't you achieve the same effect in a cleaner way by overriding x86_platform.set_wallclock only in the non-init-domain case?

Jan

#22 lore raw

Re: [Xen-devel] [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

In reply to David Vrabel
Quoted 7 lines
Quoted 1 line
Quoted 1 line · David Vrabel
arch/x86/xen/time.c +0 -2
@@ -199,28 +201,59 @@ static void xen_get_wallclock(struct timespec *now)
 
 static int xen_set_wallclock(const struct timespec *now)
 {
-	struct xen_platform_op op;
-	int ret;

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 211

Quoted 10 lines
arch/x86/xen/time.c +4 -2
-
 	/* do nothing for domU */
 	if (!xen_initial_domain())
 		return -1;
 
-	/* Set the Xen wallclock. */
+	/* Set the hardware RTC. */
+	return mach_set_rtc_mmss(now);
+
+}

Can't you achieve the same effect in a cleaner way by overriding x86_platform.set_wallclock only in the non-init-domain case?

Jan

#23 lore raw

Re: [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

Quoted 12 lines · Jan Beulich
Quoted 12 lines
Quoted 1 line
Quoted 1 line · David Vrabel
arch/x86/xen/time.c +0 -3
@@ -199,28 +201,59 @@ static void xen_get_wallclock(struct timespec *now)
 
 static int xen_set_wallclock(const struct timespec *now)
 {
-	struct xen_platform_op op;
-	int ret;
-
 	/* do nothing for domU */
 	if (!xen_initial_domain())
 		return -1;
 
Quoted 8 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 211

Quoted 5 lines
arch/x86/xen/time.c +4 -1
-	/* Set the Xen wallclock. */
+	/* Set the hardware RTC. */
+	return mach_set_rtc_mmss(now);
+
+}

Can't you achieve the same effect in a cleaner way by overriding x86_platform.set_wallclock only in the non-init-domain case?

Yes, that makes sense. John, don't apply this one yet, thanks.

David

#24 lore raw

Re: [Xen-devel] [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

In reply to Jan Beulich
Quoted 12 lines · Jan Beulich
Quoted 12 lines
Quoted 1 line
Quoted 1 line · David Vrabel
arch/x86/xen/time.c +0 -3
@@ -199,28 +201,59 @@ static void xen_get_wallclock(struct timespec *now)
 
 static int xen_set_wallclock(const struct timespec *now)
 {
-	struct xen_platform_op op;
-	int ret;
-
 	/* do nothing for domU */
 	if (!xen_initial_domain())
 		return -1;
 
Quoted 8 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 211

Quoted 5 lines
arch/x86/xen/time.c +4 -1
-	/* Set the Xen wallclock. */
+	/* Set the hardware RTC. */
+	return mach_set_rtc_mmss(now);
+
+}

Can't you achieve the same effect in a cleaner way by overriding x86_platform.set_wallclock only in the non-init-domain case?

Yes, that makes sense. John, don't apply this one yet, thanks.

David

#25 lore raw

Re: [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

Quoted 13 lines · David Vrabel
Quoted 12 lines · Jan Beulich
Quoted 12 lines
Quoted 1 line
Quoted 1 line · David Vrabel
arch/x86/xen/time.c +0 -3
@@ -199,28 +201,59 @@ static void xen_get_wallclock(struct timespec *now)
 
  static int xen_set_wallclock(const struct timespec *now)
  {
-	struct xen_platform_op op;
-	int ret;
-
  	/* do nothing for domU */
  	if (!xen_initial_domain())
  		return -1;
 
Quoted 8 lines
Quoted 7 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 211

Quoted 5 lines
arch/x86/xen/time.c +4 -1
-	/* Set the Xen wallclock. */
+	/* Set the hardware RTC. */
+	return mach_set_rtc_mmss(now);
+
+}

Can't you achieve the same effect in a cleaner way by overriding x86_platform.set_wallclock only in the non-init-domain case?

Yes, that makes sense. John, don't apply this one yet, thanks.

Ok. Zapped from my tree.

thanks
-john

#26 lore raw

Re: [Xen-devel] [PATCH 2/2] x86/xen: sync the wallclock when the system time changes

In reply to David Vrabel
Quoted 13 lines · David Vrabel
Quoted 12 lines · Jan Beulich
Quoted 12 lines
Quoted 1 line
Quoted 1 line · David Vrabel
arch/x86/xen/time.c +0 -3
@@ -199,28 +201,59 @@ static void xen_get_wallclock(struct timespec *now)
 
  static int xen_set_wallclock(const struct timespec *now)
  {
-	struct xen_platform_op op;
-	int ret;
-
  	/* do nothing for domU */
  	if (!xen_initial_domain())
  		return -1;
 
Quoted 8 lines
Quoted 7 lines

arch/x86/xen/time.c static void xen_get_wallclock(struct timespec *now) · line 211

Quoted 5 lines
arch/x86/xen/time.c +4 -1
-	/* Set the Xen wallclock. */
+	/* Set the hardware RTC. */
+	return mach_set_rtc_mmss(now);
+
+}

Can't you achieve the same effect in a cleaner way by overriding x86_platform.set_wallclock only in the non-init-domain case?

Yes, that makes sense. John, don't apply this one yet, thanks.

Ok. Zapped from my tree.

thanks
-john