linux 2.6.18: time handling

Remove struct timer_opts left-overs, add a Xen clocksource, and adjust conditionals for x86-64.

Index: head-2007-02-27/arch/i386/Kconfig
===================================================================
@@ -16,7 +16,6 @@ config X86_32
 
 config GENERIC_TIME
 	bool
-	depends on !X86_XEN
 	default y
 
 config LOCKDEP_SUPPORT

Index: head-2007-02-27/arch/i386/kernel/Makefile
===================================================================
@@ -93,7 +93,7 @@ include $(srctree)/scripts/Makefile.xen
 
 obj-y += fixup.o
 microcode-$(subst m,y,$(CONFIG_MICROCODE)) := microcode-xen.o
-n-obj-xen := i8259.o timers/ reboot.o smpboot.o trampoline.o
+n-obj-xen := i8259.o reboot.o smpboot.o trampoline.o tsc.o
 
 obj-y := $(call filterxen, $(obj-y), $(n-obj-xen))
 obj-y := $(call cherrypickxen, $(obj-y))

Index: head-2007-02-27/include/asm-i386/mach-xen/asm/processor.h
===================================================================
@@ -23,7 +23,7 @@
 #include <xen/interface/physdev.h>
 
 /* flag for disabling the tsc */
-extern int tsc_disable;
+#define tsc_disable 0
 
 struct desc_struct {
 	unsigned long a,b;

There doesn't seem to be much advantage to this (we're already very diverged from native i386 time handling) and the disadvantages are a bigger diff versus what we need for x86/64 (hence more ifdefs) and independent_wallclock probably stops working.

This is all solvable I'm sure, particularly if clocksources are the way of the future (e.g., is x86/64 native going to use generic_time any time soon)?

-- Keir

We didn't notice any malfunction in time handling so far (which included the released SuSE 10.2) - how would you expect such a problem to surface?

Jan

For example, settimeofday() will not be ignored for ordinary domUs. Also settimeofday() calls in dom0 will not immediately propagate their effect to other domains (but should happen during the once-per-minute wallclock propagation to Xen). Small-ish but potentially annoying issues.

-- Keir

The other issue afaics is that the clocksource simply does raw reads of the TSC, subsequently scaled by cpu_khz. This isn't very accurate and will cause horrible problems if some CPUs enter power-saving modes (not explicitly supported yet, but can happen due to auto thermal throttling) or on bigger systems where TSCs may not be driven from the same mainboard clock (and hence will drift).

I think Jeremy Fitzhardinge has an alternative clocksource patch which iirc is more in line with how Xen time works (should advertise a GHz frequency clocksource, and do scaling of the TSC value according to time-record values read from shared_info). Having thought about this some more I think clocksource support is worth getting into our tree, but let's look at both available patches and decide which is the better basis for further work.

Jeremy: If I'm not mistaken and you do have a patch floating around, could you post it?

Thanks,
Keir

Yes, there's a Xen clocksource in the pv_ops tree. There's no nicely separable patch, but the mechanism is pretty simple. I've attached arch/i386/xen/time.c

J

#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/kernel_stat.h>
#include <linux/clocksource.h>

#include <asm/xen/hypercall.h>
#include <asm/arch_hooks.h>

#include <xen/events.h>
#include <xen/interface/xen.h>
#include <xen/interface/vcpu.h>

#include "xen-ops.h"

#define XEN_SHIFT 22

/* Permitted clock jitter, in nsecs, beyond which a warning will be printed. */ static unsigned long permitted_clock_jitter = 10000000UL; /* 10ms */ static int __init __permitted_clock_jitter(char *str)

{
	permitted_clock_jitter = simple_strtoul(str, NULL, 0);
	return 1;
}

__setup("permitted_clock_jitter=", __permitted_clock_jitter);

/* These are perodically updated in shared_info, and then copied here. */

struct shadow_time_info {
	u64 tsc_timestamp;     /* TSC at last update of time vals.  */
	u64 system_timestamp;  /* Time, in nanosecs, since boot.    */
	u32 tsc_to_nsec_mul;
	int tsc_shift;
	u32 version;
};

static DEFINE_PER_CPU(struct shadow_time_info, shadow_time);

/* Keep track of last time we did processing/updating of jiffies and xtime. */
static u64 processed_system_time; /* System time (ns) at last processing. */
static DEFINE_PER_CPU(u64, processed_system_time);

/* How much CPU time was spent blocked and how much was 'stolen'? */ static DEFINE_PER_CPU(u64, processed_stolen_time);
static DEFINE_PER_CPU(u64, processed_blocked_time);

/* Current runstate of each CPU (updated automatically by the hypervisor). */ static DEFINE_PER_CPU(struct vcpu_runstate_info, runstate);

/* Must be signed, as it's compared with s64 quantities which can be -ve. */ #define NS_PER_TICK (1000000000LL/HZ)

unsigned long xen_cpu_khz(void)

{
	u64 cpu_khz = 1000000ULL << 32;
	const struct vcpu_time_info *info =
		&HYPERVISOR_shared_info->vcpu_info[0].time;

	do_div(cpu_khz, info->tsc_to_system_mul);
	if (info->tsc_shift < 0)
		cpu_khz <<= -info->tsc_shift;
	else
		cpu_khz >>= info->tsc_shift;

	return cpu_khz;
}

/*
* Reads a consistent set of time-base values from Xen, into a shadow data
* area.
*/
static void get_time_values_from_xen(void)

{
	struct vcpu_time_info   *src;
	struct shadow_time_info *dst;

	src = &read_pda(xen.vcpu)->time;
	dst = &get_cpu_var(shadow_time);

	do {
		dst->version = src->version;
		rmb();
		dst->tsc_timestamp     = src->tsc_timestamp;
		dst->system_timestamp  = src->system_time;
		dst->tsc_to_nsec_mul   = src->tsc_to_system_mul;
		dst->tsc_shift         = src->tsc_shift;
		rmb();
	} while ((src->version & 1) | (dst->version ^ src->version));

	put_cpu_var(shadow_time);
}

static inline int time_values_up_to_date(void)

{
	struct vcpu_time_info   *src;
	unsigned dstversion;

	src = &read_pda(xen.vcpu)->time;
	dstversion = get_cpu_var(shadow_time).version;
	put_cpu_var(shadow_time);

	rmb();
	return (dstversion == src->version);
}

/*
* Scale a 64-bit delta by scaling and multiplying by a 32-bit fraction,
* yielding a 64-bit result.
*/
static inline u64 scale_delta(u64 delta, u32 mul_frac, int shift)

{
	u64 product;
#ifdef __i386__
	u32 tmp1, tmp2;

#endif

	if (shift < 0)
		delta >>= -shift;
	else
		delta <<= shift;

#ifdef __i386__
	__asm__ (
		"mul  %5       ; "
		"mov  %4,%%eax ; "
		"mov  %%edx,%4 ; "
		"mul  %5       ; "
		"xor  %5,%5    ; "
		"add  %4,%%eax ; "
		"adc  %5,%%edx ; "
		: "=A" (product), "=r" (tmp1), "=r" (tmp2)
		: "a" ((u32)delta), "1" ((u32)(delta >> 32)), "2" (mul_frac) );
#elif __x86_64__
	__asm__ (
		"mul %%rdx ; shrd $32,%%rdx,%%rax"
		: "=a" (product) : "0" (delta), "d" ((u64)mul_frac) );

#else
#error implement me!
#endif

	return product;
}

static u64 get_nsec_offset(struct shadow_time_info *shadow)

{
	u64 now, delta;
	rdtscll(now);
	delta = now - shadow->tsc_timestamp;
	return scale_delta(delta, shadow->tsc_to_nsec_mul, shadow->tsc_shift);
}

static void xen_timer_interrupt_hook(void)

{
	s64 delta, delta_cpu, stolen, blocked;
	u64 sched_time;
	int i, cpu = smp_processor_id();
	unsigned long ticks;
	struct shadow_time_info *shadow = &__get_cpu_var(shadow_time);
	struct vcpu_runstate_info *runstate = &__get_cpu_var(runstate);

	do {
		get_time_values_from_xen();

		/* Obtain a consistent snapshot of elapsed wallclock cycles. */
		delta = delta_cpu =
			shadow->system_timestamp + get_nsec_offset(shadow);
		if (0)
			printk("tsc_timestamp=%llu system_timestamp=%llu tsc_to_nsec=%u tsc_shift=%d, version=%u, delta=%lld processed_system_time=%lld\n",
			       shadow->tsc_timestamp, shadow->system_timestamp,
			       shadow->tsc_to_nsec_mul, shadow->tsc_shift,
			       shadow->version, delta, processed_system_time);

		delta     -= processed_system_time;
		delta_cpu -= __get_cpu_var(processed_system_time);

		/*
		 * Obtain a consistent snapshot of stolen/blocked cycles. We
		 * can use state_entry_time to detect if we get preempted here.
		 */
		do {
			sched_time = runstate->state_entry_time;
			barrier();
			stolen = runstate->time[RUNSTATE_runnable] +
				runstate->time[RUNSTATE_offline] -
				__get_cpu_var(processed_stolen_time);
			blocked = runstate->time[RUNSTATE_blocked] -
				__get_cpu_var(processed_blocked_time);
			barrier();
		} while (sched_time != runstate->state_entry_time);
	} while (!time_values_up_to_date());

	if ((unlikely(delta < -(s64)permitted_clock_jitter) ||
	     unlikely(delta_cpu < -(s64)permitted_clock_jitter))
	    && printk_ratelimit()) {
		printk("Timer ISR/%d: Time went backwards: "
		       "delta=%lld delta_cpu=%lld shadow=%lld "
		       "off=%lld processed=%lld cpu_processed=%lld\n",
		       cpu, delta, delta_cpu, shadow->system_timestamp,
		       (s64)get_nsec_offset(shadow),
		       processed_system_time,
		       __get_cpu_var(processed_system_time));
		for (i = 0; i < num_online_cpus(); i++)
			printk(" %d: %lld\n", i,
			       per_cpu(processed_system_time, i));
	}

	/* System-wide jiffy work. */
	ticks = 0;
	while(delta > NS_PER_TICK) {
		delta -= NS_PER_TICK;
		processed_system_time += NS_PER_TICK;
		ticks++;
	}
	do_timer(ticks);

	/*
	 * Account stolen ticks.
	 * HACK: Passing NULL to account_steal_time()
	 * ensures that the ticks are accounted as stolen.
	 */
	if ((stolen > 0) && (delta_cpu > 0)) {
		delta_cpu -= stolen;
		if (unlikely(delta_cpu < 0))
			stolen += delta_cpu; /* clamp local-time progress */
		do_div(stolen, NS_PER_TICK);
		__get_cpu_var(processed_stolen_time) += stolen * NS_PER_TICK;
		__get_cpu_var(processed_system_time) += stolen * NS_PER_TICK;
		account_steal_time(NULL, (cputime_t)stolen);
	}

	/*
	 * Account blocked ticks.
	 * HACK: Passing idle_task to account_steal_time()
	 * ensures that the ticks are accounted as idle/wait.
	 */
	if ((blocked > 0) && (delta_cpu > 0)) {
		delta_cpu -= blocked;
		if (unlikely(delta_cpu < 0))
			blocked += delta_cpu; /* clamp local-time progress */
		do_div(blocked, NS_PER_TICK);
		__get_cpu_var(processed_blocked_time) += blocked * NS_PER_TICK;
		__get_cpu_var(processed_system_time)  += blocked * NS_PER_TICK;
		account_steal_time(idle_task(cpu), (cputime_t)blocked);
	}

	update_process_times(user_mode_vm(get_irq_regs()));
}

static cycle_t xen_clocksource_read(void)

{
	struct shadow_time_info *shadow = &get_cpu_var(shadow_time);
	cycle_t ret;

	get_time_values_from_xen();

	ret = shadow->system_timestamp + get_nsec_offset(shadow);

	put_cpu_var(shadow_time);

	return ret;
}

static void xen_read_wallclock(struct timespec *ts)

{
	const struct shared_info *s = HYPERVISOR_shared_info;
	u32 version;
	u64 delta;
	struct timespec now;

	/* get wallclock at system boot */
	do {
		version = s->wc_version;
		rmb();
		now.tv_sec  = s->wc_sec;
		now.tv_nsec = s->wc_nsec;
		rmb();
	} while ((s->wc_version & 1) | (version ^ s->wc_version));

	delta = xen_clocksource_read();	/* time since system boot */
	delta += now.tv_sec * (u64)NSEC_PER_SEC + now.tv_nsec;

	now.tv_nsec = do_div(delta, NSEC_PER_SEC);
	now.tv_sec = delta;

	set_normalized_timespec(ts, now.tv_sec, now.tv_nsec);
}

unsigned long xen_get_wallclock(void)

{
	struct timespec ts;

	xen_read_wallclock(&ts);

	return ts.tv_sec;
}

int xen_set_wallclock(unsigned long now)

{
	/* do nothing for domU */
	return -1;
}

static struct clocksource xen_clocksource = {
.name = "xen",
.rating = 400,
.read = xen_clocksource_read,
.mask = ~0,
.mult = 1<<XEN_SHIFT, /* time directly in nanoseconds */
.shift = XEN_SHIFT,
.flags = CLOCK_SOURCE_IS_CONTINUOUS,
};

static void init_missing_ticks_accounting(int cpu)

{
	struct vcpu_register_runstate_memory_area area;
	struct vcpu_runstate_info *runstate = &per_cpu(runstate, cpu);

	memset(runstate, 0, sizeof(*runstate));

	area.addr.v = runstate;
	HYPERVISOR_vcpu_op(VCPUOP_register_runstate_memory_area, cpu, &area);

	per_cpu(processed_blocked_time, cpu) =
		runstate->time[RUNSTATE_blocked];
	per_cpu(processed_stolen_time, cpu) =
		runstate->time[RUNSTATE_runnable] +
		runstate->time[RUNSTATE_offline];
}

static irqreturn_t xen_timer_interrupt(int irq, void *dev_id)

{
	/*
	 * Here we are in the timer irq handler. We just have irqs locally
	 * disabled but we don't know if the timer_bh is running on the other
	 * CPU. We need to avoid to SMP race with it. NOTE: we don' t need
	 * the irq version of write_lock because as just said we have irq
	 * locally disabled. -arca
	 */
	write_seqlock(&xtime_lock);

	xen_timer_interrupt_hook();

	write_sequnlock(&xtime_lock);

	return IRQ_HANDLED;
}

static void setup_cpu0_timer_irq(void)

{
	printk(KERN_DEBUG "installing Xen timer for CPU 0\n");

	bind_virq_to_irqhandler(
		VIRQ_TIMER,
		0,
		xen_timer_interrupt,
		SA_INTERRUPT,
		"timer0",
		NULL);
}

__init void xen_time_init(void)

{
	get_time_values_from_xen();

	processed_system_time = per_cpu(shadow_time, 0).system_timestamp;
	per_cpu(processed_system_time, 0) = processed_system_time;

	init_missing_ticks_accounting(0);

	clocksource_register(&xen_clocksource);

	/* Set initial system time with full resolution */
	xen_read_wallclock(&xtime);
	set_normalized_timespec(&wall_to_monotonic,
				-xtime.tv_sec, -xtime.tv_nsec);

	tsc_disable = 0;

	setup_cpu0_timer_irq();
}

/* Convert jiffies to system time. */
static u64 jiffies_to_st(unsigned long j)

{
	unsigned long seq;
	long delta;
	u64 st;

	do {
		seq = read_seqbegin(&xtime_lock);
		delta = j - jiffies;
		if (delta < 1) {
			/* Triggers in some wrap-around cases, but that's okay:
			 * we just end up with a shorter timeout. */
			st = processed_system_time + NS_PER_TICK;
		} else if (((unsigned long)delta >> (BITS_PER_LONG-3)) != 0) {
			/* Very long timeout means there is no pending timer.
			 * We indicate this to Xen by passing zero timeout. */
			st = 0;
		} else {
			st = processed_system_time + delta * (u64)NS_PER_TICK;
		}
	} while (read_seqretry(&xtime_lock, seq));

	return st;
}

/*
* stop_hz_timer / start_hz_timer - enter/exit 'tickless mode' on an idle cpu
* These functions are based on implementations from arch/s390/kernel/time.c */
void stop_hz_timer(void)

{
	unsigned int cpu = smp_processor_id();
	unsigned long j;

	cpu_set(cpu, nohz_cpu_mask);

	/*
	 * See matching smp_mb in rcu_start_batch in rcupdate.c.  These mbs
	 * ensure that if __rcu_pending (nested in rcu_needs_cpu) fetches a
	 * value of rcp->cur that matches rdp->quiescbatch and allows us to
	 * stop the hz timer then the cpumasks created for subsequent values
	 * of cur in rcu_start_batch are guaranteed to pick up the updated
	 * nohz_cpu_mask and so will not depend on this cpu.
	 */

	smp_mb();

	/* Leave ourselves in tick mode if rcu or softirq or timer pending. */
	if (rcu_needs_cpu(cpu) || local_softirq_pending() ||
	    (j = next_timer_interrupt(), time_before_eq(j, jiffies))) {
		cpu_clear(cpu, nohz_cpu_mask);
		j = jiffies + 1;
	}

	if (HYPERVISOR_set_timer_op(jiffies_to_st(j)) != 0)
		BUG();
}

void start_hz_timer(void)

{
	cpu_clear(smp_processor_id(), nohz_cpu_mask);
}

_______________________________________________
Xen-devel mailing list
[email protected]
http://lists.xensource.com/xen-devel