PageRenderTime 27ms CodeModel.GetById 10ms app.highlight 13ms RepoModel.GetById 1ms app.codeStats 0ms

/contrib/ntp/libntp/adjtime.c

https://bitbucket.org/freebsd/freebsd-head/
C | 386 lines | 204 code | 50 blank | 132 comment | 38 complexity | f9729c26362ef54a2abb8e3f95fef779 MD5 | raw file
  1#ifdef HAVE_CONFIG_H
  2# include <config.h>
  3#endif
  4
  5#ifdef MPE 
  6/*
  7 * MPE lacks adjtime(), so we define our own.  But note that time slewing has
  8 * a sub-second accuracy bug documented in SR 5003462838 which prevents ntpd
  9 * from being able to maintain clock synch.  Because of the bug, this adjtime()
 10 * implementation as used by ntpd has a side-effect of screwing up the hardware
 11 * PDC clock, which will need to be reset with a reboot.
 12 *
 13 * This problem affects all versions of MPE at the time of this writing (when
 14 * MPE/iX 7.0 is the most current).  It only causes bad things to happen when
 15 * doing continuous clock synchronization with ntpd; note that you CAN run ntpd
 16 * with "disable ntp" in ntp.conf if you wish to provide a time server.
 17 *
 18 * The one-time clock adjustment functionality of ntpdate and ntp_timeset can
 19 * be used without screwing up the PDC clock.
 20 * 
 21 */
 22#include <time.h>
 23
 24int adjtime(struct timeval *delta, struct timeval *olddelta);
 25
 26int adjtime(struct timeval *delta, struct timeval *olddelta)
 27
 28{
 29/* Documented, supported MPE system intrinsics. */
 30
 31extern void GETPRIVMODE(void);
 32extern void GETUSERMODE(void);
 33
 34/* Undocumented, unsupported MPE internal functions. */
 35
 36extern long long current_correction_usecs(void);
 37extern long long get_time(void);
 38extern void get_time_change_info(long long *, char *, char *);
 39extern long long pdc_time(int *);
 40extern void set_time_correction(long long, int, int);
 41extern long long ticks_to_micro(long long);
 42
 43long long big_sec, big_usec, new_correction = 0LL;
 44long long prev_correction;
 45
 46if (delta != NULL) {
 47  /* Adjustment required.  Convert delta to 64-bit microseconds. */
 48  big_sec = (long)delta->tv_sec;
 49  big_usec = delta->tv_usec;
 50  new_correction = (big_sec * 1000000LL) + big_usec;
 51}
 52
 53GETPRIVMODE();
 54
 55/* Determine how much of a previous correction (if any) we're interrupting. */
 56prev_correction = current_correction_usecs();
 57
 58if (delta != NULL) {
 59  /* Adjustment required. */
 60
 61#if 0
 62  /* Speculative code disabled until bug SR 5003462838 is fixed.  This bug
 63     prevents accurate time slewing, and indeed renders ntpd inoperable. */
 64
 65  if (prev_correction != 0LL) {
 66    /* A previous adjustment did not complete.  Since the PDC UTC clock was
 67    immediately jumped at the start of the previous adjustment, we must
 68    explicitly reset it to the value of the MPE local time clock minus the
 69    time zone offset. */
 70
 71    char pwf_since_boot, recover_pwf_time;
 72    long long offset_ticks, offset_usecs, pdc_usecs_current, pdc_usecs_wanted;
 73    int hpe_status;
 74
 75    get_time_change_info(&offset_ticks, &pwf_since_boot, &recover_pwf_time);
 76    offset_usecs = ticks_to_micro(offset_ticks);
 77    pdc_usecs_wanted = get_time() - offset_usecs;
 78    pdc_usecs_current = pdc_time(&hpe_status);
 79    if (hpe_status == 0) 
 80      /* Force new PDC time by starting an extra correction. */
 81      set_time_correction(pdc_usecs_wanted - pdc_usecs_current,0,1);
 82  }
 83#endif /* 0 */
 84    
 85  /* Immediately jump the PDC time to the new value, and then initiate a 
 86     gradual MPE time correction slew. */
 87  set_time_correction(new_correction,0,1);
 88}
 89
 90GETUSERMODE();
 91
 92if (olddelta != NULL) {
 93  /* Caller wants to know remaining amount of previous correction. */
 94  (long)olddelta->tv_sec = prev_correction / 1000000LL;
 95  olddelta->tv_usec = prev_correction % 1000000LL;
 96}
 97
 98return 0;
 99}
100#endif /* MPE */
101
102#ifdef NEED_HPUX_ADJTIME
103/*************************************************************************/
104/* (c) Copyright Tai Jin, 1988.  All Rights Reserved.                    */
105/*     Hewlett-Packard Laboratories.                                     */
106/*                                                                       */
107/* Permission is hereby granted for unlimited modification, use, and     */
108/* distribution.  This software is made available with no warranty of    */
109/* any kind, express or implied.  This copyright notice must remain      */
110/* intact in all versions of this software.                              */
111/*                                                                       */
112/* The author would appreciate it if any bug fixes and enhancements were */
113/* to be sent back to him for incorporation into future versions of this */
114/* software.  Please send changes to tai@iag.hp.com or ken@sdd.hp.com.   */
115/*************************************************************************/
116
117/*
118 * Revision history
119 *
120 * 9 Jul 94	David L. Mills, Unibergity of Delabunch
121 *		Implemented variable threshold to limit age of
122 *		corrections; reformatted code for readability.
123 */
124
125#ifndef lint
126static char RCSid[] = "adjtime.c,v 3.1 1993/07/06 01:04:42 jbj Exp";
127#endif
128
129#include <sys/types.h>
130#include <sys/ipc.h>
131#include <sys/msg.h>
132#include <time.h>
133#include <signal.h>
134#include "adjtime.h"
135
136#define abs(x)  ((x) < 0 ? -(x) : (x))
137
138/*
139 * The following paramters are appropriate for an NTP adjustment
140 * interval of one second.
141 */
142#define ADJ_THRESH 200		/* initial threshold */
143#define ADJ_DELTA 4		/* threshold decrement */
144
145static long adjthresh;		/* adjustment threshold */
146static long saveup;		/* corrections accumulator */
147
148/*
149 * clear_adjtime - reset accumulator and threshold variables
150 */
151void
152_clear_adjtime(void)
153{
154	saveup = 0;
155	adjthresh = ADJ_THRESH;
156}
157
158/*
159 * adjtime - hp-ux copout of the standard Unix adjtime() system call
160 */
161int
162adjtime(
163	register struct timeval *delta,
164	register struct timeval *olddelta
165	)
166{
167	struct timeval newdelta;
168
169	/*
170	 * Corrections greater than one second are done immediately.
171	 */
172	if (delta->tv_sec) {
173		adjthresh = ADJ_THRESH;
174		saveup = 0;
175		return(_adjtime(delta, olddelta));
176	}
177
178	/*
179	 * Corrections less than one second are accumulated until
180	 * tripping a threshold, which is initially set at ADJ_THESH and
181	 * reduced in ADJ_DELTA steps to zero. The idea here is to
182	 * introduce large corrections quickly, while making sure that
183	 * small corrections are introduced without excessive delay. The
184	 * idea comes from the ARPAnet routing update algorithm.
185	 */
186	saveup += delta->tv_usec;
187	if (abs(saveup) >= adjthresh) {
188		adjthresh = ADJ_THRESH;
189		newdelta.tv_sec = 0;
190		newdelta.tv_usec = saveup;
191		saveup = 0;
192		return(_adjtime(&newdelta, olddelta));
193	} else {
194		adjthresh -= ADJ_DELTA;
195	}
196
197	/*
198	 * While nobody uses it, return the residual before correction,
199	 * as per Unix convention.
200	 */
201	if (olddelta)
202	    olddelta->tv_sec = olddelta->tv_usec = 0;
203	return(0);
204}
205
206/*
207 * _adjtime - does the actual work
208 */
209int
210_adjtime(
211	register struct timeval *delta,
212	register struct timeval *olddelta
213	)
214{
215	register int mqid;
216	MsgBuf msg;
217	register MsgBuf *msgp = &msg;
218
219	/*
220	 * Get the key to the adjtime message queue (note that we must
221	 * get it every time because the queue might have been removed
222	 * and recreated)
223	 */
224	if ((mqid = msgget(KEY, 0)) == -1)
225	    return (-1);
226	msgp->msgb.mtype = CLIENT;
227	msgp->msgb.tv = *delta;
228	if (olddelta)
229	    msgp->msgb.code = DELTA2;
230	else
231	    msgp->msgb.code = DELTA1;
232
233	/*
234	 * Tickle adjtimed and snatch residual, if indicated. Lots of
235	 * fanatic error checking here.
236	 */
237	if (msgsnd(mqid, &msgp->msgp, MSGSIZE, 0) == -1)
238	    return (-1);
239	if (olddelta) {
240		if (msgrcv(mqid, &msgp->msgp, MSGSIZE, SERVER, 0) == -1)
241		    return (-1);
242		*olddelta = msgp->msgb.tv;
243	}
244	return (0);
245}
246
247#else
248# if NEED_QNX_ADJTIME
249/*
250 * Emulate adjtime() using QNX ClockAdjust().
251 * Chris Burghart <burghart@atd.ucar.edu>, 11/2001
252 * Miroslaw Pabich <miroslaw_pabich@o2.pl>, 09/2005
253 *
254 * This is an implementation of adjtime() for QNX.  
255 * ClockAdjust() is used to tweak the system clock for about
256 * 1 second period until the desired delta is achieved.
257 * Time correction slew is limited to reasonable value.
258 * Internal rounding and relative errors are reduced.
259 */
260# include <sys/neutrino.h>
261# include <sys/time.h>
262
263# include <ntp_stdlib.h>
264
265/*
266 * Time correction slew limit. QNX is a hard real-time system,
267 * so don't adjust system clock too fast.
268 */
269#define CORR_SLEW_LIMIT     0.02  /* [s/s] */
270
271/*
272 * Period of system clock adjustment. It should be equal to adjtime
273 * execution period (1s). If slightly less than 1s (0.95-0.99), then olddelta
274 * residual error (introduced by execution period jitter) will be reduced.
275 */
276#define ADJUST_PERIOD       0.97  /* [s] */
277
278int 
279adjtime (struct timeval *delta, struct timeval *olddelta)
280{
281    double delta_nsec;
282    double delta_nsec_old;
283    struct _clockadjust adj;
284    struct _clockadjust oldadj;
285
286    /*
287     * How many nanoseconds are we adjusting?
288     */
289    if (delta != NULL)
290	delta_nsec = 1e9 * (long)delta->tv_sec + 1e3 * delta->tv_usec;
291    else
292	delta_nsec = 0;
293
294    /*
295     * Build the adjust structure and call ClockAdjust()
296     */
297    if (delta_nsec != 0)
298    {
299	struct _clockperiod period;
300	long count;
301	long increment;
302	long increment_limit;
303	int isneg = 0;
304
305	/*
306	 * Convert to absolute value for future processing
307	 */
308	if (delta_nsec < 0)
309	{
310	    isneg = 1;
311	    delta_nsec = -delta_nsec;
312	}
313
314	/*
315	 * Get the current clock period (nanoseconds)
316	 */
317	if (ClockPeriod (CLOCK_REALTIME, 0, &period, 0) < 0)
318	    return -1;
319
320	/*
321	 * Compute count and nanoseconds increment
322	 */
323	count = 1e9 * ADJUST_PERIOD / period.nsec;
324	increment = delta_nsec / count + .5;
325	/* Reduce relative error */
326	if (count > increment + 1)
327	{
328	    increment = 1 + (long)((delta_nsec - 1) / count);
329	    count = delta_nsec / increment + .5;
330	}
331
332	/*
333	 * Limit the adjust increment to appropriate value
334	 */
335	increment_limit = CORR_SLEW_LIMIT * period.nsec;
336	if (increment > increment_limit)
337	{
338	    increment = increment_limit;
339	    count = delta_nsec / increment + .5;
340	    /* Reduce relative error */
341	    if (increment > count + 1)
342	    {
343		count =  1 + (long)((delta_nsec - 1) / increment);
344		increment = delta_nsec / count + .5;
345	    }
346	}
347
348	adj.tick_nsec_inc = isneg ? -increment : increment;
349	adj.tick_count = count;
350    }
351    else
352    {
353	adj.tick_nsec_inc = 0;
354	adj.tick_count = 0;
355    }
356
357    if (ClockAdjust (CLOCK_REALTIME, &adj, &oldadj) < 0)
358	return -1;
359
360    /*
361     * Build olddelta
362     */
363    delta_nsec_old = (double)oldadj.tick_count * oldadj.tick_nsec_inc;
364    if (olddelta != NULL)
365    {
366	if (delta_nsec_old != 0)
367	{
368	    /* Reduce rounding error */
369	    delta_nsec_old += (delta_nsec_old < 0) ? -500 : 500;
370	    olddelta->tv_sec = delta_nsec_old / 1e9;
371	    olddelta->tv_usec = (long)(delta_nsec_old - 1e9
372				 * (long)olddelta->tv_sec) / 1000;
373	}
374	else
375	{
376	    olddelta->tv_sec = 0;
377	    olddelta->tv_usec = 0;
378	}
379    }
380
381    return 0;
382}
383# else /* no special adjtime() needed */
384int adjtime_bs;
385# endif
386#endif