xref: /freebsd/contrib/ntp/ntpd/ntp_monitor.c (revision 13014ca04aad1931d41958b56f71a2c65b9a7a2c)
1 /*
2  * ntp_monitor - monitor ntpd statistics
3  */
4 #ifdef HAVE_CONFIG_H
5 # include <config.h>
6 #endif
7 
8 #include "ntpd.h"
9 #include "ntp_io.h"
10 #include "ntp_if.h"
11 #include "ntp_stdlib.h"
12 #include <ntp_random.h>
13 
14 #include <stdio.h>
15 #include <signal.h>
16 #ifdef HAVE_SYS_IOCTL_H
17 # include <sys/ioctl.h>
18 #endif
19 
20 /*
21  * I'm still not sure I like what I've done here. It certainly consumes
22  * memory like it is going out of style, and also may not be as low
23  * overhead as I'd imagined.
24  *
25  * Anyway, we record statistics based on source address, mode and
26  * version (for now, anyway. Check the code).  The receive procedure
27  * calls us with the incoming rbufp before it does anything else.
28  *
29  * Each entry is doubly linked into two lists, a hash table and a
30  * most-recently-used list. When a packet arrives it is looked up in
31  * the hash table.  If found, the statistics are updated and the entry
32  * relinked at the head of the MRU list. If not found, a new entry is
33  * allocated, initialized and linked into both the hash table and at the
34  * head of the MRU list.
35  *
36  * Memory is usually allocated by grabbing a big chunk of new memory and
37  * cutting it up into littler pieces. The exception to this when we hit
38  * the memory limit. Then we free memory by grabbing entries off the
39  * tail for the MRU list, unlinking from the hash table, and
40  * reinitializing.
41  *
42  * trimmed back memory consumption ... jdg 8/94
43  */
44 /*
45  * Limits on the number of structures allocated.  This limit is picked
46  * with the illicit knowlege that we can only return somewhat less
47  * than 8K bytes in a mode 7 response packet, and that each structure
48  * will require about 20 bytes of space in the response.
49  *
50  * ... I don't believe the above is true anymore ... jdg
51  */
52 #ifndef MAXMONMEM
53 #define	MAXMONMEM	600	/* we allocate up to 600 structures */
54 #endif
55 #ifndef MONMEMINC
56 #define	MONMEMINC	40	/* allocate them 40 at a time */
57 #endif
58 
59 /*
60  * Hashing stuff
61  */
62 #define	MON_HASH_SIZE	128
63 #define	MON_HASH_MASK	(MON_HASH_SIZE-1)
64 #define	MON_HASH(addr)	sock_hash(addr)
65 
66 /*
67  * Pointers to the hash table, the MRU list and the count table.  Memory
68  * for the hash and count tables is only allocated if monitoring is
69  * turned on.
70  */
71 static	struct mon_data *mon_hash[MON_HASH_SIZE];  /* list ptrs */
72 struct	mon_data mon_mru_list;
73 
74 /*
75  * List of free structures structures, and counters of free and total
76  * structures.  The free structures are linked with the hash_next field.
77  */
78 static  struct mon_data *mon_free;      /* free list or null if none */
79 static	int mon_total_mem;		/* total structures allocated */
80 static	int mon_mem_increments;		/* times called malloc() */
81 
82 /*
83  * Initialization state.  We may be monitoring, we may not.  If
84  * we aren't, we may not even have allocated any memory yet.
85  */
86 int	mon_enabled;			/* enable switch */
87 u_long	mon_age = 3000;			/* preemption limit */
88 static	int mon_have_memory;
89 static	void	mon_getmoremem	P((void));
90 static	void	remove_from_hash P((struct mon_data *));
91 
92 /*
93  * init_mon - initialize monitoring global data
94  */
95 void
96 init_mon(void)
97 {
98 	/*
99 	 * Don't do much of anything here.  We don't allocate memory
100 	 * until someone explicitly starts us.
101 	 */
102 	mon_enabled = MON_OFF;
103 	mon_have_memory = 0;
104 
105 	mon_total_mem = 0;
106 	mon_mem_increments = 0;
107 	mon_free = NULL;
108 	memset(&mon_hash[0], 0, sizeof mon_hash);
109 	memset(&mon_mru_list, 0, sizeof mon_mru_list);
110 }
111 
112 
113 /*
114  * mon_start - start up the monitoring software
115  */
116 void
117 mon_start(
118 	int mode
119 	)
120 {
121 
122 	if (mon_enabled != MON_OFF) {
123 		mon_enabled |= mode;
124 		return;
125 	}
126 	if (mode == MON_OFF)
127 	    return;
128 
129 	if (!mon_have_memory) {
130 		mon_total_mem = 0;
131 		mon_mem_increments = 0;
132 		mon_free = NULL;
133 		mon_getmoremem();
134 		mon_have_memory = 1;
135 	}
136 
137 	mon_mru_list.mru_next = &mon_mru_list;
138 	mon_mru_list.mru_prev = &mon_mru_list;
139 	mon_enabled = mode;
140 }
141 
142 
143 /*
144  * mon_stop - stop the monitoring software
145  */
146 void
147 mon_stop(
148 	int mode
149 	)
150 {
151 	register struct mon_data *md, *md_next;
152 	register int i;
153 
154 	if (mon_enabled == MON_OFF)
155 	    return;
156 	if ((mon_enabled & mode) == 0 || mode == MON_OFF)
157 	    return;
158 
159 	mon_enabled &= ~mode;
160 	if (mon_enabled != MON_OFF)
161 	    return;
162 
163 	/*
164 	 * Put everything back on the free list
165 	 */
166 	for (i = 0; i < MON_HASH_SIZE; i++) {
167 		md = mon_hash[i];               /* get next list */
168 		mon_hash[i] = NULL;             /* zero the list head */
169 		while (md != NULL) {
170 			md_next = md->hash_next;
171 			md->hash_next = mon_free;
172 			mon_free = md;
173 			md = md_next;
174 		}
175 	}
176 
177 	mon_mru_list.mru_next = &mon_mru_list;
178 	mon_mru_list.mru_prev = &mon_mru_list;
179 }
180 
181 void
182 ntp_monclearinterface(struct interface *interface)
183 {
184         struct mon_data *md;
185 
186 	for (md = mon_mru_list.mru_next; md != &mon_mru_list;
187 	     md = md->mru_next) {
188 	  if (md->interface == interface)
189 	    {
190 	      /* dequeue from mru list and put to free list */
191 	      md->mru_prev->mru_next = md->mru_next;
192 	      md->mru_next->mru_prev = md->mru_prev;
193 	      remove_from_hash(md);
194 	      md->hash_next = mon_free;
195 	      mon_free = md;
196 	    }
197 	}
198 }
199 
200 /*
201  * ntp_monitor - record stats about this packet
202  *
203  * Returns 1 if the packet is at the head of the list, 0 otherwise.
204  */
205 int
206 ntp_monitor(
207 	struct recvbuf *rbufp
208 	)
209 {
210 	register struct pkt *pkt;
211 	register struct mon_data *md;
212         struct sockaddr_storage addr;
213 	register int hash;
214 	register int mode;
215 
216 	if (mon_enabled == MON_OFF)
217 		return 0;
218 
219 	pkt = &rbufp->recv_pkt;
220 	memset(&addr, 0, sizeof(addr));
221 	memcpy(&addr, &(rbufp->recv_srcadr), sizeof(addr));
222 	hash = MON_HASH(&addr);
223 	mode = PKT_MODE(pkt->li_vn_mode);
224 	md = mon_hash[hash];
225 	while (md != NULL) {
226 
227 		/*
228 		 * Match address only to conserve MRU size.
229 		 */
230 		if (SOCKCMP(&md->rmtadr, &addr)) {
231 			md->drop_count = current_time - md->lasttime;
232 			md->lasttime = current_time;
233 			md->count++;
234 			md->rmtport = NSRCPORT(&rbufp->recv_srcadr);
235 			md->mode = (u_char) mode;
236 			md->version = PKT_VERSION(pkt->li_vn_mode);
237 
238 			/*
239 			 * Shuffle to the head of the MRU list.
240 			 */
241 			md->mru_next->mru_prev = md->mru_prev;
242 			md->mru_prev->mru_next = md->mru_next;
243 			md->mru_next = mon_mru_list.mru_next;
244 			md->mru_prev = &mon_mru_list;
245 			mon_mru_list.mru_next->mru_prev = md;
246 			mon_mru_list.mru_next = md;
247 			return 1;
248 		}
249 		md = md->hash_next;
250 	}
251 
252 	/*
253 	 * If we got here, this is the first we've heard of this
254 	 * guy.  Get him some memory, either from the free list
255 	 * or from the tail of the MRU list.
256 	 */
257 	if (mon_free == NULL && mon_total_mem >= MAXMONMEM) {
258 
259 		/*
260 		 * Preempt from the MRU list if old enough.
261 		 */
262 		md = mon_mru_list.mru_prev;
263 		/* We get 31 bits from ntp_random() */
264 		if (((u_long)ntp_random()) / FRAC >
265 		    (double)(current_time - md->lasttime) / mon_age)
266 			return 0;
267 
268 		md->mru_prev->mru_next = &mon_mru_list;
269 		mon_mru_list.mru_prev = md->mru_prev;
270 		remove_from_hash(md);
271 	} else {
272 		if (mon_free == NULL)
273 			mon_getmoremem();
274 		md = mon_free;
275 		mon_free = md->hash_next;
276 	}
277 
278 	/*
279 	 * Got one, initialize it
280 	 */
281 	md->avg_interval = 0;
282 	md->lasttime = current_time;
283 	md->count = 1;
284 	md->drop_count = 0;
285 	memset(&md->rmtadr, 0, sizeof(md->rmtadr));
286 	memcpy(&md->rmtadr, &addr, sizeof(addr));
287 	md->rmtport = NSRCPORT(&rbufp->recv_srcadr);
288 	md->mode = (u_char) mode;
289 	md->version = PKT_VERSION(pkt->li_vn_mode);
290 	md->interface = rbufp->dstadr;
291 	md->cast_flags = (u_char)(((rbufp->dstadr->flags & INT_MCASTOPEN) &&
292 	    rbufp->fd == md->interface->fd) ? MDF_MCAST: rbufp->fd ==
293 		md->interface->bfd ? MDF_BCAST : MDF_UCAST);
294 
295 	/*
296 	 * Drop him into front of the hash table. Also put him on top of
297 	 * the MRU list.
298 	 */
299 	md->hash_next = mon_hash[hash];
300 	mon_hash[hash] = md;
301 	md->mru_next = mon_mru_list.mru_next;
302 	md->mru_prev = &mon_mru_list;
303 	mon_mru_list.mru_next->mru_prev = md;
304 	mon_mru_list.mru_next = md;
305 	return 1;
306 }
307 
308 
309 /*
310  * mon_getmoremem - get more memory and put it on the free list
311  */
312 static void
313 mon_getmoremem(void)
314 {
315 	register struct mon_data *md;
316 	register int i;
317 	struct mon_data *freedata;      /* 'old' free list (null) */
318 
319 	md = (struct mon_data *)emalloc(MONMEMINC *
320 	    sizeof(struct mon_data));
321 	freedata = mon_free;
322 	mon_free = md;
323 	for (i = 0; i < (MONMEMINC-1); i++) {
324 		md->hash_next = (md + 1);
325 		md++;
326 	}
327 
328 	/*
329 	 * md now points at the last.  Link in the rest of the chain.
330 	 */
331 	md->hash_next = freedata;
332 	mon_total_mem += MONMEMINC;
333 	mon_mem_increments++;
334 }
335 
336 static void
337 remove_from_hash(
338 	struct mon_data *md
339 	)
340 {
341 	register int hash;
342 	register struct mon_data *md_prev;
343 
344 	hash = MON_HASH(&md->rmtadr);
345 	if (mon_hash[hash] == md) {
346 		mon_hash[hash] = md->hash_next;
347 	} else {
348 		md_prev = mon_hash[hash];
349 		while (md_prev->hash_next != md) {
350 			md_prev = md_prev->hash_next;
351 			if (md_prev == NULL) {
352 				/* logic error */
353 				return;
354 			}
355 		}
356 		md_prev->hash_next = md->hash_next;
357 	}
358 }
359