![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to adjtimed.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / adjtimed|
Return to adjtimed.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / adjtimed |
1.1 misho 1: /*************************************************************************/
2: /* (c) Copyright Tai Jin, 1988. All Rights Reserved. */
3: /* Hewlett-Packard Laboratories. */
4: /* */
5: /* Permission is hereby granted for unlimited modification, use, and */
6: /* distribution. This software is made available with no warranty of */
7: /* any kind, express or implied. This copyright notice must remain */
8: /* intact in all versions of this software. */
9: /* */
10: /* The author would appreciate it if any bug fixes and enhancements were */
11: /* to be sent back to him for incorporation into future versions of this */
12: /* software. Please send changes to tai@iag.hp.com or ken@sdd.hp.com. */
13: /*************************************************************************/
14:
15: #ifndef lint
16: static char RCSid[] = "adjtimed.c,v 3.1 1993/07/06 01:04:45 jbj Exp";
17: #endif
18:
19: /*
20: * Adjust time daemon.
21: * This daemon adjusts the rate of the system clock a la BSD's adjtime().
22: * The adjtime() routine uses SYSV messages to communicate with this daemon.
23: *
24: * Caveat: This emulation uses an undocumented kernel variable. As such, it
25: * cannot be guaranteed to work in future HP-UX releases. Fortunately,
26: * it will no longer be needed in HPUX 10.01 and later.
27: */
28:
29: #include <sys/param.h>
30: #include <sys/types.h>
31: #include <sys/ipc.h>
32: #include <sys/msg.h>
33: #include <sys/lock.h>
34: #include <time.h>
35: #include <signal.h>
36: #include <nlist.h>
37: #include <fcntl.h>
38: #include <stdio.h>
39: #include <unistd.h>
40:
41: #include "ntp_syslog.h"
42: #include "ntp_stdlib.h"
43:
44: #include "adjtime.h"
45:
46: double atof (const char *);
47:
48: int InitClockRate (void);
49: int AdjustClockRate (register struct timeval *delta, register struct timeval *olddelta);
50: long GetClockRate (void);
51: int SetClockRate (long);
52: void ResetClockRate (void);
53: void Cleanup (void);
54: void Exit (int);
55:
56: #define MILLION 1000000L
57:
58: /* emacs cc-mode goes nuts if we split the next line... */
59: #define tvtod(tv) ((double)tv.tv_sec + ((double)tv.tv_usec / (double)MILLION))
60:
61: char *progname = NULL;
62: int verbose = 0;
63: int sysdebug = 0;
64: static int mqid;
65: static double oldrate = 0.0;
66:
67: int
68: main(
69: int argc,
70: char *argv[]
71: )
72: {
73: struct timeval remains;
74: struct sigvec vec;
75: MsgBuf msg;
76: char ch;
77: int nofork = 0;
78: int fd;
79:
80: progname = argv[0];
81:
82: #ifdef LOG_LOCAL6
83: openlog("adjtimed", LOG_PID, LOG_LOCAL6);
84: #else
85: openlog("adjtimed", LOG_PID);
86: #endif
87:
88: while ((ch = ntp_getopt(argc, argv, "hkrvdfp:")) != EOF) {
89: switch (ch) {
90: case 'k':
91: case 'r':
92: if ((mqid = msgget(KEY, 0)) != -1) {
93: if (msgctl(mqid, IPC_RMID, (struct msqid_ds *)0) == -1) {
94: msyslog(LOG_ERR, "remove old message queue: %m");
95: perror("adjtimed: remove old message queue");
96: exit(1);
97: }
98: }
99:
100: if (ch == 'k')
101: exit(0);
102:
103: break;
104:
105: case 'v':
106: ++verbose, nofork = 1;
107: break;
108:
109: case 'd':
110: ++sysdebug;
111: break;
112:
113: case 'f':
114: nofork = 1;
115: break;
116:
117: case 'p':
118: fputs("adjtimed: -p option ignored\n", stderr);
119: break;
120:
121: default:
122: puts("usage: adjtimed -hkrvdf");
123: puts("-h\thelp");
124: puts("-k\tkill existing adjtimed, if any");
125: puts("-r\trestart (kills existing adjtimed, if any)");
126: puts("-v\tdebug output (repeat for more output)");
127: puts("-d\tsyslog output (repeat for more output)");
128: puts("-f\tno fork");
129: msyslog(LOG_ERR, "usage error");
130: exit(1);
131: } /* switch */
132: } /* while */
133:
134: if (!nofork) {
135: switch (fork()) {
136: case 0:
137: close(fileno(stdin));
138: close(fileno(stdout));
139: close(fileno(stderr));
140:
141: #ifdef TIOCNOTTY
142: if ((fd = open("/dev/tty")) != -1) {
143: ioctl(fd, TIOCNOTTY, 0);
144: close(fd);
145: }
146: #else
147: setpgrp();
148: #endif
149: break;
150:
151: case -1:
152: msyslog(LOG_ERR, "fork: %m");
153: perror("adjtimed: fork");
154: exit(1);
155:
156: default:
157: exit(0);
158: } /* switch */
159: } /* if */
160:
161: if (nofork) {
162: setvbuf(stdout, NULL, _IONBF, BUFSIZ);
163: setvbuf(stderr, NULL, _IONBF, BUFSIZ);
164: }
165:
166: msyslog(LOG_INFO, "started");
167: if (verbose) printf("adjtimed: started\n");
168:
169: if (InitClockRate() == -1)
170: Exit(2);
171:
172: (void)signal(SIGHUP, SIG_IGN);
173: (void)signal(SIGINT, SIG_IGN);
174: (void)signal(SIGQUIT, SIG_IGN);
175: (void)signal(SIGTERM, Cleanup);
176:
177: vec.sv_handler = ResetClockRate;
178: vec.sv_flags = 0;
179: vec.sv_mask = ~0;
180: sigvector(SIGALRM, &vec, (struct sigvec *)0);
181:
182: if (msgget(KEY, IPC_CREAT|IPC_EXCL) == -1) {
183: if (errno == EEXIST) {
184: msyslog(LOG_ERR, "message queue already exists, use -r to remove it");
185: fputs("adjtimed: message queue already exists, use -r to remove it\n",
186: stderr);
187: Exit(1);
188: }
189:
190: msyslog(LOG_ERR, "create message queue: %m");
191: perror("adjtimed: create message queue");
192: Exit(1);
193: }
194:
195: if ((mqid = msgget(KEY, 0)) == -1) {
196: msyslog(LOG_ERR, "get message queue id: %m");
197: perror("adjtimed: get message queue id");
198: Exit(1);
199: }
200:
201: /* Lock process in memory to improve response time */
202: if (plock(PROCLOCK)) {
203: msyslog(LOG_ERR, "plock: %m");
204: perror("adjtimed: plock");
205: Cleanup();
206: }
207:
208: /* Also raise process priority.
209: * If we do not get run when we want, this leads to bad timekeeping
210: * and "Previous time adjustment didn't complete" gripes from xntpd.
211: */
212: if (nice(-10) == -1) {
213: msyslog(LOG_ERR, "nice: %m");
214: perror("adjtimed: nice");
215: Cleanup();
216: }
217:
218: for (;;) {
219: if (msgrcv(mqid, &msg.msgp, MSGSIZE, CLIENT, 0) == -1) {
220: if (errno == EINTR) continue;
221: msyslog(LOG_ERR, "read message: %m");
222: perror("adjtimed: read message");
223: Cleanup();
224: }
225:
226: switch (msg.msgb.code) {
227: case DELTA1:
228: case DELTA2:
229: AdjustClockRate(&msg.msgb.tv, &remains);
230:
231: if (msg.msgb.code == DELTA2) {
232: msg.msgb.tv = remains;
233: msg.msgb.mtype = SERVER;
234:
235: while (msgsnd(mqid, &msg.msgp, MSGSIZE, 0) == -1) {
236: if (errno == EINTR) continue;
237: msyslog(LOG_ERR, "send message: %m");
238: perror("adjtimed: send message");
239: Cleanup();
240: }
241: }
242:
243: if (remains.tv_sec + remains.tv_usec != 0L) {
244: if (verbose) {
245: printf("adjtimed: previous correction remaining %.6fs\n",
246: tvtod(remains));
247: }
248: if (sysdebug) {
249: msyslog(LOG_INFO, "previous correction remaining %.6fs",
250: tvtod(remains));
251: }
252: }
253: break;
254:
255: default:
256: fprintf(stderr, "adjtimed: unknown message code %d\n", msg.msgb.code);
257: msyslog(LOG_ERR, "unknown message code %d", msg.msgb.code);
258: } /* switch */
259: } /* loop */
260: } /* main */
261:
262: /*
263: * Default clock rate (old_tick).
264: */
265: #define DEFAULT_RATE (MILLION / HZ)
266: #define UNKNOWN_RATE 0L
267: #define TICK_ADJ 5 /* standard adjustment rate, microsec/tick */
268:
269: static long default_rate = DEFAULT_RATE;
270: static long tick_rate = HZ; /* ticks per sec */
271: static long slew_rate = TICK_ADJ * HZ; /* in microsec/sec */
272:
273: int
274: AdjustClockRate(
275: register struct timeval *delta,
276: register struct timeval *olddelta
277: )
278: {
279: register long rate, dt, leftover;
280: struct itimerval period, remains;
281:
282: dt = (delta->tv_sec * MILLION) + delta->tv_usec;
283:
284: if (verbose)
285: printf("adjtimed: new correction %.6fs\n", (double)dt / (double)MILLION);
286: if (sysdebug)
287: msyslog(LOG_INFO, "new correction %.6fs", (double)dt / (double)MILLION);
288: if (verbose > 2) printf("adjtimed: leftover %ldus\n", leftover);
289: if (sysdebug > 2) msyslog(LOG_INFO, "leftover %ldus", leftover);
290: rate = dt;
291:
292: /*
293: * Apply a slew rate of slew_rate over a period of dt/slew_rate seconds.
294: */
295: if (dt > 0) {
296: rate = slew_rate;
297: } else {
298: rate = -slew_rate;
299: dt = -dt;
300: }
301: period.it_value.tv_sec = dt / slew_rate;
302: period.it_value.tv_usec = (dt % slew_rate) * (MILLION / slew_rate);
303: /*
304: * Note: we assume the kernel will convert the specified period into ticks
305: * using the modified clock rate rather than an assumed nominal clock rate,
306: * and therefore will generate the timer interrupt after the specified
307: * number of true seconds, not skewed seconds.
308: */
309:
310: if (verbose > 1)
311: printf("adjtimed: will be complete in %lds %ldus\n",
312: period.it_value.tv_sec, period.it_value.tv_usec);
313: if (sysdebug > 1)
314: msyslog(LOG_INFO, "will be complete in %lds %ldus",
315: period.it_value.tv_sec, period.it_value.tv_usec);
316: /*
317: * adjust the clock rate
318: */
319: if (dt) {
320: if (SetClockRate((rate / tick_rate) + default_rate) == -1) {
321: msyslog(LOG_ERR, "set clock rate: %m");
322: perror("adjtimed: set clock rate");
323: }
324: }
325: /*
326: * start the timer
327: * (do this after changing the rate because the period has been rounded down)
328: */
329: period.it_interval.tv_sec = period.it_interval.tv_usec = 0L;
330: setitimer(ITIMER_REAL, &period, &remains);
331: /*
332: * return old delta
333: */
334: if (olddelta) {
335: dt = ((remains.it_value.tv_sec * MILLION) + remains.it_value.tv_usec) *
336: oldrate;
337: olddelta->tv_sec = dt / MILLION;
338: olddelta->tv_usec = dt - (olddelta->tv_sec * MILLION);
339: }
340:
341: oldrate = (double)rate / (double)MILLION;
342: return(0);
343: } /* AdjustClockRate */
344:
345: static struct nlist nl[] = {
346: #ifdef __hp9000s800
347: #ifdef PRE7_0
348: { "tick" },
349: #else
350: { "old_tick" },
351: #endif
352: #else
353: { "_old_tick" },
354: #endif
355: { "" }
356: };
357:
358: static int kmem;
359:
360: /*
361: * The return value is the clock rate in old_tick units or -1 if error.
362: */
363: long
364: GetClockRate(void)
365: {
366: long rate, mask;
367:
368: if (lseek(kmem, (off_t)nl[0].n_value, 0) == -1L)
369: return (-1L);
370:
371: mask = sigblock(sigmask(SIGALRM));
372:
373: if (read(kmem, (caddr_t)&rate, sizeof(rate)) != sizeof(rate))
374: rate = UNKNOWN_RATE;
375:
376: sigsetmask(mask);
377: return (rate);
378: } /* GetClockRate */
379:
380: /*
381: * The argument is the new rate in old_tick units.
382: */
383: int
384: SetClockRate(
385: long rate
386: )
387: {
388: long mask;
389:
390: if (lseek(kmem, (off_t)nl[0].n_value, 0) == -1L)
391: return (-1);
392:
393: mask = sigblock(sigmask(SIGALRM));
394:
395: if (write(kmem, (caddr_t)&rate, sizeof(rate)) != sizeof(rate)) {
396: sigsetmask(mask);
397: return (-1);
398: }
399:
400: sigsetmask(mask);
401:
402: if (rate != default_rate) {
403: if (verbose > 3) {
404: printf("adjtimed: clock rate (%lu) %ldus/s\n", rate,
405: (rate - default_rate) * tick_rate);
406: }
407: if (sysdebug > 3) {
408: msyslog(LOG_INFO, "clock rate (%lu) %ldus/s", rate,
409: (rate - default_rate) * tick_rate);
410: }
411: }
412:
413: return (0);
414: } /* SetClockRate */
415:
416: int
417: InitClockRate(void)
418: {
419: if ((kmem = open("/dev/kmem", O_RDWR)) == -1) {
420: msyslog(LOG_ERR, "open(/dev/kmem): %m");
421: perror("adjtimed: open(/dev/kmem)");
422: return (-1);
423: }
424:
425: nlist("/hp-ux", nl);
426:
427: if (nl[0].n_type == 0) {
428: fputs("adjtimed: /hp-ux has no symbol table\n", stderr);
429: msyslog(LOG_ERR, "/hp-ux has no symbol table");
430: return (-1);
431: }
432: /*
433: * Set the default to the system's original value
434: */
435: default_rate = GetClockRate();
436: if (default_rate == UNKNOWN_RATE) default_rate = DEFAULT_RATE;
437: tick_rate = (MILLION / default_rate);
438: slew_rate = TICK_ADJ * tick_rate;
439: fprintf(stderr,"default_rate=%ld, tick_rate=%ld, slew_rate=%ld\n",default_rate,tick_rate,slew_rate);
440:
441: return (0);
442: } /* InitClockRate */
443:
444: /*
445: * Reset the clock rate to the default value.
446: */
447: void
448: ResetClockRate(void)
449: {
450: struct itimerval it;
451:
452: it.it_value.tv_sec = it.it_value.tv_usec = 0L;
453: setitimer(ITIMER_REAL, &it, (struct itimerval *)0);
454:
455: if (verbose > 2) puts("adjtimed: resetting the clock");
456: if (sysdebug > 2) msyslog(LOG_INFO, "resetting the clock");
457:
458: if (GetClockRate() != default_rate) {
459: if (SetClockRate(default_rate) == -1) {
460: msyslog(LOG_ERR, "set clock rate: %m");
461: perror("adjtimed: set clock rate");
462: }
463: }
464:
465: oldrate = 0.0;
466: } /* ResetClockRate */
467:
468: void
469: Cleanup(void)
470: {
471: ResetClockRate();
472:
473: if (msgctl(mqid, IPC_RMID, (struct msqid_ds *)0) == -1) {
474: if (errno != EINVAL) {
475: msyslog(LOG_ERR, "remove message queue: %m");
476: perror("adjtimed: remove message queue");
477: }
478: }
479:
480: Exit(2);
481: } /* Cleanup */
482:
483: void
484: Exit(status)
485: int status;
486: {
487: msyslog(LOG_ERR, "terminated");
488: closelog();
489: if (kmem != -1) close(kmem);
490: exit(status);
491: } /* Exit */