1/*
2 * timespecops.c -- calculations on 'struct timespec' values
3 *
4 * Written by Juergen Perlinger (perlinger@ntp.org) for the NTP project.
5 * The contents of 'html/copyright.html' apply.
6 *
7 */
8
9#include "config.h"
10
11#include <sys/types.h>
12#include <stdio.h>
13#include <math.h>
14
15#include "ntp.h"
16#include "timetoa.h"
17#include "timespecops.h"
18
19
20/* nanoseconds per second */
21#define NANOSECONDS 1000000000
22
23/* conversion between l_fp fractions and nanoseconds */
24#ifdef HAVE_U_INT64
25# define FTOTVN(tsf)						\
26	((int32)						\
27	 (((u_int64)(tsf) * NANOSECONDS + 0x80000000) >> 32))
28# define TVNTOF(tvu)						\
29	((u_int32)						\
30	 ((((u_int64)(tvu) << 32) + NANOSECONDS / 2) /		\
31	  NANOSECONDS))
32#else
33# define NSECFRAC	(FRAC / NANOSECONDS)
34# define FTOTVN(tsf)						\
35	((int32)((tsf) / NSECFRAC + 0.5))
36# define TVNTOF(tvu)						\
37	((u_int32)((tvu) * NSECFRAC + 0.5))
38#endif
39
40
41
42/* make sure nanoseconds are in nominal range */
43struct timespec
44normalize_tspec(
45	struct timespec x
46	)
47{
48#if SIZEOF_LONG > 4
49	long	z;
50
51	/*
52	 * tv_nsec is of type 'long', and on a 64-bit machine using only
53	 * loops becomes prohibitive once the upper 32 bits get
54	 * involved. On the other hand, division by constant should be
55	 * fast enough; so we do a division of the nanoseconds in that
56	 * case. The floor adjustment step follows with the standard
57	 * normalisation loops. And labs() is intentionally not used
58	 * here: it has implementation-defined behaviour when applied
59	 * to LONG_MIN.
60	 */
61	if (x.tv_nsec < -3l * NANOSECONDS ||
62	    x.tv_nsec > 3l * NANOSECONDS) {
63		z = x.tv_nsec / NANOSECONDS;
64		x.tv_nsec -= z * NANOSECONDS;
65		x.tv_sec += z;
66	}
67#endif
68	/* since 10**9 is close to 2**32, we don't divide but do a
69	 * normalisation in a loop; this takes 3 steps max, and should
70	 * outperform a division even if the mul-by-inverse trick is
71	 * employed. */
72	if (x.tv_nsec < 0)
73		do {
74			x.tv_nsec += NANOSECONDS;
75			x.tv_sec--;
76		} while (x.tv_nsec < 0);
77	else if (x.tv_nsec >= NANOSECONDS)
78		do {
79			x.tv_nsec -= NANOSECONDS;
80			x.tv_sec++;
81		} while (x.tv_nsec >= NANOSECONDS);
82
83	return x;
84}
85
86/* x = abs(a) */
87struct timespec
88abs_tspec(
89	struct timespec	a
90	)
91{
92	struct timespec	c;
93
94	c = normalize_tspec(a);
95	if (c.tv_sec < 0) {
96		if (c.tv_nsec != 0) {
97			c.tv_sec = -c.tv_sec - 1;
98			c.tv_nsec = NANOSECONDS - c.tv_nsec;
99		} else {
100			c.tv_sec = -c.tv_sec;
101		}
102	}
103
104	return c;
105}
106
107/*
108 * compare previously-normalised a and b
109 * return 1 / 0 / -1 if a < / == / > b
110 */
111int
112cmp_tspec(
113	struct timespec a,
114	struct timespec b
115	)
116{
117	int r;
118
119	r = (a.tv_sec > b.tv_sec) - (a.tv_sec < b.tv_sec);
120	if (0 == r)
121		r = (a.tv_nsec > b.tv_nsec) -
122		    (a.tv_nsec < b.tv_nsec);
123
124	return r;
125}
126
127/*
128 * test previously-normalised a
129 * return 1 / 0 / -1 if a < / == / > 0
130 */
131int
132test_tspec(
133	struct timespec	a
134	)
135{
136	int		r;
137
138	r = (a.tv_sec > 0) - (a.tv_sec < 0);
139	if (r == 0)
140		r = (a.tv_nsec > 0);
141
142	return r;
143}
144
145/*
146 *  convert to l_fp type, relative and absolute
147 */
148
149/* convert from timespec duration to l_fp duration */
150l_fp
151tspec_intv_to_lfp(
152	struct timespec	x
153	)
154{
155	struct timespec	v;
156	l_fp		y;
157
158	v = normalize_tspec(x);
159	y.l_uf = TVNTOF(v.tv_nsec);
160	y.l_i = (int32)v.tv_sec;
161
162	return y;
163}
164
165/* convert from l_fp type, relative signed/unsigned and absolute */
166struct timespec
167lfp_intv_to_tspec(
168	l_fp		x
169	)
170{
171	struct timespec out;
172	l_fp		absx;
173	int		neg;
174
175	neg = L_ISNEG(&x);
176	absx = x;
177	if (neg) {
178		L_NEG(&absx);
179	}
180	out.tv_nsec = FTOTVN(absx.l_uf);
181	out.tv_sec = absx.l_i;
182	if (neg) {
183		out.tv_sec = -out.tv_sec;
184		out.tv_nsec = -out.tv_nsec;
185		out = normalize_tspec(out);
186	}
187
188	return out;
189}
190
191struct timespec
192lfp_uintv_to_tspec(
193	l_fp		x
194	)
195{
196	struct timespec	out;
197
198	out.tv_nsec = FTOTVN(x.l_uf);
199	out.tv_sec = x.l_ui;
200
201	return out;
202}
203
204/*
205 * absolute (timestamp) conversion. Input is time in NTP epoch, output
206 * is in UN*X epoch. The NTP time stamp will be expanded around the
207 * pivot time *p or the current time, if p is NULL.
208 */
209struct timespec
210lfp_stamp_to_tspec(
211	l_fp		x,
212	const time_t *	p
213	)
214{
215	struct timespec	out;
216	vint64		sec;
217
218	sec = ntpcal_ntp_to_time(x.l_ui, p);
219	out.tv_nsec = FTOTVN(x.l_uf);
220
221	/* copying a vint64 to a time_t needs some care... */
222#if SIZEOF_TIME_T <= 4
223	out.tv_sec = (time_t)sec.d_s.lo;
224#elif defined(HAVE_INT64)
225	out.tv_sec = (time_t)sec.q_s;
226#else
227	out.tv_sec = ((time_t)sec.d_s.hi << 32) | sec.d_s.lo;
228#endif
229
230	return out;
231}
232
233/* -*-EOF-*- */
234