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
stats_timeval_add(long long * d_sec,long long * d_usec,long long add_sec,long long add_usec)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
server_stats_init(struct ub_server_stats * stats,struct config_file * cfg)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
server_stats_querymiss(struct ub_server_stats * stats,struct worker * worker)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
server_stats_prefetch(struct ub_server_stats * stats,struct worker * worker)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
server_stats_log(struct ub_server_stats * stats,struct worker * worker,int threadnum)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
set_subnet_stats(struct worker * worker,struct ub_server_stats * svr,int reset)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
set_neg_cache_stats(struct worker * worker,struct ub_server_stats * svr,int reset)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
get_rrset_bogus(struct worker * worker,int reset)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
get_queries_ratelimit(struct worker * worker,int reset)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
get_dnscrypt_cache_miss(struct worker * worker,int reset)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
get_dnscrypt_replay(struct worker * worker,int reset)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
server_stats_compile(struct worker * worker,struct ub_stats_info * s,int reset)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.val_ops += (long long)worker->env.mesh->val_ops;
277 s->svr.ans_rcode_nodata += (long long)worker->env.mesh->ans_nodata;
278 s->svr.ans_expired += (long long)worker->env.mesh->ans_expired;
279 for(i=0; i<UB_STATS_RCODE_NUM; i++)
280 s->svr.ans_rcode[i] += (long long)worker->env.mesh->ans_rcode[i];
281 for(i=0; i<UB_STATS_RPZ_ACTION_NUM; i++)
282 s->svr.rpz_action[i] += (long long)worker->env.mesh->rpz_action[i];
283 timehist_export(worker->env.mesh->histogram, s->svr.hist,
284 NUM_BUCKETS_HIST);
285 s->svr.num_queries_discard_timeout +=
286 (long long)worker->env.mesh->num_queries_discard_timeout;
287 s->svr.num_queries_wait_limit +=
288 (long long)worker->env.mesh->num_queries_wait_limit;
289 s->svr.num_dns_error_reports +=
290 (long long)worker->env.mesh->num_dns_error_reports;
291 /* values from outside network */
292 s->svr.unwanted_replies = (long long)worker->back->unwanted_replies;
293 s->svr.qtcp_outgoing = (long long)worker->back->num_tcp_outgoing;
294 s->svr.qudp_outgoing = (long long)worker->back->num_udp_outgoing;
295
296 /* get and reset validator rrset bogus number */
297 s->svr.rrset_bogus = (long long)get_rrset_bogus(worker, reset);
298
299 /* get and reset iterator query ratelimit number */
300 s->svr.queries_ratelimited = (long long)get_queries_ratelimit(worker, reset);
301
302 /* get cache sizes */
303 get_slabhash_stats(worker->env.msg_cache,
304 &s->svr.msg_cache_count, &s->svr.msg_cache_max_collisions);
305 get_slabhash_stats(&worker->env.rrset_cache->table,
306 &s->svr.rrset_cache_count, &s->svr.rrset_cache_max_collisions);
307 s->svr.infra_cache_count = (long long)count_slabhash_entries(worker->env.infra_cache->hosts);
308 if(worker->env.key_cache)
309 s->svr.key_cache_count = (long long)count_slabhash_entries(worker->env.key_cache->slab);
310 else s->svr.key_cache_count = 0;
311
312 #ifdef USE_DNSCRYPT
313 if(worker->daemon->dnscenv) {
314 s->svr.num_query_dnscrypt_secret_missed_cache =
315 (long long)get_dnscrypt_cache_miss(worker, reset);
316 s->svr.shared_secret_cache_count = (long long)count_slabhash_entries(
317 worker->daemon->dnscenv->shared_secrets_cache);
318 s->svr.nonce_cache_count = (long long)count_slabhash_entries(
319 worker->daemon->dnscenv->nonces_cache);
320 s->svr.num_query_dnscrypt_replay =
321 (long long)get_dnscrypt_replay(worker, reset);
322 } else {
323 s->svr.num_query_dnscrypt_secret_missed_cache = 0;
324 s->svr.shared_secret_cache_count = 0;
325 s->svr.nonce_cache_count = 0;
326 s->svr.num_query_dnscrypt_replay = 0;
327 }
328 #else
329 s->svr.num_query_dnscrypt_secret_missed_cache = 0;
330 s->svr.shared_secret_cache_count = 0;
331 s->svr.nonce_cache_count = 0;
332 s->svr.num_query_dnscrypt_replay = 0;
333 #endif /* USE_DNSCRYPT */
334 if(worker->env.auth_zones) {
335 s->svr.num_query_authzone_up += (long long)worker->env.mesh->num_query_authzone_up;
336 s->svr.num_query_authzone_down += (long long)worker->env.mesh->num_query_authzone_down;
337 }
338 s->svr.mem_stream_wait =
339 (long long)tcp_req_info_get_stream_buffer_size();
340 s->svr.mem_http2_query_buffer =
341 (long long)http2_get_query_buffer_size();
342 s->svr.mem_http2_response_buffer =
343 (long long)http2_get_response_buffer_size();
344 #ifdef HAVE_NGTCP2
345 s->svr.mem_quic = (long long)doq_table_quic_size_get(
346 worker->daemon->doq_table);
347 #else
348 s->svr.mem_quic = 0;
349 #endif /* HAVE_NGTCP2 */
350
351 /* Set neg cache usage numbers */
352 set_neg_cache_stats(worker, &s->svr, reset);
353 #ifdef CLIENT_SUBNET
354 /* EDNS Subnet usage numbers */
355 set_subnet_stats(worker, &s->svr, reset);
356 #else
357 s->svr.num_query_subnet = 0;
358 s->svr.num_query_subnet_cache = 0;
359 #endif
360 #ifdef USE_CACHEDB
361 s->svr.num_query_cachedb = (long long)worker->env.mesh->ans_cachedb;
362 #else
363 s->svr.num_query_cachedb = 0;
364 #endif
365
366 /* get tcp accept usage */
367 s->svr.tcp_accept_usage = 0;
368 for(lp = worker->front->cps; lp; lp = lp->next) {
369 if(lp->com->type == comm_tcp_accept)
370 s->svr.tcp_accept_usage += (long long)lp->com->cur_tcp_count;
371 }
372
373 if(reset && !worker->env.cfg->stat_cumulative) {
374 worker_stats_clear(worker);
375 }
376 }
377
server_stats_obtain(struct worker * worker,struct worker * who,struct ub_stats_info * s,int reset)378 void server_stats_obtain(struct worker* worker, struct worker* who,
379 struct ub_stats_info* s, int reset)
380 {
381 uint8_t *reply = NULL;
382 uint32_t len = 0;
383 if(worker == who) {
384 /* just fill it in */
385 server_stats_compile(worker, s, reset);
386 return;
387 }
388 /* communicate over tube */
389 verbose(VERB_ALGO, "write stats cmd");
390 if(reset)
391 worker_send_cmd(who, worker_cmd_stats);
392 else worker_send_cmd(who, worker_cmd_stats_noreset);
393 verbose(VERB_ALGO, "wait for stats reply");
394 if(tube_wait_timeout(worker->cmd, STATS_THREAD_WAIT) == 0) {
395 #if defined(HAVE_PTHREAD) && defined(SIZEOF_PTHREAD_T) && defined(SIZEOF_UNSIGNED_LONG)
396 # if SIZEOF_PTHREAD_T == SIZEOF_UNSIGNED_LONG
397 unsigned long pthid = 0;
398 if(verbosity >= VERB_OPS)
399 memcpy(&pthid, &who->thr_id, sizeof(unsigned long));
400 # endif
401 #endif
402 verbose(VERB_OPS, "no response from thread %d"
403 #ifdef HAVE_GETTID
404 " LWP %u"
405 #endif
406 #if defined(HAVE_PTHREAD) && defined(SIZEOF_PTHREAD_T) && defined(SIZEOF_UNSIGNED_LONG)
407 # if SIZEOF_PTHREAD_T == SIZEOF_UNSIGNED_LONG
408 " pthread 0x%lx"
409 # endif
410 #endif
411 ,
412 who->thread_num
413 #ifdef HAVE_GETTID
414 , (unsigned)who->thread_tid
415 #endif
416 #if defined(HAVE_PTHREAD) && defined(SIZEOF_PTHREAD_T) && defined(SIZEOF_UNSIGNED_LONG)
417 # if SIZEOF_PTHREAD_T == SIZEOF_UNSIGNED_LONG
418 , pthid
419 # endif
420 #endif
421 );
422 }
423 if(!tube_read_msg(worker->cmd, &reply, &len, 0))
424 fatal_exit("failed to read stats over cmd channel");
425 if(len != (uint32_t)sizeof(*s))
426 fatal_exit("stats on cmd channel wrong length %d %d",
427 (int)len, (int)sizeof(*s));
428 memcpy(s, reply, (size_t)len);
429 free(reply);
430 }
431
server_stats_reply(struct worker * worker,int reset)432 void server_stats_reply(struct worker* worker, int reset)
433 {
434 struct ub_stats_info s;
435 server_stats_compile(worker, &s, reset);
436 verbose(VERB_ALGO, "write stats replymsg");
437 if(!tube_write_msg(worker->daemon->workers[0]->cmd,
438 (uint8_t*)&s, sizeof(s), 0))
439 fatal_exit("could not write stat values over cmd channel");
440 }
441
server_stats_add(struct ub_stats_info * total,struct ub_stats_info * a)442 void server_stats_add(struct ub_stats_info* total, struct ub_stats_info* a)
443 {
444 total->svr.num_queries += a->svr.num_queries;
445 total->svr.num_queries_ip_ratelimited += a->svr.num_queries_ip_ratelimited;
446 total->svr.num_queries_cookie_valid += a->svr.num_queries_cookie_valid;
447 total->svr.num_queries_cookie_client += a->svr.num_queries_cookie_client;
448 total->svr.num_queries_cookie_invalid += a->svr.num_queries_cookie_invalid;
449 total->svr.num_queries_discard_timeout +=
450 a->svr.num_queries_discard_timeout;
451 total->svr.num_queries_wait_limit += a->svr.num_queries_wait_limit;
452 total->svr.num_dns_error_reports += a->svr.num_dns_error_reports;
453 total->svr.num_queries_missed_cache += a->svr.num_queries_missed_cache;
454 total->svr.num_queries_prefetch += a->svr.num_queries_prefetch;
455 total->svr.num_queries_timed_out += a->svr.num_queries_timed_out;
456 total->svr.num_query_authzone_up += a->svr.num_query_authzone_up;
457 total->svr.num_query_authzone_down += a->svr.num_query_authzone_down;
458 if (total->svr.max_query_time_us < a->svr.max_query_time_us)
459 total->svr.max_query_time_us = a->svr.max_query_time_us;
460 total->svr.sum_query_list_size += a->svr.sum_query_list_size;
461 total->svr.ans_expired += a->svr.ans_expired;
462 #ifdef USE_DNSCRYPT
463 total->svr.num_query_dnscrypt_crypted += a->svr.num_query_dnscrypt_crypted;
464 total->svr.num_query_dnscrypt_cert += a->svr.num_query_dnscrypt_cert;
465 total->svr.num_query_dnscrypt_cleartext +=
466 a->svr.num_query_dnscrypt_cleartext;
467 total->svr.num_query_dnscrypt_crypted_malformed +=
468 a->svr.num_query_dnscrypt_crypted_malformed;
469 #endif /* USE_DNSCRYPT */
470 /* the max size reached is upped to higher of both */
471 if(a->svr.max_query_list_size > total->svr.max_query_list_size)
472 total->svr.max_query_list_size = a->svr.max_query_list_size;
473
474 if(a->svr.extended) {
475 int i;
476 total->svr.qtype_big += a->svr.qtype_big;
477 total->svr.qclass_big += a->svr.qclass_big;
478 total->svr.qtcp += a->svr.qtcp;
479 total->svr.qtcp_outgoing += a->svr.qtcp_outgoing;
480 total->svr.qudp_outgoing += a->svr.qudp_outgoing;
481 total->svr.qtls += a->svr.qtls;
482 total->svr.qtls_resume += a->svr.qtls_resume;
483 total->svr.qhttps += a->svr.qhttps;
484 total->svr.qquic += a->svr.qquic;
485 total->svr.qipv6 += a->svr.qipv6;
486 total->svr.qbit_QR += a->svr.qbit_QR;
487 total->svr.qbit_AA += a->svr.qbit_AA;
488 total->svr.qbit_TC += a->svr.qbit_TC;
489 total->svr.qbit_RD += a->svr.qbit_RD;
490 total->svr.qbit_RA += a->svr.qbit_RA;
491 total->svr.qbit_Z += a->svr.qbit_Z;
492 total->svr.qbit_AD += a->svr.qbit_AD;
493 total->svr.qbit_CD += a->svr.qbit_CD;
494 total->svr.qEDNS += a->svr.qEDNS;
495 total->svr.qEDNS_DO += a->svr.qEDNS_DO;
496 total->svr.ans_rcode_nodata += a->svr.ans_rcode_nodata;
497 total->svr.ans_secure += a->svr.ans_secure;
498 total->svr.ans_bogus += a->svr.ans_bogus;
499 total->svr.val_ops += a->svr.val_ops;
500 total->svr.unwanted_replies += a->svr.unwanted_replies;
501 total->svr.unwanted_queries += a->svr.unwanted_queries;
502 total->svr.tcp_accept_usage += a->svr.tcp_accept_usage;
503 #ifdef USE_CACHEDB
504 total->svr.num_query_cachedb += a->svr.num_query_cachedb;
505 #endif
506 for(i=0; i<UB_STATS_QTYPE_NUM; i++)
507 total->svr.qtype[i] += a->svr.qtype[i];
508 for(i=0; i<UB_STATS_QCLASS_NUM; i++)
509 total->svr.qclass[i] += a->svr.qclass[i];
510 for(i=0; i<UB_STATS_OPCODE_NUM; i++)
511 total->svr.qopcode[i] += a->svr.qopcode[i];
512 for(i=0; i<UB_STATS_RCODE_NUM; i++)
513 total->svr.ans_rcode[i] += a->svr.ans_rcode[i];
514 for(i=0; i<NUM_BUCKETS_HIST; i++)
515 total->svr.hist[i] += a->svr.hist[i];
516 for(i=0; i<UB_STATS_RPZ_ACTION_NUM; i++)
517 total->svr.rpz_action[i] += a->svr.rpz_action[i];
518 }
519
520 total->mesh_num_states += a->mesh_num_states;
521 total->mesh_num_reply_states += a->mesh_num_reply_states;
522 total->mesh_jostled += a->mesh_jostled;
523 total->mesh_dropped += a->mesh_dropped;
524 total->mesh_replies_sent += a->mesh_replies_sent;
525 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);
526 /* the medians are averaged together, this is not as accurate as
527 * taking the median over all of the data, but is good and fast
528 * added up here, division later*/
529 total->mesh_time_median += a->mesh_time_median;
530 }
531
server_stats_insquery(struct ub_server_stats * stats,struct comm_point * c,uint16_t qtype,uint16_t qclass,struct edns_data * edns,struct comm_reply * repinfo)532 void server_stats_insquery(struct ub_server_stats* stats, struct comm_point* c,
533 uint16_t qtype, uint16_t qclass, struct edns_data* edns,
534 struct comm_reply* repinfo)
535 {
536 uint16_t flags = sldns_buffer_read_u16_at(c->buffer, 2);
537 if(qtype < UB_STATS_QTYPE_NUM)
538 stats->qtype[qtype]++;
539 else stats->qtype_big++;
540 if(qclass < UB_STATS_QCLASS_NUM)
541 stats->qclass[qclass]++;
542 else stats->qclass_big++;
543 stats->qopcode[ LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) ]++;
544 if(c->type != comm_udp) {
545 if(c->type != comm_doq)
546 stats->qtcp++;
547 if(c->ssl != NULL) {
548 stats->qtls++;
549 #ifdef HAVE_SSL
550 if(SSL_session_reused(c->ssl))
551 stats->qtls_resume++;
552 #endif
553 if(c->type == comm_http)
554 stats->qhttps++;
555 #ifdef HAVE_NGTCP2
556 else if(c->type == comm_doq)
557 stats->qquic++;
558 #endif
559 }
560 }
561 if(repinfo && addr_is_ip6(&repinfo->remote_addr, repinfo->remote_addrlen))
562 stats->qipv6++;
563 if( (flags&BIT_QR) )
564 stats->qbit_QR++;
565 if( (flags&BIT_AA) )
566 stats->qbit_AA++;
567 if( (flags&BIT_TC) )
568 stats->qbit_TC++;
569 if( (flags&BIT_RD) )
570 stats->qbit_RD++;
571 if( (flags&BIT_RA) )
572 stats->qbit_RA++;
573 if( (flags&BIT_Z) )
574 stats->qbit_Z++;
575 if( (flags&BIT_AD) )
576 stats->qbit_AD++;
577 if( (flags&BIT_CD) )
578 stats->qbit_CD++;
579 if(edns->edns_present) {
580 stats->qEDNS++;
581 if( (edns->bits & EDNS_DO) )
582 stats->qEDNS_DO++;
583 }
584 }
585
server_stats_insrcode(struct ub_server_stats * stats,sldns_buffer * buf)586 void server_stats_insrcode(struct ub_server_stats* stats, sldns_buffer* buf)
587 {
588 if(stats->extended && sldns_buffer_limit(buf) != 0) {
589 int r = (int)LDNS_RCODE_WIRE( sldns_buffer_begin(buf) );
590 stats->ans_rcode[r] ++;
591 if(r == 0 && LDNS_ANCOUNT( sldns_buffer_begin(buf) ) == 0)
592 stats->ans_rcode_nodata ++;
593 }
594 }
595
server_stats_downstream_cookie(struct ub_server_stats * stats,struct edns_data * edns)596 void server_stats_downstream_cookie(struct ub_server_stats* stats,
597 struct edns_data* edns)
598 {
599 if(!(edns->edns_present && edns->cookie_present)) return;
600 if(edns->cookie_valid) {
601 stats->num_queries_cookie_valid++;
602 } else if(edns->cookie_client) {
603 stats->num_queries_cookie_client++;
604 } else {
605 stats->num_queries_cookie_invalid++;
606 }
607 }
608