Various cleanup and sorting of clock reading functions. Add the two

functions missing in the complete 12 function complement.

2 files changed, 114 insertions, 77 deletions

diff --git a/sys/kern/kern_tc.c b/sys/kern/kern_tc.c
index 51f70fe..d403847 100644
--- a/sys/kern/kern_tc.c
+++ b/sys/kern/kern_tc.c
@@ -39,26 +39,16 @@ SYSCTL_STRUCT(_kern, KERN_BOOTTIME, boottime, CTLFLAG_RD,
 
 SYSCTL_NODE(_kern, OID_AUTO, timecounter, CTLFLAG_RW, 0, "");
 
-static unsigned nbintime;
-static unsigned nbinuptime;
-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, nbintime, CTLFLAG_RD, &nbintime, 0, "");
-SYSCTL_INT(_kern_timecounter, OID_AUTO, nbinuptime, CTLFLAG_RD, &nbinuptime, 0, "");
-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, "");
+#define TC_STATS(foo) \
+	static unsigned foo; \
+	SYSCTL_INT(_kern_timecounter, OID_AUTO, foo, CTLFLAG_RD, & foo, 0, "")
+
+TC_STATS(nbinuptime);    TC_STATS(nnanouptime);    TC_STATS(nmicrouptime);
+TC_STATS(nbintime);      TC_STATS(nnanotime);      TC_STATS(nmicrotime);
+TC_STATS(ngetbinuptime); TC_STATS(ngetnanouptime); TC_STATS(ngetmicrouptime);
+TC_STATS(ngetbintime);   TC_STATS(ngetnanotime);   TC_STATS(ngetmicrotime);
+
+#undef TC_STATS
 
 /*
  * Implement a dummy timecounter which we can use until we get a real one
@@ -72,7 +62,7 @@ dummy_get_timecount(struct timecounter *tc)
 	static unsigned now;
 
 	if (tc->tc_generation == 0)
-		tc->tc_generation++;
+		tc->tc_generation = 1;
 	return (++now);
 }
 
@@ -94,17 +84,6 @@ tc_delta(struct timecounter *tc)
 	    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
 binuptime(struct bintime *bt)
 {
@@ -121,6 +100,26 @@ binuptime(struct bintime *bt)
 }
 
 void
+nanouptime(struct timespec *ts)
+{
+	struct bintime bt;
+
+	nnanouptime++;
+	binuptime(&bt);
+	bintime2timespec(&bt, ts);
+}
+
+void
+microuptime(struct timeval *tv)
+{
+	struct bintime bt;
+
+	nmicrouptime++;
+	binuptime(&bt);
+	bintime2timeval(&bt, tv);
+}
+
+void
 bintime(struct bintime *bt)
 {
 
@@ -130,54 +129,54 @@ bintime(struct bintime *bt)
 }
 
 void
-getmicrotime(struct timeval *tvp)
+nanotime(struct timespec *ts)
+{
+	struct bintime bt;
+
+	nnanotime++;
+	bintime(&bt);
+	bintime2timespec(&bt, ts);
+}
+
+void
+microtime(struct timeval *tv)
+{
+	struct bintime bt;
+
+	nmicrotime++;
+	bintime(&bt);
+	bintime2timeval(&bt, tv);
+}
+
+void
+getbinuptime(struct bintime *bt)
 {
 	struct timecounter *tc;
 	unsigned gen;
 
-	ngetmicrotime++;
+	ngetbinuptime++;
 	do {
 		tc = timecounter;
 		gen = tc->tc_generation;
-		*tvp = tc->tc_microtime;
+		*bt = tc->tc_offset;
 	} while (gen == 0 || gen != tc->tc_generation);
 }
 
 void
-getnanotime(struct timespec *tsp)
+getnanouptime(struct timespec *tsp)
 {
 	struct timecounter *tc;
 	unsigned gen;
 
-	ngetnanotime++;
+	ngetnanouptime++;
 	do {
 		tc = timecounter;
 		gen = tc->tc_generation;
-		*tsp = tc->tc_nanotime;
+		bintime2timespec(&tc->tc_offset, tsp);
 	} while (gen == 0 || gen != tc->tc_generation);
 }
 
 void
-microtime(struct timeval *tv)
-{
-	struct bintime bt;
-
-	nmicrotime++;
-	bintime(&bt);
-	bintime2timeval(&bt, tv);
-}
-
-void
-nanotime(struct timespec *ts)
-{
-	struct bintime bt;
-
-	nnanotime++;
-	bintime(&bt);
-	bintime2timespec(&bt, ts);
-}
-
-void
 getmicrouptime(struct timeval *tvp)
 {
 	struct timecounter *tc;
@@ -192,37 +191,46 @@ getmicrouptime(struct timeval *tvp)
 }
 
 void
-getnanouptime(struct timespec *tsp)
+getbintime(struct bintime *bt)
 {
 	struct timecounter *tc;
 	unsigned gen;
 
-	ngetnanouptime++;
+	ngetbintime++;
 	do {
 		tc = timecounter;
 		gen = tc->tc_generation;
-		bintime2timespec(&tc->tc_offset, tsp);
+		*bt = tc->tc_offset;
 	} while (gen == 0 || gen != tc->tc_generation);
+	bintime_add(bt, &boottimebin);
 }
 
 void
-microuptime(struct timeval *tv)
+getnanotime(struct timespec *tsp)
 {
-	struct bintime bt;
+	struct timecounter *tc;
+	unsigned gen;
 
-	nmicrouptime++;
-	binuptime(&bt);
-	bintime2timeval(&bt, tv);
+	ngetnanotime++;
+	do {
+		tc = timecounter;
+		gen = tc->tc_generation;
+		*tsp = tc->tc_nanotime;
+	} while (gen == 0 || gen != tc->tc_generation);
 }
 
 void
-nanouptime(struct timespec *ts)
+getmicrotime(struct timeval *tvp)
 {
-	struct bintime bt;
+	struct timecounter *tc;
+	unsigned gen;
 
-	nnanouptime++;
-	binuptime(&bt);
-	bintime2timespec(&bt, ts);
+	ngetmicrotime++;
+	do {
+		tc = timecounter;
+		gen = tc->tc_generation;
+		*tvp = tc->tc_microtime;
+	} while (gen == 0 || gen != tc->tc_generation);
 }
 
 static void
diff --git a/sys/sys/time.h b/sys/sys/time.h
index 2312e08..8a66105 100644
--- a/sys/sys/time.h
+++ b/sys/sys/time.h
@@ -282,18 +282,47 @@ struct clockinfo {
 #ifdef _KERNEL
 extern time_t	time_second;
 
+/*-
+ * Functions for looking at our clock: [get]{bin,nano,micro}[up]time()
+ *
+ * Functions without the "get" prefix returns the best timestamp
+ * we can produce in the given format.
+ *
+ * "bin"   == struct bintime  == seconds + 64 bit fraction of seconds.
+ * "nano"  == struct timespec == seconds + nanoseconds.
+ * "micro" == struct timeval  == seconds + microseconds.
+ *              
+ * Functions containing "up" returns time relative to boot and
+ * should be used for calculating time intervals.
+ *
+ * Functions without "up" returns GMT time.
+ *
+ * Functions with the "get" prefix returns a less precise result
+ * much faster than the functions without "get" prefix and should
+ * be used where a precision of 10 msec is acceptable or where
+ * performance is priority. (NB: "precision", _not_ "resolution" !) 
+ * 
+ */
+
 void	binuptime(struct bintime *bt);
+void	nanouptime(struct timespec *ts);
+void	microuptime(struct timeval *tv);
+
 void	bintime(struct bintime *bt);
-void	getmicrouptime(struct timeval *tv);
-void	getmicrotime(struct timeval *tv);
+void	nanotime(struct timespec *ts);
+void	microtime(struct timeval *tv);
+
+void	getbinuptime(struct bintime *bt);
 void	getnanouptime(struct timespec *tsp);
+void	getmicrouptime(struct timeval *tv);
+
+void	getbintime(struct bintime *bt);
 void	getnanotime(struct timespec *tsp);
+void	getmicrotime(struct timeval *tv);
+
+/* other prototypes */
 int	itimerdecr(struct itimerval *itp, int usec);
 int	itimerfix(struct timeval *tv);
-void	microuptime(struct timeval *tv);
-void	microtime(struct timeval *tv);
-void	nanouptime(struct timespec *ts);
-void	nanotime(struct timespec *ts);
 void	timevaladd(struct timeval *, struct timeval *);
 void	timevalsub(struct timeval *, struct timeval *);
 int	tvtohz(struct timeval *);