Isolate the Timecounter internals in their own two files.

Make the public interface more systematically named.

Remove the alternate method, it doesn't do any good, only ruins performance.

Add counters to profile the usage of the 8 access functions.

Apply the beer-ware to my code.

The weird +/- counts are caused by two repocopies behind the scenes:
	kern/kern_clock.c -> kern/kern_tc.c
	sys/time.h -> sys/timetc.h
(thanks peter!)

20 files changed, 120 insertions, 1384 deletions

diff --git a/sys/amd64/amd64/tsc.c b/sys/amd64/amd64/tsc.c
index ea39018..871724c 100644
--- a/sys/amd64/amd64/tsc.c
+++ b/sys/amd64/amd64/tsc.c
@@ -54,6 +54,7 @@
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/time.h>
+#include <sys/timetc.h>
 #include <sys/kernel.h>
 #ifndef SMP
 #include <sys/lock.h>
@@ -771,7 +772,7 @@ startrtclock()
 
 	set_timer_freq(timer_freq, hz);
 	i8254_timecounter.tc_frequency = timer_freq;
-	init_timecounter(&i8254_timecounter);
+	tc_init(&i8254_timecounter);
 
 #ifndef CLK_USE_TSC_CALIBRATION
 	if (tsc_freq != 0) {
@@ -821,7 +822,7 @@ startrtclock()
 
 	if (tsc_present && tsc_freq != 0 && !tsc_is_broken) {
 		tsc_timecounter.tc_frequency = tsc_freq;
-		init_timecounter(&tsc_timecounter);
+		tc_init(&tsc_timecounter);
 	}
 
 #endif /* !defined(SMP) */
@@ -844,7 +845,7 @@ inittodr(time_t base)
 		s = splclock();
 		ts.tv_sec = base;
 		ts.tv_nsec = 0;
-		set_timecounter(&ts);
+		tc_setclock(&ts);
 		splx(s);
 	}
 
@@ -895,7 +896,7 @@ inittodr(time_t base)
 		/* badly off, adjust it */
 		ts.tv_sec = sec;
 		ts.tv_nsec = 0;
-		set_timecounter(&ts);
+		tc_setclock(&ts);
 	}
 	splx(s);
 	return;
@@ -1157,7 +1158,7 @@ sysctl_machdep_i8254_freq SYSCTL_HANDLER_ARGS
 			return (EBUSY);	/* too much trouble to handle */
 		set_timer_freq(freq, hz);
 		i8254_timecounter.tc_frequency = freq;
-		update_timecounter(&i8254_timecounter);
+		tc_update(&i8254_timecounter);
 	}
 	return (error);
 }
@@ -1178,7 +1179,7 @@ sysctl_machdep_tsc_freq SYSCTL_HANDLER_ARGS
 	if (error == 0 && req->newptr != NULL) {
 		tsc_freq = freq;
 		tsc_timecounter.tc_frequency = tsc_freq;
-		update_timecounter(&tsc_timecounter);
+		tc_update(&tsc_timecounter);
 	}
 	return (error);
 }
diff --git a/sys/amd64/isa/clock.c b/sys/amd64/isa/clock.c
index ea39018..871724c 100644
--- a/sys/amd64/isa/clock.c
+++ b/sys/amd64/isa/clock.c
@@ -54,6 +54,7 @@
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/time.h>
+#include <sys/timetc.h>
 #include <sys/kernel.h>
 #ifndef SMP
 #include <sys/lock.h>
@@ -771,7 +772,7 @@ startrtclock()
 
 	set_timer_freq(timer_freq, hz);
 	i8254_timecounter.tc_frequency = timer_freq;
-	init_timecounter(&i8254_timecounter);
+	tc_init(&i8254_timecounter);
 
 #ifndef CLK_USE_TSC_CALIBRATION
 	if (tsc_freq != 0) {
@@ -821,7 +822,7 @@ startrtclock()
 
 	if (tsc_present && tsc_freq != 0 && !tsc_is_broken) {
 		tsc_timecounter.tc_frequency = tsc_freq;
-		init_timecounter(&tsc_timecounter);
+		tc_init(&tsc_timecounter);
 	}
 
 #endif /* !defined(SMP) */
@@ -844,7 +845,7 @@ inittodr(time_t base)
 		s = splclock();
 		ts.tv_sec = base;
 		ts.tv_nsec = 0;
-		set_timecounter(&ts);
+		tc_setclock(&ts);
 		splx(s);
 	}
 
@@ -895,7 +896,7 @@ inittodr(time_t base)
 		/* badly off, adjust it */
 		ts.tv_sec = sec;
 		ts.tv_nsec = 0;
-		set_timecounter(&ts);
+		tc_setclock(&ts);
 	}
 	splx(s);
 	return;
@@ -1157,7 +1158,7 @@ sysctl_machdep_i8254_freq SYSCTL_HANDLER_ARGS
 			return (EBUSY);	/* too much trouble to handle */
 		set_timer_freq(freq, hz);
 		i8254_timecounter.tc_frequency = freq;
-		update_timecounter(&i8254_timecounter);
+		tc_update(&i8254_timecounter);
 	}
 	return (error);
 }
@@ -1178,7 +1179,7 @@ sysctl_machdep_tsc_freq SYSCTL_HANDLER_ARGS
 	if (error == 0 && req->newptr != NULL) {
 		tsc_freq = freq;
 		tsc_timecounter.tc_frequency = tsc_freq;
-		update_timecounter(&tsc_timecounter);
+		tc_update(&tsc_timecounter);
 	}
 	return (error);
 }
diff --git a/sys/conf/files b/sys/conf/files
index 326b4b2..9e8624e 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -433,6 +433,7 @@ kern/kern_syscalls.c	standard
 kern/kern_sysctl.c	standard
 kern/kern_time.c	standard
 kern/kern_timeout.c	standard
+kern/kern_tc.c		standard
 kern/kern_xxx.c		standard
 kern/md5c.c		standard
 kern/subr_autoconf.c	standard
diff --git a/sys/dev/ppbus/pps.c b/sys/dev/ppbus/pps.c
index e4b6866..f89c560 100644
--- a/sys/dev/ppbus/pps.c
+++ b/sys/dev/ppbus/pps.c
@@ -21,6 +21,7 @@
 #include <sys/module.h>
 #include <sys/bus.h>
 #include <sys/conf.h>
+#include <sys/timetc.h>
 #include <sys/timepps.h>
 #include <sys/malloc.h>
 #include <machine/bus.h>
diff --git a/sys/dev/sio/sio.c b/sys/dev/sio/sio.c
index 95b8bfeb..d5681d3 100644
--- a/sys/dev/sio/sio.c
+++ b/sys/dev/sio/sio.c
@@ -68,6 +68,7 @@
 #include <sys/bus.h>
 #include <machine/bus.h>
 #include <sys/rman.h>
+#include <sys/timetc.h>
 #include <sys/timepps.h>
 
 #include <isa/isareg.h>
diff --git a/sys/i386/i386/mp_clock.c b/sys/i386/i386/mp_clock.c
index 4345a53..bd9c397 100644
--- a/sys/i386/i386/mp_clock.c
+++ b/sys/i386/i386/mp_clock.c
@@ -39,7 +39,7 @@
 
 #include <sys/param.h>
 #include <sys/systm.h>
-#include <sys/time.h>
+#include <sys/timetc.h>
 #include <sys/kernel.h>
 #include <sys/sysctl.h>
 #include <sys/bus.h>
@@ -75,7 +75,7 @@ sysctl_machdep_piix_freq SYSCTL_HANDLER_ARGS
 	if (error == 0 && req->newptr != NULL) {
 		piix_freq = freq;
 		piix_timecounter.tc_frequency = piix_freq;
-		update_timecounter(&piix_timecounter);
+		tc_update(&piix_timecounter);
 	}
 	return (error);
 }
@@ -111,7 +111,7 @@ piix_probe (device_t dev)
 		d = pci_read_config(dev, 0x40, 4);
 		piix_timecounter_address = (d & 0xffc0) + 8;
 		piix_timecounter.tc_frequency = piix_freq;
-		init_timecounter(&piix_timecounter);
+		tc_init(&piix_timecounter);
 		return (ENXIO);
 	};
 	return (ENXIO);
diff --git a/sys/i386/i386/tsc.c b/sys/i386/i386/tsc.c
index ea39018..871724c 100644
--- a/sys/i386/i386/tsc.c
+++ b/sys/i386/i386/tsc.c
@@ -54,6 +54,7 @@
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/time.h>
+#include <sys/timetc.h>
 #include <sys/kernel.h>
 #ifndef SMP
 #include <sys/lock.h>
@@ -771,7 +772,7 @@ startrtclock()
 
 	set_timer_freq(timer_freq, hz);
 	i8254_timecounter.tc_frequency = timer_freq;
-	init_timecounter(&i8254_timecounter);
+	tc_init(&i8254_timecounter);
 
 #ifndef CLK_USE_TSC_CALIBRATION
 	if (tsc_freq != 0) {
@@ -821,7 +822,7 @@ startrtclock()
 
 	if (tsc_present && tsc_freq != 0 && !tsc_is_broken) {
 		tsc_timecounter.tc_frequency = tsc_freq;
-		init_timecounter(&tsc_timecounter);
+		tc_init(&tsc_timecounter);
 	}
 
 #endif /* !defined(SMP) */
@@ -844,7 +845,7 @@ inittodr(time_t base)
 		s = splclock();
 		ts.tv_sec = base;
 		ts.tv_nsec = 0;
-		set_timecounter(&ts);
+		tc_setclock(&ts);
 		splx(s);
 	}
 
@@ -895,7 +896,7 @@ inittodr(time_t base)
 		/* badly off, adjust it */
 		ts.tv_sec = sec;
 		ts.tv_nsec = 0;
-		set_timecounter(&ts);
+		tc_setclock(&ts);
 	}
 	splx(s);
 	return;
@@ -1157,7 +1158,7 @@ sysctl_machdep_i8254_freq SYSCTL_HANDLER_ARGS
 			return (EBUSY);	/* too much trouble to handle */
 		set_timer_freq(freq, hz);
 		i8254_timecounter.tc_frequency = freq;
-		update_timecounter(&i8254_timecounter);
+		tc_update(&i8254_timecounter);
 	}
 	return (error);
 }
@@ -1178,7 +1179,7 @@ sysctl_machdep_tsc_freq SYSCTL_HANDLER_ARGS
 	if (error == 0 && req->newptr != NULL) {
 		tsc_freq = freq;
 		tsc_timecounter.tc_frequency = tsc_freq;
-		update_timecounter(&tsc_timecounter);
+		tc_update(&tsc_timecounter);
 	}
 	return (error);
 }
diff --git a/sys/i386/isa/clock.c b/sys/i386/isa/clock.c
index ea39018..871724c 100644
--- a/sys/i386/isa/clock.c
+++ b/sys/i386/isa/clock.c
@@ -54,6 +54,7 @@
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/time.h>
+#include <sys/timetc.h>
 #include <sys/kernel.h>
 #ifndef SMP
 #include <sys/lock.h>
@@ -771,7 +772,7 @@ startrtclock()
 
 	set_timer_freq(timer_freq, hz);
 	i8254_timecounter.tc_frequency = timer_freq;
-	init_timecounter(&i8254_timecounter);
+	tc_init(&i8254_timecounter);
 
 #ifndef CLK_USE_TSC_CALIBRATION
 	if (tsc_freq != 0) {
@@ -821,7 +822,7 @@ startrtclock()
 
 	if (tsc_present && tsc_freq != 0 && !tsc_is_broken) {
 		tsc_timecounter.tc_frequency = tsc_freq;
-		init_timecounter(&tsc_timecounter);
+		tc_init(&tsc_timecounter);
 	}
 
 #endif /* !defined(SMP) */
@@ -844,7 +845,7 @@ inittodr(time_t base)
 		s = splclock();
 		ts.tv_sec = base;
 		ts.tv_nsec = 0;
-		set_timecounter(&ts);
+		tc_setclock(&ts);
 		splx(s);
 	}
 
@@ -895,7 +896,7 @@ inittodr(time_t base)
 		/* badly off, adjust it */
 		ts.tv_sec = sec;
 		ts.tv_nsec = 0;
-		set_timecounter(&ts);
+		tc_setclock(&ts);
 	}
 	splx(s);
 	return;
@@ -1157,7 +1158,7 @@ sysctl_machdep_i8254_freq SYSCTL_HANDLER_ARGS
 			return (EBUSY);	/* too much trouble to handle */
 		set_timer_freq(freq, hz);
 		i8254_timecounter.tc_frequency = freq;
-		update_timecounter(&i8254_timecounter);
+		tc_update(&i8254_timecounter);
 	}
 	return (error);
 }
@@ -1178,7 +1179,7 @@ sysctl_machdep_tsc_freq SYSCTL_HANDLER_ARGS
 	if (error == 0 && req->newptr != NULL) {
 		tsc_freq = freq;
 		tsc_timecounter.tc_frequency = tsc_freq;
-		update_timecounter(&tsc_timecounter);
+		tc_update(&tsc_timecounter);
 	}
 	return (error);
 }
diff --git a/sys/i386/isa/loran.c b/sys/i386/isa/loran.c
index 23db1a4..b4c5daa 100644
--- a/sys/i386/isa/loran.c
+++ b/sys/i386/isa/loran.c
@@ -28,6 +28,7 @@
 #include <sys/kernel.h>
 #include <sys/uio.h>
 #include <sys/malloc.h>
+#include <sys/timetc.h>
 
 #include <i386/isa/isa_device.h>
 #endif /* _KERNEL */
@@ -291,7 +292,7 @@ loranattach(struct isa_device *isdp)
 	 
 	init_tgc();
 
-	init_timecounter(&loran_timecounter);
+	tc_init(&loran_timecounter);
 
 	TAILQ_INIT(&working);
 	for (i = 0; i < NLORAN + 1; i++) {
diff --git a/sys/i386/isa/random_machdep.c b/sys/i386/isa/random_machdep.c
index ef63742..5309478 100644
--- a/sys/i386/isa/random_machdep.c
+++ b/sys/i386/isa/random_machdep.c
@@ -44,6 +44,7 @@
 #include <sys/kernel.h>
 #include <sys/select.h>
 #include <sys/poll.h>
+#include <sys/timetc.h>
 #include <sys/md5.h>
 
 #include <machine/random.h>
diff --git a/sys/isa/atrtc.c b/sys/isa/atrtc.c
index ea39018..871724c 100644
--- a/sys/isa/atrtc.c
+++ b/sys/isa/atrtc.c
@@ -54,6 +54,7 @@
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/time.h>
+#include <sys/timetc.h>
 #include <sys/kernel.h>
 #ifndef SMP
 #include <sys/lock.h>
@@ -771,7 +772,7 @@ startrtclock()
 
 	set_timer_freq(timer_freq, hz);
 	i8254_timecounter.tc_frequency = timer_freq;
-	init_timecounter(&i8254_timecounter);
+	tc_init(&i8254_timecounter);
 
 #ifndef CLK_USE_TSC_CALIBRATION
 	if (tsc_freq != 0) {
@@ -821,7 +822,7 @@ startrtclock()
 
 	if (tsc_present && tsc_freq != 0 && !tsc_is_broken) {
 		tsc_timecounter.tc_frequency = tsc_freq;
-		init_timecounter(&tsc_timecounter);
+		tc_init(&tsc_timecounter);
 	}
 
 #endif /* !defined(SMP) */
@@ -844,7 +845,7 @@ inittodr(time_t base)
 		s = splclock();
 		ts.tv_sec = base;
 		ts.tv_nsec = 0;
-		set_timecounter(&ts);
+		tc_setclock(&ts);
 		splx(s);
 	}
 
@@ -895,7 +896,7 @@ inittodr(time_t base)
 		/* badly off, adjust it */
 		ts.tv_sec = sec;
 		ts.tv_nsec = 0;
-		set_timecounter(&ts);
+		tc_setclock(&ts);
 	}
 	splx(s);
 	return;
@@ -1157,7 +1158,7 @@ sysctl_machdep_i8254_freq SYSCTL_HANDLER_ARGS
 			return (EBUSY);	/* too much trouble to handle */
 		set_timer_freq(freq, hz);
 		i8254_timecounter.tc_frequency = freq;
-		update_timecounter(&i8254_timecounter);
+		tc_update(&i8254_timecounter);
 	}
 	return (error);
 }
@@ -1178,7 +1179,7 @@ sysctl_machdep_tsc_freq SYSCTL_HANDLER_ARGS
 	if (error == 0 && req->newptr != NULL) {
 		tsc_freq = freq;
 		tsc_timecounter.tc_frequency = tsc_freq;
-		update_timecounter(&tsc_timecounter);
+		tc_update(&tsc_timecounter);
 	}
 	return (error);
 }
diff --git a/sys/isa/sio.c b/sys/isa/sio.c
index 95b8bfeb..d5681d3 100644
--- a/sys/isa/sio.c
+++ b/sys/isa/sio.c
@@ -68,6 +68,7 @@
 #include <sys/bus.h>
 #include <machine/bus.h>
 #include <sys/rman.h>
+#include <sys/timetc.h>
 #include <sys/timepps.h>
 
 #include <isa/isareg.h>
diff --git a/sys/kern/kern_clock.c b/sys/kern/kern_clock.c
index 6166e1c..d8066a7 100644
--- a/sys/kern/kern_clock.c
+++ b/sys/kern/kern_clock.c
@@ -1,5 +1,4 @@
 /*-
- * Copyright (c) 1997, 1998 Poul-Henning Kamp <phk@FreeBSD.org>
  * Copyright (c) 1982, 1986, 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
@@ -51,7 +50,7 @@
 #include <sys/malloc.h>
 #include <sys/resourcevar.h>
 #include <sys/signalvar.h>
-#include <sys/timex.h>
+#include <sys/timetc.h>
 #include <sys/timepps.h>
 #include <vm/vm.h>
 #include <sys/lock.h>
@@ -70,23 +69,9 @@
 #include <machine/smp.h>
 #endif
 
-/*
- * Number of timecounters used to implement stable storage
- */
-#ifndef NTIMECOUNTER
-#define NTIMECOUNTER	5
-#endif
-
-static MALLOC_DEFINE(M_TIMECOUNTER, "timecounter", 
-	"Timecounter stable storage");
-
 static void initclocks __P((void *dummy));
 SYSINIT(clocks, SI_SUB_CLOCKS, SI_ORDER_FIRST, initclocks, NULL)
 
-static void tco_forward __P((int force));
-static void tco_setscales __P((struct timecounter *tc));
-static __inline unsigned tco_delta __P((struct timecounter *tc));
-
 /* Some of these don't belong here, but it's easiest to concentrate them. */
 #if defined(SMP) && defined(BETTER_CLOCK)
 long cp_time[CPUSTATES];
@@ -99,42 +84,6 @@ long tk_nin;
 long tk_nout;
 long tk_rawcc;
 
-time_t time_second;
-
-struct	timeval boottime;
-SYSCTL_STRUCT(_kern, KERN_BOOTTIME, boottime, CTLFLAG_RD,
-    &boottime, timeval, "System boottime");
-
-/*
- * Which update policy to use.
- *   0 - every tick, bad hardware may fail with "calcru negative..."
- *   1 - more resistent to the above hardware, but less efficient.
- */
-static int tco_method;
-
-/*
- * Implement a dummy timecounter which we can use until we get a real one
- * in the air.  This allows the console and other early stuff to use
- * timeservices.
- */
-
-static unsigned 
-dummy_get_timecount(struct timecounter *tc)
-{
-	static unsigned now;
-	return (++now);
-}
-
-static struct timecounter dummy_timecounter = {
-	dummy_get_timecount,
-	0,
-	~0u,
-	1000000,
-	"dummy"
-};
-
-struct timecounter *timecounter = &dummy_timecounter;
-
 /*
  * Clock handling routines.
  *
@@ -236,7 +185,7 @@ hardclock(frame)
 	if (stathz == 0)
 		statclock(frame);
 
-	tco_forward(0);
+	tc_windup();
 	ticks++;
 
 	/*
@@ -483,522 +432,3 @@ sysctl_kern_clockrate SYSCTL_HANDLER_ARGS
 
 SYSCTL_PROC(_kern, KERN_CLOCKRATE, clockrate, CTLTYPE_STRUCT|CTLFLAG_RD,
 	0, 0, sysctl_kern_clockrate, "S,clockinfo","");
-
-static __inline unsigned
-tco_delta(struct timecounter *tc)
-{
-
-	return ((tc->tc_get_timecount(tc) - tc->tc_offset_count) & 
-	    tc->tc_counter_mask);
-}
-
-/*
- * We have eight functions for looking at the clock, four for
- * microseconds and four for nanoseconds.  For each there is fast
- * but less precise version "get{nano|micro}[up]time" which will
- * return a time which is up to 1/HZ previous to the call, whereas
- * the raw version "{nano|micro}[up]time" will return a timestamp
- * which is as precise as possible.  The "up" variants return the
- * time relative to system boot, these are well suited for time
- * interval measurements.
- */
-
-void
-getmicrotime(struct timeval *tvp)
-{
-	struct timecounter *tc;
-
-	if (!tco_method) {
-		tc = timecounter;
-		*tvp = tc->tc_microtime;
-	} else {
-		microtime(tvp);
-	}
-}
-
-void
-getnanotime(struct timespec *tsp)
-{
-	struct timecounter *tc;
-
-	if (!tco_method) {
-		tc = timecounter;
-		*tsp = tc->tc_nanotime;
-	} else {
-		nanotime(tsp);
-	}
-}
-
-void
-microtime(struct timeval *tv)
-{
-	struct timecounter *tc;
-
-	tc = timecounter;
-	tv->tv_sec = tc->tc_offset_sec;
-	tv->tv_usec = tc->tc_offset_micro;
-	tv->tv_usec += ((u_int64_t)tco_delta(tc) * tc->tc_scale_micro) >> 32;
-	tv->tv_usec += boottime.tv_usec;
-	tv->tv_sec += boottime.tv_sec;
-	while (tv->tv_usec >= 1000000) {
-		tv->tv_usec -= 1000000;
-		tv->tv_sec++;
-	}
-}
-
-void
-nanotime(struct timespec *ts)
-{
-	unsigned count;
-	u_int64_t delta;
-	struct timecounter *tc;
-
-	tc = timecounter;
-	ts->tv_sec = tc->tc_offset_sec;
-	count = tco_delta(tc);
-	delta = tc->tc_offset_nano;
-	delta += ((u_int64_t)count * tc->tc_scale_nano_f);
-	delta >>= 32;
-	delta += ((u_int64_t)count * tc->tc_scale_nano_i);
-	delta += boottime.tv_usec * 1000;
-	ts->tv_sec += boottime.tv_sec;
-	while (delta >= 1000000000) {
-		delta -= 1000000000;
-		ts->tv_sec++;
-	}
-	ts->tv_nsec = delta;
-}
-
-void
-getmicrouptime(struct timeval *tvp)
-{
-	struct timecounter *tc;
-
-	if (!tco_method) {
-		tc = timecounter;
-		tvp->tv_sec = tc->tc_offset_sec;
-		tvp->tv_usec = tc->tc_offset_micro;
-	} else {
-		microuptime(tvp);
-	}
-}
-
-void
-getnanouptime(struct timespec *tsp)
-{
-	struct timecounter *tc;
-
-	if (!tco_method) {
-		tc = timecounter;
-		tsp->tv_sec = tc->tc_offset_sec;
-		tsp->tv_nsec = tc->tc_offset_nano >> 32;
-	} else {
-		nanouptime(tsp);
-	}
-}
-
-void
-microuptime(struct timeval *tv)
-{
-	struct timecounter *tc;
-
-	tc = timecounter;
-	tv->tv_sec = tc->tc_offset_sec;
-	tv->tv_usec = tc->tc_offset_micro;
-	tv->tv_usec += ((u_int64_t)tco_delta(tc) * tc->tc_scale_micro) >> 32;
-	if (tv->tv_usec >= 1000000) {
-		tv->tv_usec -= 1000000;
-		tv->tv_sec++;
-	}
-}
-
-void
-nanouptime(struct timespec *ts)
-{
-	unsigned count;
-	u_int64_t delta;
-	struct timecounter *tc;
-
-	tc = timecounter;
-	ts->tv_sec = tc->tc_offset_sec;
-	count = tco_delta(tc);
-	delta = tc->tc_offset_nano;
-	delta += ((u_int64_t)count * tc->tc_scale_nano_f);
-	delta >>= 32;
-	delta += ((u_int64_t)count * tc->tc_scale_nano_i);
-	if (delta >= 1000000000) {
-		delta -= 1000000000;
-		ts->tv_sec++;
-	}
-	ts->tv_nsec = delta;
-}
-
-static void
-tco_setscales(struct timecounter *tc)
-{
-	u_int64_t scale;
-
-	scale = 1000000000LL << 32;
-	scale += tc->tc_adjustment;
-	scale /= tc->tc_tweak->tc_frequency;
-	tc->tc_scale_micro = scale / 1000;
-	tc->tc_scale_nano_f = scale & 0xffffffff;
-	tc->tc_scale_nano_i = scale >> 32;
-}
-
-void
-update_timecounter(struct timecounter *tc)
-{
-	tco_setscales(tc);
-}
-
-void
-init_timecounter(struct timecounter *tc)
-{
-	struct timespec ts1;
-	struct timecounter *t1, *t2, *t3;
-	int i;
-
-	tc->tc_adjustment = 0;
-	tc->tc_tweak = tc;
-	tco_setscales(tc);
-	tc->tc_offset_count = tc->tc_get_timecount(tc);
-	if (timecounter == &dummy_timecounter)
-		tc->tc_avail = tc;
-	else {
-		tc->tc_avail = timecounter->tc_tweak->tc_avail;
-		timecounter->tc_tweak->tc_avail = tc;
-	}
-	MALLOC(t1, struct timecounter *, sizeof *t1, M_TIMECOUNTER, M_WAITOK);
-	tc->tc_other = t1;
-	*t1 = *tc;
-	t2 = t1;
-	for (i = 1; i < NTIMECOUNTER; i++) {
-		MALLOC(t3, struct timecounter *, sizeof *t3,
-		    M_TIMECOUNTER, M_WAITOK);
-		*t3 = *tc;
-		t3->tc_other = t2;
-		t2 = t3;
-	}
-	t1->tc_other = t3;
-	tc = t1;
-
-	printf("Timecounter \"%s\"  frequency %lu Hz\n", 
-	    tc->tc_name, (u_long)tc->tc_frequency);
-
-	/* XXX: For now always start using the counter. */
-	tc->tc_offset_count = tc->tc_get_timecount(tc);
-	nanouptime(&ts1);
-	tc->tc_offset_nano = (u_int64_t)ts1.tv_nsec << 32;
-	tc->tc_offset_micro = ts1.tv_nsec / 1000;
-	tc->tc_offset_sec = ts1.tv_sec;
-	timecounter = tc;
-}
-
-void
-set_timecounter(struct timespec *ts)
-{
-	struct timespec ts2;
-
-	nanouptime(&ts2);
-	boottime.tv_sec = ts->tv_sec - ts2.tv_sec;
-	boottime.tv_usec = (ts->tv_nsec - ts2.tv_nsec) / 1000;
-	if (boottime.tv_usec < 0) {
-		boottime.tv_usec += 1000000;
-		boottime.tv_sec--;
-	}
-	/* fiddle all the little crinkly bits around the fiords... */
-	tco_forward(1);
-}
-
-static void
-switch_timecounter(struct timecounter *newtc)
-{
-	int s;
-	struct timecounter *tc;
-	struct timespec ts;
-
-	s = splclock();
-	tc = timecounter;
-	if (newtc->tc_tweak == tc->tc_tweak) {
-		splx(s);
-		return;
-	}
-	newtc = newtc->tc_tweak->tc_other;
-	nanouptime(&ts);
-	newtc->tc_offset_sec = ts.tv_sec;
-	newtc->tc_offset_nano = (u_int64_t)ts.tv_nsec << 32;
-	newtc->tc_offset_micro = ts.tv_nsec / 1000;
-	newtc->tc_offset_count = newtc->tc_get_timecount(newtc);
-	tco_setscales(newtc);
-	timecounter = newtc;
-	splx(s);
-}
-
-static struct timecounter *
-sync_other_counter(void)
-{
-	struct timecounter *tc, *tcn, *tco;
-	unsigned delta;
-
-	tco = timecounter;
-	tc = tco->tc_other;
-	tcn = tc->tc_other;
-	*tc = *tco;
-	tc->tc_other = tcn;
-	delta = tco_delta(tc);
-	tc->tc_offset_count += delta;
-	tc->tc_offset_count &= tc->tc_counter_mask;
-	tc->tc_offset_nano += (u_int64_t)delta * tc->tc_scale_nano_f;
-	tc->tc_offset_nano += (u_int64_t)delta * tc->tc_scale_nano_i << 32;
-	return (tc);
-}
-
-static void
-tco_forward(int force)
-{
-	struct timecounter *tc, *tco;
-	struct timeval tvt;
-
-	tco = timecounter;
-	tc = sync_other_counter();
-	/*
-	 * We may be inducing a tiny error here, the tc_poll_pps() may
-	 * process a latched count which happens after the tco_delta()
-	 * in sync_other_counter(), which would extend the previous
-	 * counters parameters into the domain of this new one.
-	 * Since the timewindow is very small for this, the error is
-	 * going to be only a few weenieseconds (as Dave Mills would
-	 * say), so lets just not talk more about it, OK ?
-	 */
-	if (tco->tc_poll_pps) 
-		tco->tc_poll_pps(tco);
-	if (timedelta != 0) {
-		tvt = boottime;
-		tvt.tv_usec += tickdelta;
-		if (tvt.tv_usec >= 1000000) {
-			tvt.tv_sec++;
-			tvt.tv_usec -= 1000000;
-		} else if (tvt.tv_usec < 0) {
-			tvt.tv_sec--;
-			tvt.tv_usec += 1000000;
-		}
-		boottime = tvt;
-		timedelta -= tickdelta;
-	}
-
-	while (tc->tc_offset_nano >= 1000000000ULL << 32) {
-		tc->tc_offset_nano -= 1000000000ULL << 32;
-		tc->tc_offset_sec++;
-		ntp_update_second(tc);	/* XXX only needed if xntpd runs */
-		tco_setscales(tc);
-		force++;
-	}
-
-	if (tco_method && !force)
-		return;
-
-	tc->tc_offset_micro = (tc->tc_offset_nano / 1000) >> 32;
-
-	/* Figure out the wall-clock time */
-	tc->tc_nanotime.tv_sec = tc->tc_offset_sec + boottime.tv_sec;
-	tc->tc_nanotime.tv_nsec = 
-	    (tc->tc_offset_nano >> 32) + boottime.tv_usec * 1000;
-	tc->tc_microtime.tv_usec = tc->tc_offset_micro + boottime.tv_usec;
-	if (tc->tc_nanotime.tv_nsec >= 1000000000) {
-		tc->tc_nanotime.tv_nsec -= 1000000000;
-		tc->tc_microtime.tv_usec -= 1000000;
-		tc->tc_nanotime.tv_sec++;
-	}
-	time_second = tc->tc_microtime.tv_sec = tc->tc_nanotime.tv_sec;
-
-	timecounter = tc;
-}
-
-SYSCTL_NODE(_kern, OID_AUTO, timecounter, CTLFLAG_RW, 0, "");
-
-SYSCTL_INT(_kern_timecounter, OID_AUTO, method, CTLFLAG_RW, &tco_method, 0,
-    "This variable determines the method used for updating timecounters. "
-    "If the default algorithm (0) fails with \"calcru negative...\" messages "
-    "try the alternate algorithm (1) which handles bad hardware better."
-
-);
-
-static int
-sysctl_kern_timecounter_hardware SYSCTL_HANDLER_ARGS
-{
-	char newname[32];
-	struct timecounter *newtc, *tc;
-	int error;
-
-	tc = timecounter->tc_tweak;
-	strncpy(newname, tc->tc_name, sizeof(newname));
-	error = sysctl_handle_string(oidp, &newname[0], sizeof(newname), req);
-	if (error == 0 && req->newptr != NULL &&
-	    strcmp(newname, tc->tc_name) != 0) {
-		for (newtc = tc->tc_avail; newtc != tc;
-		    newtc = newtc->tc_avail) {
-			if (strcmp(newname, newtc->tc_name) == 0) {
-				/* Warm up new timecounter. */
-				(void)newtc->tc_get_timecount(newtc);
-
-				switch_timecounter(newtc);
-				return (0);
-			}
-		}
-		return (EINVAL);
-	}
-	return (error);
-}
-
-SYSCTL_PROC(_kern_timecounter, OID_AUTO, hardware, CTLTYPE_STRING | CTLFLAG_RW,
-    0, 0, sysctl_kern_timecounter_hardware, "A", "");
-
-
-int
-pps_ioctl(u_long cmd, caddr_t data, struct pps_state *pps)
-{
-	pps_params_t *app;
-	struct pps_fetch_args *fapi;
-#ifdef PPS_SYNC
-	struct pps_kcbind_args *kapi;
-#endif
-
-	switch (cmd) {
-	case PPS_IOC_CREATE:
-		return (0);
-	case PPS_IOC_DESTROY:
-		return (0);
-	case PPS_IOC_SETPARAMS:
-		app = (pps_params_t *)data;
-		if (app->mode & ~pps->ppscap)
-			return (EINVAL);
-		pps->ppsparam = *app;         
-		return (0);
-	case PPS_IOC_GETPARAMS:
-		app = (pps_params_t *)data;
-		*app = pps->ppsparam;
-		app->api_version = PPS_API_VERS_1;
-		return (0);
-	case PPS_IOC_GETCAP:
-		*(int*)data = pps->ppscap;
-		return (0);
-	case PPS_IOC_FETCH:
-		fapi = (struct pps_fetch_args *)data;
-		if (fapi->tsformat && fapi->tsformat != PPS_TSFMT_TSPEC)
-			return (EINVAL);
-		if (fapi->timeout.tv_sec || fapi->timeout.tv_nsec)
-			return (EOPNOTSUPP);
-		pps->ppsinfo.current_mode = pps->ppsparam.mode;         
-		fapi->pps_info_buf = pps->ppsinfo;
-		return (0);
-	case PPS_IOC_KCBIND:
-#ifdef PPS_SYNC
-		kapi = (struct pps_kcbind_args *)data;
-		/* XXX Only root should be able to do this */
-		if (kapi->tsformat && kapi->tsformat != PPS_TSFMT_TSPEC)
-			return (EINVAL);
-		if (kapi->kernel_consumer != PPS_KC_HARDPPS)
-			return (EINVAL);
-		if (kapi->edge & ~pps->ppscap)
-			return (EINVAL);
-		pps->kcmode = kapi->edge;
-		return (0);
-#else
-		return (EOPNOTSUPP);
-#endif
-	default:
-		return (ENOTTY);
-	}
-}
-
-void
-pps_init(struct pps_state *pps)
-{
-	pps->ppscap |= PPS_TSFMT_TSPEC;
-	if (pps->ppscap & PPS_CAPTUREASSERT)
-		pps->ppscap |= PPS_OFFSETASSERT;
-	if (pps->ppscap & PPS_CAPTURECLEAR)
-		pps->ppscap |= PPS_OFFSETCLEAR;
-}
-
-void
-pps_event(struct pps_state *pps, struct timecounter *tc, unsigned count, int event)
-{
-	struct timespec ts, *tsp, *osp;
-	u_int64_t delta;
-	unsigned tcount, *pcount;
-	int foff, fhard;
-	pps_seq_t	*pseq;
-
-	/* Things would be easier with arrays... */
-	if (event == PPS_CAPTUREASSERT) {
-		tsp = &pps->ppsinfo.assert_timestamp;
-		osp = &pps->ppsparam.assert_offset;
-		foff = pps->ppsparam.mode & PPS_OFFSETASSERT;
-		fhard = pps->kcmode & PPS_CAPTUREASSERT;
-		pcount = &pps->ppscount[0];
-		pseq = &pps->ppsinfo.assert_sequence;
-	} else {
-		tsp = &pps->ppsinfo.clear_timestamp;
-		osp = &pps->ppsparam.clear_offset;
-		foff = pps->ppsparam.mode & PPS_OFFSETCLEAR;
-		fhard = pps->kcmode & PPS_CAPTURECLEAR;
-		pcount = &pps->ppscount[1];
-		pseq = &pps->ppsinfo.clear_sequence;
-	}
-
-	/* The timecounter changed: bail */
-	if (!pps->ppstc || 
-	    pps->ppstc->tc_name != tc->tc_name || 
-	    tc->tc_name != timecounter->tc_name) {
-		pps->ppstc = tc;
-		*pcount = count;
-		return;
-	}
-
-	/* Nothing really happened */
-	if (*pcount == count)
-		return;
-
-	*pcount = count;
-
-	/* Convert the count to timespec */
-	ts.tv_sec = tc->tc_offset_sec;
-	tcount = count - tc->tc_offset_count;
-	tcount &= tc->tc_counter_mask;
-	delta = tc->tc_offset_nano;
-	delta += ((u_int64_t)tcount * tc->tc_scale_nano_f);
-	delta >>= 32;
-	delta += ((u_int64_t)tcount * tc->tc_scale_nano_i);
-	delta += boottime.tv_usec * 1000;
-	ts.tv_sec += boottime.tv_sec;
-	while (delta >= 1000000000) {
-		delta -= 1000000000;
-		ts.tv_sec++;
-	}
-	ts.tv_nsec = delta;
-
-	(*pseq)++;
-	*tsp = ts;
-
-	if (foff) {
-		timespecadd(tsp, osp);
-		if (tsp->tv_nsec < 0) {
-			tsp->tv_nsec += 1000000000;
-			tsp->tv_sec -= 1;
-		}
-	}
-#ifdef PPS_SYNC
-	if (fhard) {
-		/* magic, at its best... */
-		tcount = count - pps->ppscount[2];
-		pps->ppscount[2] = count;
-		tcount &= tc->tc_counter_mask;
-		delta = ((u_int64_t)tcount * tc->tc_tweak->tc_scale_nano_f);
-		delta >>= 32;
-		delta += ((u_int64_t)tcount * tc->tc_tweak->tc_scale_nano_i);
-		hardpps(tsp, delta);
-	}
-#endif
-}
diff --git a/sys/kern/kern_ntptime.c b/sys/kern/kern_ntptime.c
index 883bc9d..bfec538 100644
--- a/sys/kern/kern_ntptime.c
+++ b/sys/kern/kern_ntptime.c
@@ -40,6 +40,7 @@
 #include <sys/proc.h>
 #include <sys/time.h>
 #include <sys/timex.h>
+#include <sys/timetc.h>
 #include <sys/timepps.h>
 #include <sys/sysctl.h>
 
diff --git a/sys/kern/kern_random.c b/sys/kern/kern_random.c
index ef63742..5309478 100644
--- a/sys/kern/kern_random.c
+++ b/sys/kern/kern_random.c
@@ -44,6 +44,7 @@
 #include <sys/kernel.h>
 #include <sys/select.h>
 #include <sys/poll.h>
+#include <sys/timetc.h>
 #include <sys/md5.h>
 
 #include <machine/random.h>
diff --git a/sys/kern/kern_tc.c b/sys/kern/kern_tc.c
index 6166e1c..23a6606 100644
--- a/sys/kern/kern_tc.c
+++ b/sys/kern/kern_tc.c
@@ -1,74 +1,24 @@
-/*-
- * Copyright (c) 1997, 1998 Poul-Henning Kamp <phk@FreeBSD.org>
- * Copyright (c) 1982, 1986, 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * 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
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS 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.
+/*
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <phk@FreeBSD.ORG> wrote this file.  As long as you retain this notice you
+ * can do whatever you want with this stuff. If we meet some day, and you think
+ * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
+ * ----------------------------------------------------------------------------
  *
- *	@(#)kern_clock.c	8.5 (Berkeley) 1/21/94
  * $FreeBSD$
  */
 
 #include "opt_ntp.h"
 
 #include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/dkstat.h>
-#include <sys/callout.h>
-#include <sys/kernel.h>
-#include <sys/proc.h>
+#include <sys/timetc.h>
 #include <sys/malloc.h>
-#include <sys/resourcevar.h>
-#include <sys/signalvar.h>
+#include <sys/kernel.h>
+#include <sys/sysctl.h>
+#include <sys/systm.h>
 #include <sys/timex.h>
 #include <sys/timepps.h>
-#include <vm/vm.h>
-#include <sys/lock.h>
-#include <vm/pmap.h>
-#include <vm/vm_map.h>
-#include <sys/sysctl.h>
-
-#include <machine/cpu.h>
-#include <machine/limits.h>
-
-#ifdef GPROF
-#include <sys/gmon.h>
-#endif
-
-#if defined(SMP) && defined(BETTER_CLOCK)
-#include <machine/smp.h>
-#endif
 
 /*
  * Number of timecounters used to implement stable storage
@@ -80,37 +30,33 @@
 static MALLOC_DEFINE(M_TIMECOUNTER, "timecounter", 
 	"Timecounter stable storage");
 
-static void initclocks __P((void *dummy));
-SYSINIT(clocks, SI_SUB_CLOCKS, SI_ORDER_FIRST, initclocks, NULL)
-
-static void tco_forward __P((int force));
 static void tco_setscales __P((struct timecounter *tc));
 static __inline unsigned tco_delta __P((struct timecounter *tc));
 
-/* Some of these don't belong here, but it's easiest to concentrate them. */
-#if defined(SMP) && defined(BETTER_CLOCK)
-long cp_time[CPUSTATES];
-#else
-static long cp_time[CPUSTATES];
-#endif
-
-long tk_cancc;
-long tk_nin;
-long tk_nout;
-long tk_rawcc;
-
 time_t time_second;
 
 struct	timeval boottime;
 SYSCTL_STRUCT(_kern, KERN_BOOTTIME, boottime, CTLFLAG_RD,
     &boottime, timeval, "System boottime");
 
-/*
- * Which update policy to use.
- *   0 - every tick, bad hardware may fail with "calcru negative..."
- *   1 - more resistent to the above hardware, but less efficient.
- */
-static int tco_method;
+SYSCTL_NODE(_kern, OID_AUTO, timecounter, CTLFLAG_RW, 0, "");
+
+static unsigned nmicrotime;
+static unsigned nnanotime;
+static unsigned ngetmicrotime;
+static unsigned ngetnanotime;
+static unsigned nmicrouptime;
+static unsigned nnanouptime;
+static unsigned ngetmicrouptime;
+static unsigned ngetnanouptime;
+SYSCTL_INT(_kern_timecounter, OID_AUTO, nmicrotime, CTLFLAG_RD, &nmicrotime, 0, "");
+SYSCTL_INT(_kern_timecounter, OID_AUTO, nnanotime, CTLFLAG_RD, &nnanotime, 0, "");
+SYSCTL_INT(_kern_timecounter, OID_AUTO, nmicrouptime, CTLFLAG_RD, &nmicrouptime, 0, "");
+SYSCTL_INT(_kern_timecounter, OID_AUTO, nnanouptime, CTLFLAG_RD, &nnanouptime, 0, "");
+SYSCTL_INT(_kern_timecounter, OID_AUTO, ngetmicrotime, CTLFLAG_RD, &ngetmicrotime, 0, "");
+SYSCTL_INT(_kern_timecounter, OID_AUTO, ngetnanotime, CTLFLAG_RD, &ngetnanotime, 0, "");
+SYSCTL_INT(_kern_timecounter, OID_AUTO, ngetmicrouptime, CTLFLAG_RD, &ngetmicrouptime, 0, "");
+SYSCTL_INT(_kern_timecounter, OID_AUTO, ngetnanouptime, CTLFLAG_RD, &ngetnanouptime, 0, "");
 
 /*
  * Implement a dummy timecounter which we can use until we get a real one
@@ -122,6 +68,7 @@ static unsigned
 dummy_get_timecount(struct timecounter *tc)
 {
 	static unsigned now;
+
 	return (++now);
 }
 
@@ -135,355 +82,6 @@ static struct timecounter dummy_timecounter = {
 
 struct timecounter *timecounter = &dummy_timecounter;
 
-/*
- * Clock handling routines.
- *
- * This code is written to operate with two timers that run independently of
- * each other.
- *
- * The main timer, running hz times per second, is used to trigger interval
- * timers, timeouts and rescheduling as needed.
- *
- * The second timer handles kernel and user profiling,
- * and does resource use estimation.  If the second timer is programmable,
- * it is randomized to avoid aliasing between the two clocks.  For example,
- * the randomization prevents an adversary from always giving up the cpu
- * just before its quantum expires.  Otherwise, it would never accumulate
- * cpu ticks.  The mean frequency of the second timer is stathz.
- *
- * If no second timer exists, stathz will be zero; in this case we drive
- * profiling and statistics off the main clock.  This WILL NOT be accurate;
- * do not do it unless absolutely necessary.
- *
- * The statistics clock may (or may not) be run at a higher rate while
- * profiling.  This profile clock runs at profhz.  We require that profhz
- * be an integral multiple of stathz.
- *
- * If the statistics clock is running fast, it must be divided by the ratio
- * profhz/stathz for statistics.  (For profiling, every tick counts.)
- *
- * Time-of-day is maintained using a "timecounter", which may or may
- * not be related to the hardware generating the above mentioned
- * interrupts.
- */
-
-int	stathz;
-int	profhz;
-static int profprocs;
-int	ticks;
-static int psdiv, pscnt;		/* prof => stat divider */
-int	psratio;			/* ratio: prof / stat */
-
-/*
- * Initialize clock frequencies and start both clocks running.
- */
-/* ARGSUSED*/
-static void
-initclocks(dummy)
-	void *dummy;
-{
-	register int i;
-
-	/*
-	 * Set divisors to 1 (normal case) and let the machine-specific
-	 * code do its bit.
-	 */
-	psdiv = pscnt = 1;
-	cpu_initclocks();
-
-	/*
-	 * Compute profhz/stathz, and fix profhz if needed.
-	 */
-	i = stathz ? stathz : hz;
-	if (profhz == 0)
-		profhz = i;
-	psratio = profhz / i;
-}
-
-/*
- * The real-time timer, interrupting hz times per second.
- */
-void
-hardclock(frame)
-	register struct clockframe *frame;
-{
-	register struct proc *p;
-
-	p = curproc;
-	if (p) {
-		register struct pstats *pstats;
-
-		/*
-		 * Run current process's virtual and profile time, as needed.
-		 */
-		pstats = p->p_stats;
-		if (CLKF_USERMODE(frame) &&
-		    timevalisset(&pstats->p_timer[ITIMER_VIRTUAL].it_value) &&
-		    itimerdecr(&pstats->p_timer[ITIMER_VIRTUAL], tick) == 0)
-			psignal(p, SIGVTALRM);
-		if (timevalisset(&pstats->p_timer[ITIMER_PROF].it_value) &&
-		    itimerdecr(&pstats->p_timer[ITIMER_PROF], tick) == 0)
-			psignal(p, SIGPROF);
-	}
-
-#if defined(SMP) && defined(BETTER_CLOCK)
-	forward_hardclock(pscnt);
-#endif
-
-	/*
-	 * If no separate statistics clock is available, run it from here.
-	 */
-	if (stathz == 0)
-		statclock(frame);
-
-	tco_forward(0);
-	ticks++;
-
-	/*
-	 * Process callouts at a very low cpu priority, so we don't keep the
-	 * relatively high clock interrupt priority any longer than necessary.
-	 */
-	if (TAILQ_FIRST(&callwheel[ticks & callwheelmask]) != NULL) {
-		if (CLKF_BASEPRI(frame)) {
-			/*
-			 * Save the overhead of a software interrupt;
-			 * it will happen as soon as we return, so do it now.
-			 */
-			(void)splsoftclock();
-			softclock();
-		} else
-			setsoftclock();
-	} else if (softticks + 1 == ticks)
-		++softticks;
-}
-
-/*
- * Compute number of ticks in the specified amount of time.
- */
-int
-tvtohz(tv)
-	struct timeval *tv;
-{
-	register unsigned long ticks;
-	register long sec, usec;
-
-	/*
-	 * If the number of usecs in the whole seconds part of the time
-	 * difference fits in a long, then the total number of usecs will
-	 * fit in an unsigned long.  Compute the total and convert it to
-	 * ticks, rounding up and adding 1 to allow for the current tick
-	 * to expire.  Rounding also depends on unsigned long arithmetic
-	 * to avoid overflow.
-	 *
-	 * Otherwise, if the number of ticks in the whole seconds part of
-	 * the time difference fits in a long, then convert the parts to
-	 * ticks separately and add, using similar rounding methods and
-	 * overflow avoidance.  This method would work in the previous
-	 * case but it is slightly slower and assumes that hz is integral.
-	 *
-	 * Otherwise, round the time difference down to the maximum
-	 * representable value.
-	 *
-	 * If ints have 32 bits, then the maximum value for any timeout in
-	 * 10ms ticks is 248 days.
-	 */
-	sec = tv->tv_sec;
-	usec = tv->tv_usec;
-	if (usec < 0) {
-		sec--;
-		usec += 1000000;
-	}
-	if (sec < 0) {
-#ifdef DIAGNOSTIC
-		if (usec > 0) {
-			sec++;
-			usec -= 1000000;
-		}
-		printf("tvotohz: negative time difference %ld sec %ld usec\n",
-		       sec, usec);
-#endif
-		ticks = 1;
-	} else if (sec <= LONG_MAX / 1000000)
-		ticks = (sec * 1000000 + (unsigned long)usec + (tick - 1))
-			/ tick + 1;
-	else if (sec <= LONG_MAX / hz)
-		ticks = sec * hz
-			+ ((unsigned long)usec + (tick - 1)) / tick + 1;
-	else
-		ticks = LONG_MAX;
-	if (ticks > INT_MAX)
-		ticks = INT_MAX;
-	return ((int)ticks);
-}
-
-/*
- * Start profiling on a process.
- *
- * Kernel profiling passes proc0 which never exits and hence
- * keeps the profile clock running constantly.
- */
-void
-startprofclock(p)
-	register struct proc *p;
-{
-	int s;
-
-	if ((p->p_flag & P_PROFIL) == 0) {
-		p->p_flag |= P_PROFIL;
-		if (++profprocs == 1 && stathz != 0) {
-			s = splstatclock();
-			psdiv = pscnt = psratio;
-			setstatclockrate(profhz);
-			splx(s);
-		}
-	}
-}
-
-/*
- * Stop profiling on a process.
- */
-void
-stopprofclock(p)
-	register struct proc *p;
-{
-	int s;
-
-	if (p->p_flag & P_PROFIL) {
-		p->p_flag &= ~P_PROFIL;
-		if (--profprocs == 0 && stathz != 0) {
-			s = splstatclock();
-			psdiv = pscnt = 1;
-			setstatclockrate(stathz);
-			splx(s);
-		}
-	}
-}
-
-/*
- * Statistics clock.  Grab profile sample, and if divider reaches 0,
- * do process and kernel statistics.  Most of the statistics are only
- * used by user-level statistics programs.  The main exceptions are
- * p->p_uticks, p->p_sticks, p->p_iticks, and p->p_estcpu.
- */
-void
-statclock(frame)
-	register struct clockframe *frame;
-{
-#ifdef GPROF
-	register struct gmonparam *g;
-	int i;
-#endif
-	register struct proc *p;
-	struct pstats *pstats;
-	long rss;
-	struct rusage *ru;
-	struct vmspace *vm;
-
-	if (curproc != NULL && CLKF_USERMODE(frame)) {
-		/*
-		 * Came from user mode; CPU was in user state.
-		 * If this process is being profiled, record the tick.
-		 */
-		p = curproc;
-		if (p->p_flag & P_PROFIL)
-			addupc_intr(p, CLKF_PC(frame), 1);
-#if defined(SMP) && defined(BETTER_CLOCK)
-		if (stathz != 0)
-			forward_statclock(pscnt);
-#endif
-		if (--pscnt > 0)
-			return;
-		/*
-		 * Charge the time as appropriate.
-		 */
-		p->p_uticks++;
-		if (p->p_nice > NZERO)
-			cp_time[CP_NICE]++;
-		else
-			cp_time[CP_USER]++;
-	} else {
-#ifdef GPROF
-		/*
-		 * Kernel statistics are just like addupc_intr, only easier.
-		 */
-		g = &_gmonparam;
-		if (g->state == GMON_PROF_ON) {
-			i = CLKF_PC(frame) - g->lowpc;
-			if (i < g->textsize) {
-				i /= HISTFRACTION * sizeof(*g->kcount);
-				g->kcount[i]++;
-			}
-		}
-#endif
-#if defined(SMP) && defined(BETTER_CLOCK)
-		if (stathz != 0)
-			forward_statclock(pscnt);
-#endif
-		if (--pscnt > 0)
-			return;
-		/*
-		 * Came from kernel mode, so we were:
-		 * - handling an interrupt,
-		 * - doing syscall or trap work on behalf of the current
-		 *   user process, or
-		 * - spinning in the idle loop.
-		 * Whichever it is, charge the time as appropriate.
-		 * Note that we charge interrupts to the current process,
-		 * regardless of whether they are ``for'' that process,
-		 * so that we know how much of its real time was spent
-		 * in ``non-process'' (i.e., interrupt) work.
-		 */
-		p = curproc;
-		if (CLKF_INTR(frame)) {
-			if (p != NULL)
-				p->p_iticks++;
-			cp_time[CP_INTR]++;
-		} else if (p != NULL) {
-			p->p_sticks++;
-			cp_time[CP_SYS]++;
-		} else
-			cp_time[CP_IDLE]++;
-	}
-	pscnt = psdiv;
-
-	if (p != NULL) {
-		schedclock(p);
-
-		/* Update resource usage integrals and maximums. */
-		if ((pstats = p->p_stats) != NULL &&
-		    (ru = &pstats->p_ru) != NULL &&
-		    (vm = p->p_vmspace) != NULL) {
-			ru->ru_ixrss += pgtok(vm->vm_tsize);
-			ru->ru_idrss += pgtok(vm->vm_dsize);
-			ru->ru_isrss += pgtok(vm->vm_ssize);
-			rss = pgtok(vmspace_resident_count(vm));
-			if (ru->ru_maxrss < rss)
-				ru->ru_maxrss = rss;
-		}
-	}
-}
-
-/*
- * Return information about system clocks.
- */
-static int
-sysctl_kern_clockrate SYSCTL_HANDLER_ARGS
-{
-	struct clockinfo clkinfo;
-	/*
-	 * Construct clockinfo structure.
-	 */
-	clkinfo.hz = hz;
-	clkinfo.tick = tick;
-	clkinfo.tickadj = tickadj;
-	clkinfo.profhz = profhz;
-	clkinfo.stathz = stathz ? stathz : hz;
-	return (sysctl_handle_opaque(oidp, &clkinfo, sizeof clkinfo, req));
-}
-
-SYSCTL_PROC(_kern, KERN_CLOCKRATE, clockrate, CTLTYPE_STRUCT|CTLFLAG_RD,
-	0, 0, sysctl_kern_clockrate, "S,clockinfo","");
-
 static __inline unsigned
 tco_delta(struct timecounter *tc)
 {
@@ -508,12 +106,9 @@ getmicrotime(struct timeval *tvp)
 {
 	struct timecounter *tc;
 
-	if (!tco_method) {
-		tc = timecounter;
-		*tvp = tc->tc_microtime;
-	} else {
-		microtime(tvp);
-	}
+	ngetmicrotime++;
+	tc = timecounter;
+	*tvp = tc->tc_microtime;
 }
 
 void
@@ -521,12 +116,9 @@ getnanotime(struct timespec *tsp)
 {
 	struct timecounter *tc;
 
-	if (!tco_method) {
-		tc = timecounter;
-		*tsp = tc->tc_nanotime;
-	} else {
-		nanotime(tsp);
-	}
+	ngetnanotime++;
+	tc = timecounter;
+	*tsp = tc->tc_nanotime;
 }
 
 void
@@ -534,6 +126,7 @@ microtime(struct timeval *tv)
 {
 	struct timecounter *tc;
 
+	nmicrotime++;
 	tc = timecounter;
 	tv->tv_sec = tc->tc_offset_sec;
 	tv->tv_usec = tc->tc_offset_micro;
@@ -553,6 +146,7 @@ nanotime(struct timespec *ts)
 	u_int64_t delta;
 	struct timecounter *tc;
 
+	nnanotime++;
 	tc = timecounter;
 	ts->tv_sec = tc->tc_offset_sec;
 	count = tco_delta(tc);
@@ -574,13 +168,10 @@ getmicrouptime(struct timeval *tvp)
 {
 	struct timecounter *tc;
 
-	if (!tco_method) {
-		tc = timecounter;
-		tvp->tv_sec = tc->tc_offset_sec;
-		tvp->tv_usec = tc->tc_offset_micro;
-	} else {
-		microuptime(tvp);
-	}
+	ngetmicrouptime++;
+	tc = timecounter;
+	tvp->tv_sec = tc->tc_offset_sec;
+	tvp->tv_usec = tc->tc_offset_micro;
 }
 
 void
@@ -588,13 +179,10 @@ getnanouptime(struct timespec *tsp)
 {
 	struct timecounter *tc;
 
-	if (!tco_method) {
-		tc = timecounter;
-		tsp->tv_sec = tc->tc_offset_sec;
-		tsp->tv_nsec = tc->tc_offset_nano >> 32;
-	} else {
-		nanouptime(tsp);
-	}
+	ngetnanouptime++;
+	tc = timecounter;
+	tsp->tv_sec = tc->tc_offset_sec;
+	tsp->tv_nsec = tc->tc_offset_nano >> 32;
 }
 
 void
@@ -602,6 +190,7 @@ microuptime(struct timeval *tv)
 {
 	struct timecounter *tc;
 
+	nmicrouptime++;
 	tc = timecounter;
 	tv->tv_sec = tc->tc_offset_sec;
 	tv->tv_usec = tc->tc_offset_micro;
@@ -619,6 +208,7 @@ nanouptime(struct timespec *ts)
 	u_int64_t delta;
 	struct timecounter *tc;
 
+	nnanouptime++;
 	tc = timecounter;
 	ts->tv_sec = tc->tc_offset_sec;
 	count = tco_delta(tc);
@@ -647,13 +237,13 @@ tco_setscales(struct timecounter *tc)
 }
 
 void
-update_timecounter(struct timecounter *tc)
+tc_update(struct timecounter *tc)
 {
 	tco_setscales(tc);
 }
 
 void
-init_timecounter(struct timecounter *tc)
+tc_init(struct timecounter *tc)
 {
 	struct timespec ts1;
 	struct timecounter *t1, *t2, *t3;
@@ -696,7 +286,7 @@ init_timecounter(struct timecounter *tc)
 }
 
 void
-set_timecounter(struct timespec *ts)
+tc_setclock(struct timespec *ts)
 {
 	struct timespec ts2;
 
@@ -708,7 +298,7 @@ set_timecounter(struct timespec *ts)
 		boottime.tv_sec--;
 	}
 	/* fiddle all the little crinkly bits around the fiords... */
-	tco_forward(1);
+	tc_windup();
 }
 
 static void
@@ -754,8 +344,8 @@ sync_other_counter(void)
 	return (tc);
 }
 
-static void
-tco_forward(int force)
+void
+tc_windup(void)
 {
 	struct timecounter *tc, *tco;
 	struct timeval tvt;
@@ -792,12 +382,8 @@ tco_forward(int force)
 		tc->tc_offset_sec++;
 		ntp_update_second(tc);	/* XXX only needed if xntpd runs */
 		tco_setscales(tc);
-		force++;
 	}
 
-	if (tco_method && !force)
-		return;
-
 	tc->tc_offset_micro = (tc->tc_offset_nano / 1000) >> 32;
 
 	/* Figure out the wall-clock time */
@@ -815,15 +401,6 @@ tco_forward(int force)
 	timecounter = tc;
 }
 
-SYSCTL_NODE(_kern, OID_AUTO, timecounter, CTLFLAG_RW, 0, "");
-
-SYSCTL_INT(_kern_timecounter, OID_AUTO, method, CTLFLAG_RW, &tco_method, 0,
-    "This variable determines the method used for updating timecounters. "
-    "If the default algorithm (0) fails with \"calcru negative...\" messages "
-    "try the alternate algorithm (1) which handles bad hardware better."
-
-);
-
 static int
 sysctl_kern_timecounter_hardware SYSCTL_HANDLER_ARGS
 {
diff --git a/sys/kern/kern_time.c b/sys/kern/kern_time.c
index 7c06c50..64b9f34 100644
--- a/sys/kern/kern_time.c
+++ b/sys/kern/kern_time.c
@@ -45,6 +45,7 @@
 #include <sys/sysent.h>
 #include <sys/proc.h>
 #include <sys/time.h>
+#include <sys/timetc.h>
 #include <sys/vnode.h>
 #include <vm/vm.h>
 #include <vm/vm_extern.h>
@@ -128,7 +129,7 @@ settime(tv)
 
 	ts.tv_sec = tv->tv_sec;
 	ts.tv_nsec = tv->tv_usec * 1000;
-	set_timecounter(&ts);
+	tc_setclock(&ts);
 	(void) splsoftclock();
 	lease_updatetime(delta.tv_sec);
 	splx(s);
diff --git a/sys/pci/xrpu.c b/sys/pci/xrpu.c
index 44d2b76..9688caa 100644
--- a/sys/pci/xrpu.c
+++ b/sys/pci/xrpu.c
@@ -22,6 +22,7 @@
 #include <sys/conf.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
+#include <sys/timetc.h>
 #include <sys/timepps.h>
 #include <sys/xrpuio.h>
 #include <sys/bus.h>
@@ -188,7 +189,7 @@ xrpu_ioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct proc *pr)
 			pps_init(&sc->pps[i]);
 		}
 		sc->mode = TIMECOUNTER;
-		init_timecounter(&sc->tc);
+		tc_init(&sc->tc);
 		return (0);
 	}
 	error = ENOTTY;
diff --git a/sys/sys/time.h b/sys/sys/time.h
index d7bbc83..74274f8 100644
--- a/sys/sys/time.h
+++ b/sys/sys/time.h
@@ -79,86 +79,6 @@ struct timezone {
 #define	DST_EET		5	/* Eastern European dst */
 #define	DST_CAN		6	/* Canada */
 
-/*
- * Structure used to interface to the machine dependent hardware support
- * for timekeeping.
- *
- * A timecounter is a (hard or soft) binary counter which has two properties:
- *    * it runs at a fixed, known frequency.
- *    * it must not roll over in less than (1 + delta)/HZ seconds.  "delta"
- *	is expected to be less than 20 msec, but no hard data has been 
- *      collected on this.  16 bit at 5 MHz (31 msec) is known to work.
- *
- * get_timecount() reads the counter.
- *
- * counter_mask removes unimplemented bits from the count value.
- *
- * frequency is the counter frequency in hz.
- *
- * name is a short mnemonic name for this counter.
- *
- * cost is a measure of how long time it takes to read the counter.
- *
- * adjustment [PPM << 16] which means that the smallest unit of correction
- *     you can apply amounts to 481.5 usec/year.
- *
- * scale_micro [2^32 * usec/tick].
- * scale_nano_i [ns/tick].
- * scale_nano_f [(ns/2^32)/tick].
- *
- * offset_count is the contents of the counter which corresponds to the
- *     rest of the offset_* values.
- *
- * offset_sec [s].
- * offset_micro [usec].
- * offset_nano [ns/2^32] is misnamed, the real unit is .23283064365...
- *     attoseconds (10E-18) and before you ask: yes, they are in fact 
- *     called attoseconds, it comes from "atten" for 18 in Danish/Swedish.
- *
- * Each timecounter must supply an array of three timecounters, this is needed
- * to guarantee atomicity in the code.  Index zero is used to transport 
- * modifications, for instance done with sysctl, into the timecounter being 
- * used in a safe way.  Such changes may be adopted with a delay of up to 1/HZ,
- * index one & two are used alternately for the actual timekeeping.
- *
- * 'tc_avail' points to the next available (external) timecounter in a
- *      circular queue.  This is only valid for index 0.
- *
- * `tc_other' points to the next "work" timecounter in a circular queue,
- *      i.e., for index i > 0 it points to index 1 + (i - 1) % NTIMECOUNTER.
- *      We also use it to point from index 0 to index 1.
- *
- * `tc_tweak' points to index 0.
- */
-
-struct timecounter;
-typedef unsigned timecounter_get_t __P((struct timecounter *));
-typedef void timecounter_pps_t __P((struct timecounter *));
-
-struct timecounter {
-	/* These fields must be initialized by the driver. */
-	timecounter_get_t	*tc_get_timecount;
-	timecounter_pps_t	*tc_poll_pps;
-	unsigned 		tc_counter_mask;
-	u_int32_t		tc_frequency;
-	char			*tc_name;
-	void			*tc_priv;
-	/* These fields will be managed by the generic code. */
-	int64_t			tc_adjustment;
-	u_int32_t		tc_scale_micro;
-	u_int32_t		tc_scale_nano_i;
-	u_int32_t		tc_scale_nano_f;
-	unsigned 		tc_offset_count;
-	u_int32_t		tc_offset_sec;
-	u_int32_t		tc_offset_micro;
-	u_int64_t		tc_offset_nano;
-	struct timeval		tc_microtime;
-	struct timespec		tc_nanotime;
-	struct timecounter	*tc_avail;
-	struct timecounter	*tc_other;
-	struct timecounter	*tc_tweak;
-};
-
 #ifdef _KERNEL
 
 /* Operations on timespecs */
@@ -266,25 +186,21 @@ struct clockinfo {
 #endif
 
 #ifdef _KERNEL
-extern struct timecounter *timecounter;
 extern time_t	time_second;
 
 void	getmicrouptime __P((struct timeval *tv));
 void	getmicrotime __P((struct timeval *tv));
 void	getnanouptime __P((struct timespec *tv));
 void	getnanotime __P((struct timespec *tv));
-void	init_timecounter __P((struct timecounter *tc));
 int	itimerdecr __P((struct itimerval *itp, int usec));
 int	itimerfix __P((struct timeval *tv));
 void	microuptime __P((struct timeval *tv));
 void	microtime __P((struct timeval *tv));
 void	nanouptime __P((struct timespec *ts));
 void	nanotime __P((struct timespec *ts));
-void	set_timecounter __P((struct timespec *ts));
 void	timevaladd __P((struct timeval *, struct timeval *));
 void	timevalsub __P((struct timeval *, struct timeval *));
 int	tvtohz __P((struct timeval *));
-void	update_timecounter __P((struct timecounter *tc));
 #else /* !_KERNEL */
 #include <time.h>
 
diff --git a/sys/sys/timetc.h b/sys/sys/timetc.h
index d7bbc83..ac62dc7 100644
--- a/sys/sys/timetc.h
+++ b/sys/sys/timetc.h
@@ -1,83 +1,16 @@
 /*
- * Copyright (c) 1982, 1986, 1993
- *	The Regents of the University of California.  All rights reserved.
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <phk@FreeBSD.ORG> wrote this file.  As long as you retain this notice you
+ * can do whatever you want with this stuff. If we meet some day, and you think
+ * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
+ * ----------------------------------------------------------------------------
  *
- * 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
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS 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.
- *
- *	@(#)time.h	8.5 (Berkeley) 5/4/95
  * $FreeBSD$
  */
 
-#ifndef _SYS_TIME_H_
-#define _SYS_TIME_H_
-
-#include <sys/types.h>
-
-/*
- * Structure returned by gettimeofday(2) system call,
- * and used in other calls.
- */
-struct timeval {
-	long	tv_sec;		/* seconds */
-	long	tv_usec;	/* and microseconds */
-};
-
-#ifndef _TIMESPEC_DECLARED
-#define _TIMESPEC_DECLARED
-struct timespec {
-	time_t	tv_sec;		/* seconds */
-	long	tv_nsec;	/* and nanoseconds */
-};
-#endif
-
-#define	TIMEVAL_TO_TIMESPEC(tv, ts)					\
-	do {								\
-		(ts)->tv_sec = (tv)->tv_sec;				\
-		(ts)->tv_nsec = (tv)->tv_usec * 1000;			\
-	} while (0)
-#define	TIMESPEC_TO_TIMEVAL(tv, ts)					\
-	do {								\
-		(tv)->tv_sec = (ts)->tv_sec;				\
-		(tv)->tv_usec = (ts)->tv_nsec / 1000;			\
-	} while (0)
-
-struct timezone {
-	int	tz_minuteswest;	/* minutes west of Greenwich */
-	int	tz_dsttime;	/* type of dst correction */
-};
-#define	DST_NONE	0	/* not on dst */
-#define	DST_USA		1	/* USA style dst */
-#define	DST_AUST	2	/* Australian style dst */
-#define	DST_WET		3	/* Western European dst */
-#define	DST_MET		4	/* Middle European dst */
-#define	DST_EET		5	/* Eastern European dst */
-#define	DST_CAN		6	/* Canada */
+#ifndef _SYS_TIMETC_H_
+#define _SYS_TIMETC_H_
 
 /*
  * Structure used to interface to the machine dependent hardware support
@@ -160,147 +93,12 @@ struct timecounter {
 };
 
 #ifdef _KERNEL
-
-/* Operations on timespecs */
-#define	timespecclear(tvp)	((tvp)->tv_sec = (tvp)->tv_nsec = 0)
-#define	timespecisset(tvp)	((tvp)->tv_sec || (tvp)->tv_nsec)
-#define	timespeccmp(tvp, uvp, cmp)					\
-	(((tvp)->tv_sec == (uvp)->tv_sec) ?				\
-	    ((tvp)->tv_nsec cmp (uvp)->tv_nsec) :			\
-	    ((tvp)->tv_sec cmp (uvp)->tv_sec))
-#define timespecadd(vvp, uvp)						\
-	do {								\
-		(vvp)->tv_sec += (uvp)->tv_sec;				\
-		(vvp)->tv_nsec += (uvp)->tv_nsec;			\
-		if ((vvp)->tv_nsec >= 1000000000) {			\
-			(vvp)->tv_sec++;				\
-			(vvp)->tv_nsec -= 1000000000;			\
-		}							\
-	} while (0)
-#define timespecsub(vvp, uvp)						\
-	do {								\
-		(vvp)->tv_sec -= (uvp)->tv_sec;				\
-		(vvp)->tv_nsec -= (uvp)->tv_nsec;			\
-		if ((vvp)->tv_nsec < 0) {				\
-			(vvp)->tv_sec--;				\
-			(vvp)->tv_nsec += 1000000000;			\
-		}							\
-	} while (0)
-
-/* Operations on timevals. */
-
-#define	timevalclear(tvp)		(tvp)->tv_sec = (tvp)->tv_usec = 0
-#define	timevalisset(tvp)		((tvp)->tv_sec || (tvp)->tv_usec)
-#define	timevalcmp(tvp, uvp, cmp)					\
-	(((tvp)->tv_sec == (uvp)->tv_sec) ?				\
-	    ((tvp)->tv_usec cmp (uvp)->tv_usec) :			\
-	    ((tvp)->tv_sec cmp (uvp)->tv_sec))
-
-/* timevaladd and timevalsub are not inlined */
-
-#endif /* _KERNEL */
-
-#ifndef _KERNEL			/* NetBSD/OpenBSD compatable interfaces */
-
-#define	timerclear(tvp)		(tvp)->tv_sec = (tvp)->tv_usec = 0
-#define	timerisset(tvp)		((tvp)->tv_sec || (tvp)->tv_usec)
-#define	timercmp(tvp, uvp, cmp)					\
-	(((tvp)->tv_sec == (uvp)->tv_sec) ?				\
-	    ((tvp)->tv_usec cmp (uvp)->tv_usec) :			\
-	    ((tvp)->tv_sec cmp (uvp)->tv_sec))
-#define timeradd(tvp, uvp, vvp)						\
-	do {								\
-		(vvp)->tv_sec = (tvp)->tv_sec + (uvp)->tv_sec;		\
-		(vvp)->tv_usec = (tvp)->tv_usec + (uvp)->tv_usec;	\
-		if ((vvp)->tv_usec >= 1000000) {			\
-			(vvp)->tv_sec++;				\
-			(vvp)->tv_usec -= 1000000;			\
-		}							\
-	} while (0)
-#define timersub(tvp, uvp, vvp)						\
-	do {								\
-		(vvp)->tv_sec = (tvp)->tv_sec - (uvp)->tv_sec;		\
-		(vvp)->tv_usec = (tvp)->tv_usec - (uvp)->tv_usec;	\
-		if ((vvp)->tv_usec < 0) {				\
-			(vvp)->tv_sec--;				\
-			(vvp)->tv_usec += 1000000;			\
-		}							\
-	} while (0)
-#endif
-
-/*
- * Names of the interval timers, and structure
- * defining a timer setting.
- */
-#define	ITIMER_REAL	0
-#define	ITIMER_VIRTUAL	1
-#define	ITIMER_PROF	2
-
-struct	itimerval {
-	struct	timeval it_interval;	/* timer interval */
-	struct	timeval it_value;	/* current value */
-};
-
-/*
- * Getkerninfo clock information structure
- */
-struct clockinfo {
-	int	hz;		/* clock frequency */
-	int	tick;		/* micro-seconds per hz tick */
-	int	tickadj;	/* clock skew rate for adjtime() */
-	int	stathz;		/* statistics clock frequency */
-	int	profhz;		/* profiling clock frequency */
-};
-
-/* CLOCK_REALTIME and TIMER_ABSTIME are supposed to be in time.h */
-
-#ifndef CLOCK_REALTIME
-#define CLOCK_REALTIME	0
-#endif
-#define CLOCK_VIRTUAL	1
-#define CLOCK_PROF	2
-
-#define TIMER_RELTIME	0x0	/* relative timer */
-#ifndef TIMER_ABSTIME
-#define TIMER_ABSTIME	0x1	/* absolute timer */
-#endif
-
-#ifdef _KERNEL
 extern struct timecounter *timecounter;
-extern time_t	time_second;
-
-void	getmicrouptime __P((struct timeval *tv));
-void	getmicrotime __P((struct timeval *tv));
-void	getnanouptime __P((struct timespec *tv));
-void	getnanotime __P((struct timespec *tv));
-void	init_timecounter __P((struct timecounter *tc));
-int	itimerdecr __P((struct itimerval *itp, int usec));
-int	itimerfix __P((struct timeval *tv));
-void	microuptime __P((struct timeval *tv));
-void	microtime __P((struct timeval *tv));
-void	nanouptime __P((struct timespec *ts));
-void	nanotime __P((struct timespec *ts));
-void	set_timecounter __P((struct timespec *ts));
-void	timevaladd __P((struct timeval *, struct timeval *));
-void	timevalsub __P((struct timeval *, struct timeval *));
-int	tvtohz __P((struct timeval *));
-void	update_timecounter __P((struct timecounter *tc));
-#else /* !_KERNEL */
-#include <time.h>
-
-#include <sys/cdefs.h>
-
-__BEGIN_DECLS
-int	adjtime __P((const struct timeval *, struct timeval *));
-int	futimes __P((int, const struct timeval *));
-int	getitimer __P((int, struct itimerval *));
-int	gettimeofday __P((struct timeval *, struct timezone *));
-int	lutimes __P((const char *, const struct timeval *));
-int	setitimer __P((int, const struct itimerval *, struct itimerval *));
-int	settimeofday __P((const struct timeval *, const struct timezone *));
-int	utimes __P((const char *, const struct timeval *));
-__END_DECLS
 
+void	tc_init __P((struct timecounter *tc));
+void	tc_setclock __P((struct timespec *ts));
+void	tc_windup __P((void));
+void	tc_update __P((struct timecounter *tc));
 #endif /* !_KERNEL */
 
-#endif /* !_SYS_TIME_H_ */
+#endif /* !_SYS_TIMETC_H_ */