xref: /freebsd/contrib/unbound/daemon/stats.c (revision 4b9d6057)
1 /*
2  * daemon/stats.c - collect runtime performance indicators.
3  *
4  * Copyright (c) 2007, NLnet Labs. All rights reserved.
5  *
6  * This software is open source.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * Redistributions of source code must retain the above copyright notice,
13  * this list of conditions and the following disclaimer.
14  *
15  * Redistributions in binary form must reproduce the above copyright notice,
16  * this list of conditions and the following disclaimer in the documentation
17  * and/or other materials provided with the distribution.
18  *
19  * Neither the name of the NLNET LABS nor the names of its contributors may
20  * be used to endorse or promote products derived from this software without
21  * specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
29  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
30  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34  */
35 
36 /**
37  * \file
38  *
39  * This file describes the data structure used to collect runtime performance
40  * numbers. These 'statistics' may be of interest to the operator.
41  */
42 #include "config.h"
43 #ifdef HAVE_TIME_H
44 #include <time.h>
45 #endif
46 #include <sys/time.h>
47 #include <sys/types.h>
48 #include "daemon/stats.h"
49 #include "daemon/worker.h"
50 #include "daemon/daemon.h"
51 #include "services/mesh.h"
52 #include "services/outside_network.h"
53 #include "services/listen_dnsport.h"
54 #include "util/config_file.h"
55 #include "util/tube.h"
56 #include "util/timehist.h"
57 #include "util/net_help.h"
58 #include "validator/validator.h"
59 #include "iterator/iterator.h"
60 #include "sldns/sbuffer.h"
61 #include "services/cache/rrset.h"
62 #include "services/cache/infra.h"
63 #include "services/authzone.h"
64 #include "validator/val_kcache.h"
65 #include "validator/val_neg.h"
66 #ifdef CLIENT_SUBNET
67 #include "edns-subnet/subnetmod.h"
68 #endif
69 #ifdef HAVE_SSL
70 #include <openssl/ssl.h>
71 #endif
72 
73 /** How long to wait for threads to transmit statistics, in msec. */
74 #define STATS_THREAD_WAIT 60000
75 
76 /** add timers and the values do not overflow or become negative */
77 static void
78 stats_timeval_add(long long* d_sec, long long* d_usec, long long add_sec, long long add_usec)
79 {
80 #ifndef S_SPLINT_S
81 	(*d_sec) += add_sec;
82 	(*d_usec) += add_usec;
83 	if((*d_usec) >= 1000000) {
84 		(*d_usec) -= 1000000;
85 		(*d_sec)++;
86 	}
87 #endif
88 }
89 
90 void server_stats_init(struct ub_server_stats* stats, struct config_file* cfg)
91 {
92 	memset(stats, 0, sizeof(*stats));
93 	stats->extended = cfg->stat_extended;
94 }
95 
96 void server_stats_querymiss(struct ub_server_stats* stats, struct worker* worker)
97 {
98 	stats->num_queries_missed_cache++;
99 	stats->sum_query_list_size += worker->env.mesh->all.count;
100 	if((long long)worker->env.mesh->all.count > stats->max_query_list_size)
101 		stats->max_query_list_size = (long long)worker->env.mesh->all.count;
102 }
103 
104 void server_stats_prefetch(struct ub_server_stats* stats, struct worker* worker)
105 {
106 	stats->num_queries_prefetch++;
107 	/* changes the query list size so account that, like a querymiss */
108 	stats->sum_query_list_size += worker->env.mesh->all.count;
109 	if((long long)worker->env.mesh->all.count > stats->max_query_list_size)
110 		stats->max_query_list_size = (long long)worker->env.mesh->all.count;
111 }
112 
113 void server_stats_log(struct ub_server_stats* stats, struct worker* worker,
114 	int threadnum)
115 {
116 	log_info("server stats for thread %d: %u queries, "
117 		"%u answers from cache, %u recursions, %u prefetch, %u rejected by "
118 		"ip ratelimiting",
119 		threadnum, (unsigned)stats->num_queries,
120 		(unsigned)(stats->num_queries -
121 			stats->num_queries_missed_cache),
122 		(unsigned)stats->num_queries_missed_cache,
123 		(unsigned)stats->num_queries_prefetch,
124 		(unsigned)stats->num_queries_ip_ratelimited);
125 	log_info("server stats for thread %d: requestlist max %u avg %g "
126 		"exceeded %u jostled %u", threadnum,
127 		(unsigned)stats->max_query_list_size,
128 		(stats->num_queries_missed_cache+stats->num_queries_prefetch)?
129 			(double)stats->sum_query_list_size/
130 			(double)(stats->num_queries_missed_cache+
131 			stats->num_queries_prefetch) : 0.0,
132 		(unsigned)worker->env.mesh->stats_dropped,
133 		(unsigned)worker->env.mesh->stats_jostled);
134 }
135 
136 
137 #ifdef CLIENT_SUBNET
138 /** Set the EDNS Subnet stats. */
139 static void
140 set_subnet_stats(struct worker* worker, struct ub_server_stats* svr,
141 	int reset)
142 {
143 	int m = modstack_find(&worker->env.mesh->mods, "subnetcache");
144 	struct subnet_env* sne;
145 	if(m == -1)
146 		return;
147 	sne = (struct subnet_env*)worker->env.modinfo[m];
148 	if(reset && !worker->env.cfg->stat_cumulative) {
149 		lock_rw_wrlock(&sne->biglock);
150 	} else {
151 		lock_rw_rdlock(&sne->biglock);
152 	}
153 	svr->num_query_subnet = (long long)(sne->num_msg_nocache + sne->num_msg_cache);
154 	svr->num_query_subnet_cache = (long long)sne->num_msg_cache;
155 	if(reset && !worker->env.cfg->stat_cumulative) {
156 		sne->num_msg_cache = 0;
157 		sne->num_msg_nocache = 0;
158 	}
159 	lock_rw_unlock(&sne->biglock);
160 }
161 #endif /* CLIENT_SUBNET */
162 
163 /** Set the neg cache stats. */
164 static void
165 set_neg_cache_stats(struct worker* worker, struct ub_server_stats* svr,
166 	int reset)
167 {
168 	int m = modstack_find(&worker->env.mesh->mods, "validator");
169 	struct val_env* ve;
170 	struct val_neg_cache* neg;
171 	if(m == -1)
172 		return;
173 	ve = (struct val_env*)worker->env.modinfo[m];
174 	if(!ve->neg_cache)
175 		return;
176 	neg = ve->neg_cache;
177 	lock_basic_lock(&neg->lock);
178 	svr->num_neg_cache_noerror = (long long)neg->num_neg_cache_noerror;
179 	svr->num_neg_cache_nxdomain = (long long)neg->num_neg_cache_nxdomain;
180 	if(reset && !worker->env.cfg->stat_cumulative) {
181 		neg->num_neg_cache_noerror = 0;
182 		neg->num_neg_cache_nxdomain = 0;
183 	}
184 	lock_basic_unlock(&neg->lock);
185 }
186 
187 /** get rrsets bogus number from validator */
188 static size_t
189 get_rrset_bogus(struct worker* worker, int reset)
190 {
191 	int m = modstack_find(&worker->env.mesh->mods, "validator");
192 	struct val_env* ve;
193 	size_t r;
194 	if(m == -1)
195 		return 0;
196 	ve = (struct val_env*)worker->env.modinfo[m];
197 	lock_basic_lock(&ve->bogus_lock);
198 	r = ve->num_rrset_bogus;
199 	if(reset && !worker->env.cfg->stat_cumulative)
200 		ve->num_rrset_bogus = 0;
201 	lock_basic_unlock(&ve->bogus_lock);
202 	return r;
203 }
204 
205 /** get number of ratelimited queries from iterator */
206 static size_t
207 get_queries_ratelimit(struct worker* worker, int reset)
208 {
209 	int m = modstack_find(&worker->env.mesh->mods, "iterator");
210 	struct iter_env* ie;
211 	size_t r;
212 	if(m == -1)
213 		return 0;
214 	ie = (struct iter_env*)worker->env.modinfo[m];
215 	lock_basic_lock(&ie->queries_ratelimit_lock);
216 	r = ie->num_queries_ratelimited;
217 	if(reset && !worker->env.cfg->stat_cumulative)
218 		ie->num_queries_ratelimited = 0;
219 	lock_basic_unlock(&ie->queries_ratelimit_lock);
220 	return r;
221 }
222 
223 #ifdef USE_DNSCRYPT
224 /** get the number of shared secret cache miss */
225 static size_t
226 get_dnscrypt_cache_miss(struct worker* worker, int reset)
227 {
228 	size_t r;
229 	struct dnsc_env* de = worker->daemon->dnscenv;
230 	if(!de) return 0;
231 
232 	lock_basic_lock(&de->shared_secrets_cache_lock);
233 	r = de->num_query_dnscrypt_secret_missed_cache;
234 	if(reset && !worker->env.cfg->stat_cumulative)
235 		de->num_query_dnscrypt_secret_missed_cache = 0;
236 	lock_basic_unlock(&de->shared_secrets_cache_lock);
237 	return r;
238 }
239 
240 /** get the number of replayed queries */
241 static size_t
242 get_dnscrypt_replay(struct worker* worker, int reset)
243 {
244 	size_t r;
245 	struct dnsc_env* de = worker->daemon->dnscenv;
246 
247 	lock_basic_lock(&de->nonces_cache_lock);
248 	r = de->num_query_dnscrypt_replay;
249 	if(reset && !worker->env.cfg->stat_cumulative)
250 		de->num_query_dnscrypt_replay = 0;
251 	lock_basic_unlock(&de->nonces_cache_lock);
252 	return r;
253 }
254 #endif /* USE_DNSCRYPT */
255 
256 void
257 server_stats_compile(struct worker* worker, struct ub_stats_info* s, int reset)
258 {
259 	int i;
260 	struct listen_list* lp;
261 
262 	s->svr = worker->stats;
263 	s->mesh_num_states = (long long)worker->env.mesh->all.count;
264 	s->mesh_num_reply_states = (long long)worker->env.mesh->num_reply_states;
265 	s->mesh_jostled = (long long)worker->env.mesh->stats_jostled;
266 	s->mesh_dropped = (long long)worker->env.mesh->stats_dropped;
267 	s->mesh_replies_sent = (long long)worker->env.mesh->replies_sent;
268 	s->mesh_replies_sum_wait_sec = (long long)worker->env.mesh->replies_sum_wait.tv_sec;
269 	s->mesh_replies_sum_wait_usec = (long long)worker->env.mesh->replies_sum_wait.tv_usec;
270 	s->mesh_time_median = timehist_quartile(worker->env.mesh->histogram,
271 		0.50);
272 
273 	/* add in the values from the mesh */
274 	s->svr.ans_secure += (long long)worker->env.mesh->ans_secure;
275 	s->svr.ans_bogus += (long long)worker->env.mesh->ans_bogus;
276 	s->svr.ans_rcode_nodata += (long long)worker->env.mesh->ans_nodata;
277 	s->svr.ans_expired += (long long)worker->env.mesh->ans_expired;
278 	for(i=0; i<UB_STATS_RCODE_NUM; i++)
279 		s->svr.ans_rcode[i] += (long long)worker->env.mesh->ans_rcode[i];
280 	for(i=0; i<UB_STATS_RPZ_ACTION_NUM; i++)
281 		s->svr.rpz_action[i] += (long long)worker->env.mesh->rpz_action[i];
282 	timehist_export(worker->env.mesh->histogram, s->svr.hist,
283 		NUM_BUCKETS_HIST);
284 	/* values from outside network */
285 	s->svr.unwanted_replies = (long long)worker->back->unwanted_replies;
286 	s->svr.qtcp_outgoing = (long long)worker->back->num_tcp_outgoing;
287 	s->svr.qudp_outgoing = (long long)worker->back->num_udp_outgoing;
288 
289 	/* get and reset validator rrset bogus number */
290 	s->svr.rrset_bogus = (long long)get_rrset_bogus(worker, reset);
291 
292 	/* get and reset iterator query ratelimit number */
293 	s->svr.queries_ratelimited = (long long)get_queries_ratelimit(worker, reset);
294 
295 	/* get cache sizes */
296 	get_slabhash_stats(worker->env.msg_cache,
297 		&s->svr.msg_cache_count, &s->svr.msg_cache_max_collisions);
298 	get_slabhash_stats(&worker->env.rrset_cache->table,
299 		&s->svr.rrset_cache_count, &s->svr.rrset_cache_max_collisions);
300 	s->svr.infra_cache_count = (long long)count_slabhash_entries(worker->env.infra_cache->hosts);
301 	if(worker->env.key_cache)
302 		s->svr.key_cache_count = (long long)count_slabhash_entries(worker->env.key_cache->slab);
303 	else	s->svr.key_cache_count = 0;
304 
305 #ifdef USE_DNSCRYPT
306 	if(worker->daemon->dnscenv) {
307 		s->svr.num_query_dnscrypt_secret_missed_cache =
308 			(long long)get_dnscrypt_cache_miss(worker, reset);
309 		s->svr.shared_secret_cache_count = (long long)count_slabhash_entries(
310 			worker->daemon->dnscenv->shared_secrets_cache);
311 		s->svr.nonce_cache_count = (long long)count_slabhash_entries(
312 			worker->daemon->dnscenv->nonces_cache);
313 		s->svr.num_query_dnscrypt_replay =
314 			(long long)get_dnscrypt_replay(worker, reset);
315 	} else {
316 		s->svr.num_query_dnscrypt_secret_missed_cache = 0;
317 		s->svr.shared_secret_cache_count = 0;
318 		s->svr.nonce_cache_count = 0;
319 		s->svr.num_query_dnscrypt_replay = 0;
320 	}
321 #else
322 	s->svr.num_query_dnscrypt_secret_missed_cache = 0;
323 	s->svr.shared_secret_cache_count = 0;
324 	s->svr.nonce_cache_count = 0;
325 	s->svr.num_query_dnscrypt_replay = 0;
326 #endif /* USE_DNSCRYPT */
327 	if(worker->env.auth_zones) {
328 		if(reset && !worker->env.cfg->stat_cumulative) {
329 			lock_rw_wrlock(&worker->env.auth_zones->lock);
330 		} else {
331 			lock_rw_rdlock(&worker->env.auth_zones->lock);
332 		}
333 		s->svr.num_query_authzone_up = (long long)worker->env.
334 			auth_zones->num_query_up;
335 		s->svr.num_query_authzone_down = (long long)worker->env.
336 			auth_zones->num_query_down;
337 		if(reset && !worker->env.cfg->stat_cumulative) {
338 			worker->env.auth_zones->num_query_up = 0;
339 			worker->env.auth_zones->num_query_down = 0;
340 		}
341 		lock_rw_unlock(&worker->env.auth_zones->lock);
342 	}
343 	s->svr.mem_stream_wait =
344 		(long long)tcp_req_info_get_stream_buffer_size();
345 	s->svr.mem_http2_query_buffer =
346 		(long long)http2_get_query_buffer_size();
347 	s->svr.mem_http2_response_buffer =
348 		(long long)http2_get_response_buffer_size();
349 
350 	/* Set neg cache usage numbers */
351 	set_neg_cache_stats(worker, &s->svr, reset);
352 #ifdef CLIENT_SUBNET
353 	/* EDNS Subnet usage numbers */
354 	set_subnet_stats(worker, &s->svr, reset);
355 #else
356 	s->svr.num_query_subnet = 0;
357 	s->svr.num_query_subnet_cache = 0;
358 #endif
359 #ifdef USE_CACHEDB
360 	s->svr.num_query_cachedb = (long long)worker->env.mesh->ans_cachedb;
361 #else
362 	s->svr.num_query_cachedb = 0;
363 #endif
364 
365 	/* get tcp accept usage */
366 	s->svr.tcp_accept_usage = 0;
367 	for(lp = worker->front->cps; lp; lp = lp->next) {
368 		if(lp->com->type == comm_tcp_accept)
369 			s->svr.tcp_accept_usage += (long long)lp->com->cur_tcp_count;
370 	}
371 
372 	if(reset && !worker->env.cfg->stat_cumulative) {
373 		worker_stats_clear(worker);
374 	}
375 }
376 
377 void server_stats_obtain(struct worker* worker, struct worker* who,
378 	struct ub_stats_info* s, int reset)
379 {
380 	uint8_t *reply = NULL;
381 	uint32_t len = 0;
382 	if(worker == who) {
383 		/* just fill it in */
384 		server_stats_compile(worker, s, reset);
385 		return;
386 	}
387 	/* communicate over tube */
388 	verbose(VERB_ALGO, "write stats cmd");
389 	if(reset)
390 		worker_send_cmd(who, worker_cmd_stats);
391 	else 	worker_send_cmd(who, worker_cmd_stats_noreset);
392 	verbose(VERB_ALGO, "wait for stats reply");
393 	if(tube_wait_timeout(worker->cmd, STATS_THREAD_WAIT) == 0) {
394 		verbose(VERB_OPS, "no response from thread %d"
395 #ifdef HAVE_GETTID
396 			" LWP %u"
397 #endif
398 #if defined(HAVE_PTHREAD) && defined(SIZEOF_PTHREAD_T) && defined(SIZEOF_UNSIGNED_LONG)
399 #  if SIZEOF_PTHREAD_T == SIZEOF_UNSIGNED_LONG
400 			" pthread 0x%lx"
401 #  endif
402 #endif
403 			,
404 			who->thread_num
405 #ifdef HAVE_GETTID
406 			, (unsigned)who->thread_tid
407 #endif
408 #if defined(HAVE_PTHREAD) && defined(SIZEOF_PTHREAD_T) && defined(SIZEOF_UNSIGNED_LONG)
409 #  if SIZEOF_PTHREAD_T == SIZEOF_UNSIGNED_LONG
410 			, (unsigned long)*((unsigned long*)&who->thr_id)
411 #  endif
412 #endif
413 			);
414 	}
415 	if(!tube_read_msg(worker->cmd, &reply, &len, 0))
416 		fatal_exit("failed to read stats over cmd channel");
417 	if(len != (uint32_t)sizeof(*s))
418 		fatal_exit("stats on cmd channel wrong length %d %d",
419 			(int)len, (int)sizeof(*s));
420 	memcpy(s, reply, (size_t)len);
421 	free(reply);
422 }
423 
424 void server_stats_reply(struct worker* worker, int reset)
425 {
426 	struct ub_stats_info s;
427 	server_stats_compile(worker, &s, reset);
428 	verbose(VERB_ALGO, "write stats replymsg");
429 	if(!tube_write_msg(worker->daemon->workers[0]->cmd,
430 		(uint8_t*)&s, sizeof(s), 0))
431 		fatal_exit("could not write stat values over cmd channel");
432 }
433 
434 void server_stats_add(struct ub_stats_info* total, struct ub_stats_info* a)
435 {
436 	total->svr.num_queries += a->svr.num_queries;
437 	total->svr.num_queries_ip_ratelimited += a->svr.num_queries_ip_ratelimited;
438 	total->svr.num_queries_cookie_valid += a->svr.num_queries_cookie_valid;
439 	total->svr.num_queries_cookie_client += a->svr.num_queries_cookie_client;
440 	total->svr.num_queries_cookie_invalid += a->svr.num_queries_cookie_invalid;
441 	total->svr.num_queries_missed_cache += a->svr.num_queries_missed_cache;
442 	total->svr.num_queries_prefetch += a->svr.num_queries_prefetch;
443 	total->svr.num_queries_timed_out += a->svr.num_queries_timed_out;
444 	if (total->svr.max_query_time_us < a->svr.max_query_time_us)
445 		total->svr.max_query_time_us = a->svr.max_query_time_us;
446 	total->svr.sum_query_list_size += a->svr.sum_query_list_size;
447 	total->svr.ans_expired += a->svr.ans_expired;
448 #ifdef USE_DNSCRYPT
449 	total->svr.num_query_dnscrypt_crypted += a->svr.num_query_dnscrypt_crypted;
450 	total->svr.num_query_dnscrypt_cert += a->svr.num_query_dnscrypt_cert;
451 	total->svr.num_query_dnscrypt_cleartext += \
452 		a->svr.num_query_dnscrypt_cleartext;
453 	total->svr.num_query_dnscrypt_crypted_malformed += \
454 		a->svr.num_query_dnscrypt_crypted_malformed;
455 #endif /* USE_DNSCRYPT */
456 	/* the max size reached is upped to higher of both */
457 	if(a->svr.max_query_list_size > total->svr.max_query_list_size)
458 		total->svr.max_query_list_size = a->svr.max_query_list_size;
459 
460 	if(a->svr.extended) {
461 		int i;
462 		total->svr.qtype_big += a->svr.qtype_big;
463 		total->svr.qclass_big += a->svr.qclass_big;
464 		total->svr.qtcp += a->svr.qtcp;
465 		total->svr.qtcp_outgoing += a->svr.qtcp_outgoing;
466 		total->svr.qudp_outgoing += a->svr.qudp_outgoing;
467 		total->svr.qtls += a->svr.qtls;
468 		total->svr.qtls_resume += a->svr.qtls_resume;
469 		total->svr.qhttps += a->svr.qhttps;
470 		total->svr.qipv6 += a->svr.qipv6;
471 		total->svr.qbit_QR += a->svr.qbit_QR;
472 		total->svr.qbit_AA += a->svr.qbit_AA;
473 		total->svr.qbit_TC += a->svr.qbit_TC;
474 		total->svr.qbit_RD += a->svr.qbit_RD;
475 		total->svr.qbit_RA += a->svr.qbit_RA;
476 		total->svr.qbit_Z += a->svr.qbit_Z;
477 		total->svr.qbit_AD += a->svr.qbit_AD;
478 		total->svr.qbit_CD += a->svr.qbit_CD;
479 		total->svr.qEDNS += a->svr.qEDNS;
480 		total->svr.qEDNS_DO += a->svr.qEDNS_DO;
481 		total->svr.ans_rcode_nodata += a->svr.ans_rcode_nodata;
482 		total->svr.ans_secure += a->svr.ans_secure;
483 		total->svr.ans_bogus += a->svr.ans_bogus;
484 		total->svr.unwanted_replies += a->svr.unwanted_replies;
485 		total->svr.unwanted_queries += a->svr.unwanted_queries;
486 		total->svr.tcp_accept_usage += a->svr.tcp_accept_usage;
487 #ifdef USE_CACHEDB
488 		total->svr.num_query_cachedb += a->svr.num_query_cachedb;
489 #endif
490 		for(i=0; i<UB_STATS_QTYPE_NUM; i++)
491 			total->svr.qtype[i] += a->svr.qtype[i];
492 		for(i=0; i<UB_STATS_QCLASS_NUM; i++)
493 			total->svr.qclass[i] += a->svr.qclass[i];
494 		for(i=0; i<UB_STATS_OPCODE_NUM; i++)
495 			total->svr.qopcode[i] += a->svr.qopcode[i];
496 		for(i=0; i<UB_STATS_RCODE_NUM; i++)
497 			total->svr.ans_rcode[i] += a->svr.ans_rcode[i];
498 		for(i=0; i<NUM_BUCKETS_HIST; i++)
499 			total->svr.hist[i] += a->svr.hist[i];
500 		for(i=0; i<UB_STATS_RPZ_ACTION_NUM; i++)
501 			total->svr.rpz_action[i] += a->svr.rpz_action[i];
502 	}
503 
504 	total->mesh_num_states += a->mesh_num_states;
505 	total->mesh_num_reply_states += a->mesh_num_reply_states;
506 	total->mesh_jostled += a->mesh_jostled;
507 	total->mesh_dropped += a->mesh_dropped;
508 	total->mesh_replies_sent += a->mesh_replies_sent;
509 	stats_timeval_add(&total->mesh_replies_sum_wait_sec, &total->mesh_replies_sum_wait_usec, a->mesh_replies_sum_wait_sec, a->mesh_replies_sum_wait_usec);
510 	/* the medians are averaged together, this is not as accurate as
511 	 * taking the median over all of the data, but is good and fast
512 	 * added up here, division later*/
513 	total->mesh_time_median += a->mesh_time_median;
514 }
515 
516 void server_stats_insquery(struct ub_server_stats* stats, struct comm_point* c,
517 	uint16_t qtype, uint16_t qclass, struct edns_data* edns,
518 	struct comm_reply* repinfo)
519 {
520 	uint16_t flags = sldns_buffer_read_u16_at(c->buffer, 2);
521 	if(qtype < UB_STATS_QTYPE_NUM)
522 		stats->qtype[qtype]++;
523 	else	stats->qtype_big++;
524 	if(qclass < UB_STATS_QCLASS_NUM)
525 		stats->qclass[qclass]++;
526 	else	stats->qclass_big++;
527 	stats->qopcode[ LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) ]++;
528 	if(c->type != comm_udp) {
529 		stats->qtcp++;
530 		if(c->ssl != NULL) {
531 			stats->qtls++;
532 #ifdef HAVE_SSL
533 			if(SSL_session_reused(c->ssl))
534 				stats->qtls_resume++;
535 #endif
536 			if(c->type == comm_http)
537 				stats->qhttps++;
538 		}
539 	}
540 	if(repinfo && addr_is_ip6(&repinfo->remote_addr, repinfo->remote_addrlen))
541 		stats->qipv6++;
542 	if( (flags&BIT_QR) )
543 		stats->qbit_QR++;
544 	if( (flags&BIT_AA) )
545 		stats->qbit_AA++;
546 	if( (flags&BIT_TC) )
547 		stats->qbit_TC++;
548 	if( (flags&BIT_RD) )
549 		stats->qbit_RD++;
550 	if( (flags&BIT_RA) )
551 		stats->qbit_RA++;
552 	if( (flags&BIT_Z) )
553 		stats->qbit_Z++;
554 	if( (flags&BIT_AD) )
555 		stats->qbit_AD++;
556 	if( (flags&BIT_CD) )
557 		stats->qbit_CD++;
558 	if(edns->edns_present) {
559 		stats->qEDNS++;
560 		if( (edns->bits & EDNS_DO) )
561 			stats->qEDNS_DO++;
562 	}
563 }
564 
565 void server_stats_insrcode(struct ub_server_stats* stats, sldns_buffer* buf)
566 {
567 	if(stats->extended && sldns_buffer_limit(buf) != 0) {
568 		int r = (int)LDNS_RCODE_WIRE( sldns_buffer_begin(buf) );
569 		stats->ans_rcode[r] ++;
570 		if(r == 0 && LDNS_ANCOUNT( sldns_buffer_begin(buf) ) == 0)
571 			stats->ans_rcode_nodata ++;
572 	}
573 }
574 
575 void server_stats_downstream_cookie(struct ub_server_stats* stats,
576 	struct edns_data* edns)
577 {
578 	if(!(edns->edns_present && edns->cookie_present)) return;
579 	if(edns->cookie_valid) {
580 		stats->num_queries_cookie_valid++;
581 	} else if(edns->cookie_client) {
582 		stats->num_queries_cookie_client++;
583 	} else {
584 		stats->num_queries_cookie_invalid++;
585 	}
586 }
587