1: /*
2: * refclock_shm - clock driver for utc via shared memory
3: * - under construction -
4: * To add new modes: Extend or union the shmTime-struct. Do not
5: * extend/shrink size, because otherwise existing implementations
6: * will specify wrong size of shared memory-segment
7: * PB 18.3.97
8: */
9:
10: #ifdef HAVE_CONFIG_H
11: # include <config.h>
12: #endif
13:
14: #if defined(REFCLOCK) && defined(CLOCK_SHM)
15:
16: #include "ntpd.h"
17: #undef fileno
18: #include "ntp_io.h"
19: #undef fileno
20: #include "ntp_refclock.h"
21: #undef fileno
22: #include "ntp_unixtime.h"
23: #undef fileno
24: #include "ntp_stdlib.h"
25:
26: #undef fileno
27: #include <ctype.h>
28: #undef fileno
29:
30: #ifndef SYS_WINNT
31: # include <sys/ipc.h>
32: # include <sys/shm.h>
33: # include <assert.h>
34: # include <unistd.h>
35: # include <stdio.h>
36: #endif
37:
38: /*
39: * This driver supports a reference clock attached thru shared memory
40: */
41:
42: /* Temp hack to simplify testing of the old mode. */
43: #define OLDWAY 0
44:
45: /*
46: * SHM interface definitions
47: */
48: #define PRECISION (-1) /* precision assumed (0.5 s) */
49: #define REFID "SHM" /* reference ID */
50: #define DESCRIPTION "SHM/Shared memory interface"
51:
52: #define NSAMPLES 3 /* stages of median filter */
53:
54: /*
55: * Function prototypes
56: */
57: static int shm_start (int unit, struct peer *peer);
58: static void shm_shutdown (int unit, struct peer *peer);
59: static void shm_poll (int unit, struct peer *peer);
60: static void shm_timer (int unit, struct peer *peer);
61: int shm_peek (int unit, struct peer *peer);
62: void shm_clockstats (int unit, struct peer *peer);
63:
64: /*
65: * Transfer vector
66: */
67: struct refclock refclock_shm = {
68: shm_start, /* start up driver */
69: shm_shutdown, /* shut down driver */
70: shm_poll, /* transmit poll message */
71: noentry, /* not used: control */
72: noentry, /* not used: init */
73: noentry, /* not used: buginfo */
74: shm_timer, /* once per second */
75: };
76:
77: struct shmTime {
78: int mode; /* 0 - if valid set
79: * use values,
80: * clear valid
81: * 1 - if valid set
82: * if count before and after read of values is equal,
83: * use values
84: * clear valid
85: */
86: int count;
87: time_t clockTimeStampSec;
88: int clockTimeStampUSec;
89: time_t receiveTimeStampSec;
90: int receiveTimeStampUSec;
91: int leap;
92: int precision;
93: int nsamples;
94: int valid;
95: int dummy[10];
96: };
97:
98: struct shmunit {
99: struct shmTime *shm; /* pointer to shared memory segment */
100:
101: /* debugging/monitoring counters - reset when printed */
102: int ticks; /* number of attempts to read data*/
103: int good; /* number of valid samples */
104: int notready; /* number of peeks without data ready */
105: int bad; /* number of invalid samples */
106: int clash; /* number of access clashes while reading */
107: };
108:
109:
110: struct shmTime *getShmTime(int);
111:
112: struct shmTime *getShmTime (int unit) {
113: #ifndef SYS_WINNT
114: int shmid=0;
115:
116: /* 0x4e545030 is NTP0.
117: * Big units will give non-ascii but that's OK
118: * as long as everybody does it the same way.
119: */
120: shmid=shmget (0x4e545030+unit, sizeof (struct shmTime),
121: IPC_CREAT|(unit<2?0600:0666));
122: if (shmid==-1) { /*error */
123: msyslog(LOG_ERR,"SHM shmget (unit %d): %s",unit,strerror(errno));
124: return 0;
125: }
126: else { /* no error */
127: struct shmTime *p=(struct shmTime *)shmat (shmid, 0, 0);
128: if ((int)(long)p==-1) { /* error */
129: msyslog(LOG_ERR,"SHM shmat (unit %d): %s",unit,strerror(errno));
130: return 0;
131: }
132: return p;
133: }
134: #else
135: char buf[10];
136: LPSECURITY_ATTRIBUTES psec=0;
137: HANDLE shmid=0;
138: SECURITY_DESCRIPTOR sd;
139: SECURITY_ATTRIBUTES sa;
140: snprintf(buf, sizeof(buf), "NTP%d", unit);
141: if (unit >= 2) { /* world access */
142: if (!InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION)) {
143: msyslog(LOG_ERR,"SHM InitializeSecurityDescriptor (unit %d): %m",unit);
144: return 0;
145: }
146: if (!SetSecurityDescriptorDacl(&sd,1,0,0)) {
147: msyslog(LOG_ERR,"SHM SetSecurityDescriptorDacl (unit %d): %m",unit);
148: return 0;
149: }
150: sa.nLength=sizeof (SECURITY_ATTRIBUTES);
151: sa.lpSecurityDescriptor=&sd;
152: sa.bInheritHandle=0;
153: psec=&sa;
154: }
155: shmid=CreateFileMapping ((HANDLE)0xffffffff, psec, PAGE_READWRITE,
156: 0, sizeof (struct shmTime),buf);
157: if (!shmid) { /*error*/
158: char buf[1000];
159: FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM,
160: 0, GetLastError (), 0, buf, sizeof (buf), 0);
161: msyslog(LOG_ERR,"SHM CreateFileMapping (unit %d): %s",unit,buf);
162: return 0;
163: }
164: else {
165: struct shmTime *p=(struct shmTime *) MapViewOfFile (shmid,
166: FILE_MAP_WRITE, 0, 0, sizeof (struct shmTime));
167: if (p==0) { /*error*/
168: char buf[1000];
169: FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM,
170: 0, GetLastError (), 0, buf, sizeof (buf), 0);
171: msyslog(LOG_ERR,"SHM MapViewOfFile (unit %d): %s",unit,buf);
172: return 0;
173: }
174: return p;
175: }
176: #endif
177: }
178: /*
179: * shm_start - attach to shared memory
180: */
181: static int
182: shm_start(
183: int unit,
184: struct peer *peer
185: )
186: {
187: struct refclockproc *pp;
188: struct shmunit *up;
189:
190: pp = peer->procptr;
191: pp->io.clock_recv = noentry;
192: pp->io.srcclock = (caddr_t)peer;
193: pp->io.datalen = 0;
194: pp->io.fd = -1;
195:
196: up = emalloc(sizeof(*up));
197: memset(up, 0, sizeof(*up));
198: pp->unitptr = (caddr_t)up;
199:
200: up->shm = getShmTime(unit);
201:
202: /*
203: * Initialize miscellaneous peer variables
204: */
205: memcpy((char *)&pp->refid, REFID, 4);
206: if (up->shm != 0) {
207: up->shm->precision = PRECISION;
208: peer->precision = up->shm->precision;
209: up->shm->valid=0;
210: up->shm->nsamples=NSAMPLES;
211: pp->clockdesc = DESCRIPTION;
212: return (1);
213: }
214: else {
215: return 0;
216: }
217: }
218:
219:
220: /*
221: * shm_shutdown - shut down the clock
222: */
223: static void
224: shm_shutdown(
225: int unit,
226: struct peer *peer
227: )
228: {
229: struct refclockproc *pp;
230: struct shmunit *up;
231:
232: pp = peer->procptr;
233: up = (struct shmunit *)pp->unitptr;
234:
235: if (NULL == up)
236: return;
237: #ifndef SYS_WINNT
238: /* HMS: shmdt()wants char* or const void * */
239: (void) shmdt ((char *)up->shm);
240: #else
241: UnmapViewOfFile (up->shm);
242: #endif
243: free(up);
244: }
245:
246:
247: /*
248: * shm_timer - called every second
249: */
250: static void
251: shm_timer(int unit, struct peer *peer)
252: {
253: if (OLDWAY)
254: return;
255:
256: shm_peek(unit, peer);
257: }
258:
259:
260: /*
261: * shm_poll - called by the transmit procedure
262: */
263: static void
264: shm_poll(
265: int unit,
266: struct peer *peer
267: )
268: {
269: struct refclockproc *pp;
270: int ok;
271:
272: pp = peer->procptr;
273:
274: if (OLDWAY) {
275: ok = shm_peek(unit, peer);
276: if (!ok) return;
277: }
278:
279: /*
280: * Process median filter samples. If none received, declare a
281: * timeout and keep going.
282: */
283: if (pp->coderecv == pp->codeproc) {
284: refclock_report(peer, CEVNT_TIMEOUT);
285: shm_clockstats(unit, peer);
286: return;
287: }
288: pp->lastref = pp->lastrec;
289: refclock_receive(peer);
290: shm_clockstats(unit, peer);
291: }
292:
293: /*
294: * shm_peek - try to grab a sample
295: */
296: int shm_peek(
297: int unit,
298: struct peer *peer
299: )
300: {
301: struct refclockproc *pp;
302: struct shmunit *up;
303: struct shmTime *shm;
304:
305: /*
306: * This is the main routine. It snatches the time from the shm
307: * board and tacks on a local timestamp.
308: */
309: pp = peer->procptr;
310: up = (struct shmunit*)pp->unitptr;
311: up->ticks++;
312: if (up->shm == 0) {
313: /* try to map again - this may succeed if meanwhile some-
314: body has ipcrm'ed the old (unaccessible) shared mem segment */
315: up->shm = getShmTime(unit);
316: }
317: shm = up->shm;
318: if (shm == 0) {
319: refclock_report(peer, CEVNT_FAULT);
320: return(0);
321: }
322: if (shm->valid) {
323: struct timeval tvr;
324: struct timeval tvt;
325: struct tm *t;
326: int ok=1;
327: tvr.tv_sec = 0;
328: tvr.tv_usec = 0;
329: tvt.tv_sec = 0;
330: tvt.tv_usec = 0;
331: switch (shm->mode) {
332: case 0: {
333: tvr.tv_sec=shm->receiveTimeStampSec;
334: tvr.tv_usec=shm->receiveTimeStampUSec;
335: tvt.tv_sec=shm->clockTimeStampSec;
336: tvt.tv_usec=shm->clockTimeStampUSec;
337: }
338: break;
339: case 1: {
340: int cnt=shm->count;
341: tvr.tv_sec=shm->receiveTimeStampSec;
342: tvr.tv_usec=shm->receiveTimeStampUSec;
343: tvt.tv_sec=shm->clockTimeStampSec;
344: tvt.tv_usec=shm->clockTimeStampUSec;
345: ok=(cnt==shm->count);
346: }
347: break;
348: default:
349: msyslog (LOG_ERR, "SHM: bad mode found in shared memory: %d",shm->mode);
350: }
351: shm->valid=0;
352: if (ok) {
353: time_t help; /* XXX NetBSD has incompatible tv_sec */
354:
355: TVTOTS(&tvr,&pp->lastrec);
356: pp->lastrec.l_ui += JAN_1970;
357: /* pp->lasttime = current_time; */
358: pp->polls++;
359: help = tvt.tv_sec;
360: t = gmtime (&help);
361: pp->day=t->tm_yday+1;
362: pp->hour=t->tm_hour;
363: pp->minute=t->tm_min;
364: pp->second=t->tm_sec;
365: pp->nsec=tvt.tv_usec * 1000;
366: peer->precision=shm->precision;
367: pp->leap=shm->leap;
368: }
369: else {
370: refclock_report(peer, CEVNT_FAULT);
371: msyslog (LOG_NOTICE, "SHM: access clash in shared memory");
372: up->clash++;
373: return(0);
374: }
375: }
376: else {
377: refclock_report(peer, CEVNT_TIMEOUT);
378: up->notready++;
379: return(0);
380: }
381: if (!refclock_process(pp)) {
382: refclock_report(peer, CEVNT_BADTIME);
383: up->bad++;
384: return(0);
385: }
386: up->good++;
387: return(1);
388: }
389:
390: /*
391: * shm_clockstats - dump and reset counters
392: */
393: void shm_clockstats(
394: int unit,
395: struct peer *peer
396: )
397: {
398: struct refclockproc *pp;
399: struct shmunit *up;
400: char logbuf[256];
401:
402: pp = peer->procptr;
403: up = (struct shmunit*)pp->unitptr;
404:
405: if (!(pp->sloppyclockflag & CLK_FLAG4)) return;
406:
407: snprintf(logbuf, sizeof(logbuf), "%3d %3d %3d %3d %3d",
408: up->ticks, up->good, up->notready, up->bad, up->clash);
409: record_clock_stats(&peer->srcadr, logbuf);
410:
411: up->ticks = up->good = up->notready =up->bad = up->clash = 0;
412:
413: }
414:
415: #else
416: int refclock_shm_bs;
417: #endif /* REFCLOCK */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_shm.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 / ntpd