 @@ -1,14 +1,14 @@
-/*	$NetBSD: clock.c,v 1.54.6.4 2011/09/18 18:54:32 cherry Exp $	*/
+/*	$NetBSD: clock.c,v 1.54.6.5 2011/10/22 19:26:16 bouyer Exp $	*/
 /*
+ *
  * Copyright (c) 2004 Christian Limpach.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
 @@ -19,27 +19,27 @@
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include "opt_xen.h"
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: clock.c,v 1.54.6.4 2011/09/18 18:54:32 cherry Exp $");
+__KERNEL_RCSID(0, "$NetBSD: clock.c,v 1.54.6.5 2011/10/22 19:26:16 bouyer Exp $");
 #include <sys/param.h>
 #include <sys/cpu.h>
 #include <sys/systm.h>
 #include <sys/time.h>
 #include <sys/timetc.h>
 #include <sys/timevar.h>
 #include <sys/kernel.h>
 #include <sys/mutex.h>
 #include <sys/device.h>
 #include <sys/sysctl.h>
 #include <xen/xen.h>
 @@ -84,27 +84,27 @@ static volatile struct shadow ci_shadow[
 static kmutex_t tmutex; /* Protects volatile variables, below */
 /* The time when the last hardclock(9) call should have taken place,
  * per cpu.
  */
 static volatile uint64_t vcpu_system_time[MAXCPUS];
 /*
  * The clock (as returned by xen_get_timecount) may need to be held
  * back to maintain the illusion that hardclock(9) was called when it
  * was supposed to be, not when Xen got around to scheduling us.
  */
-static volatile uint64_t xen_clock_bias;
+static volatile uint64_t xen_clock_bias[MAXCPUS];
 #ifdef DOM0OPS
 /* If we're dom0, send our time to Xen every minute or so. */
 int xen_timepush_ticks = 0;
 static callout_t xen_timepush_co;
 #endif
 #define NS_PER_TICK (1000000000ULL/hz)
 /*
  * Reads a consistent set of time-base values from Xen, into a shadow data
  * area.  Must be called at splhigh (per timecounter requirements).
  */
 @@ -406,84 +406,90 @@ sysctl_xen_timepush(SYSCTLFN_ARGS)
 			callout_stop(&xen_timepush_co);
+	}
 	return 0;
+}
 #endif
 /* ARGSUSED */
 /* SMP note: Timecounter uses vcpu0's clock */
 u_int
 xen_get_timecount(struct timecounter *tc)
+{
 	uint64_t ns;
 	struct cpu_info *ci = curcpu();
 	mutex_enter(&tmutex);
-	ns = get_system_time() - xen_clock_bias;
+	ns = get_vcpu_time(ci) - xen_clock_bias[ci->ci_cpuid];
 	mutex_exit(&tmutex);
 	return (u_int)ns;
+}
 /*
  * Needs to be called per-cpu, from the local cpu, since VIRQ_TIMER is
  * bound per-cpu
  */
 static struct evcnt hardclock_called[MAXCPUS];
 void
 xen_initclocks(void)
+{
 	int err, evtch;
 	static bool tcdone = false;
 	struct vcpu_set_periodic_timer hardclock_period = { NS_PER_TICK };
 	struct cpu_info *ci = curcpu();
 	volatile struct shadow *shadow = &ci_shadow[ci->ci_cpuid];
-	xen_clock_bias = 0;
+	xen_clock_bias[ci->ci_cpuid] = 0;
 	evcnt_attach_dynamic(&hardclock_called[ci->ci_cpuid],
 			     EVCNT_TYPE_INTR,
 			     NULL,
 			     device_xname(ci->ci_dev),
 			     "hardclock");
 #ifdef DOM0OPS
 	if (!tcdone) { /* Do this only once */
 		callout_init(&xen_timepush_co, 0);
+	}
 #endif
 	evtch = bind_virq_to_evtch(VIRQ_TIMER);
 	aprint_verbose("Xen clock: using event channel %d\n", evtch);
 	get_time_values_from_xen(ci);
 	vcpu_system_time[ci->ci_cpuid] = shadow->system_time;
 	if (!tcdone) { /* Do this only once */
 		mutex_init(&tmutex, MUTEX_DEFAULT, IPL_CLOCK);
 		tc_init(&xen_timecounter);
+	}
 	/* The splhigh requirements start here. */
-	/* Set hardclock() frequency */
+	/*
-	err = HYPERVISOR_vcpu_op(VCPUOP_set_periodic_timer,
+	 * The periodic timer looks buggy, we stop receiving events
 	 * after a while. Use the one-shot timer every NS_PER_TICK
 	 * and rearm it from the event handler.
 	 */
 	err = HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer,
 				 ci->ci_cpuid,
-				 &hardclock_period);
+				 NULL);
 	KASSERT(err == 0);
 	err = HYPERVISOR_set_timer_op(
 	    vcpu_system_time[ci->ci_cpuid] + NS_PER_TICK);
 	KASSERT(err == 0);
 	event_set_handler(evtch, (int (*)(void *))xen_timer_handler,
 	    ci, IPL_CLOCK, "clock");
 	hypervisor_enable_event(evtch);
 #ifdef DOM0OPS
 	if (!tcdone) { /* Do this only once */
 		xen_timepush_ticks = 53 * hz + 3; /* avoid exact # of min/sec */
 		if (xendomain_is_privileged()) {
 			sysctl_createv(NULL, 0, NULL, NULL, CTLFLAG_READWRITE,
 			    CTLTYPE_INT, "xen_timepush_ticks", SYSCTL_DESCR("How often"
 			     " to update the hypervisor's time-of-day; 0 to disable"),
 @@ -494,49 +500,70 @@ xen_initclocks(void)
+		}
+	}
 #endif
 	tcdone = true;
+}
 /* ARGSUSED */
 static int
 xen_timer_handler(void *arg, struct intrframe *regs)
+{
 	int64_t delta;
 	struct cpu_info *ci = curcpu();
 	KASSERT(arg == ci);
 	int err;
 again:
 	mutex_enter(&tmutex);
 	delta = (int64_t)(get_vcpu_time(ci) - vcpu_system_time[ci->ci_cpuid]);
 	mutex_exit(&tmutex);
 	/* Several ticks may have passed without our being run; catch up. */
 	while (delta >= (int64_t)NS_PER_TICK) {
 		mutex_enter(&tmutex);
 		vcpu_system_time[ci->ci_cpuid] += NS_PER_TICK;
-		xen_clock_bias = (delta -= NS_PER_TICK);
+		xen_clock_bias[ci->ci_cpuid] = (delta -= NS_PER_TICK);
 		mutex_exit(&tmutex);
 		hardclock((struct clockframe *)regs);
 		hardclock_called[ci->ci_cpuid].ev_count++;
+	}
 	/*
 	 * rearm the timer. If it fails it's probably because the date
 	 * is in the past, update our local time and try again.
 	 */
 	err = HYPERVISOR_set_timer_op(
 	    vcpu_system_time[ci->ci_cpuid] + NS_PER_TICK);
 	if (err)
 		goto again;
-	if (xen_clock_bias) {
+	if (xen_clock_bias[ci->ci_cpuid]) {
 		mutex_enter(&tmutex);
-		xen_clock_bias = 0;
+		xen_clock_bias[ci->ci_cpuid] = 0;
 		mutex_exit(&tmutex);
+	}
 	return 0;
+}
 void
 setstatclockrate(int arg)
+{
+}
 void
 idle_block(void)
+{
 #ifdef MULTIPROCESSOR
 	HYPERVISOR_yield();
 	__sti();
 #else
 	struct cpu_info *ci = curcpu();
 	int r;
 	r = HYPERVISOR_set_timer_op(
 	    vcpu_system_time[ci->ci_cpuid] + NS_PER_TICK);
 	if (r == 0)
 		HYPERVISOR_block();
 	else
 		__sti();
 #endif
+}