diff --git a/plugins/napatech/util-napatech.c b/plugins/napatech/util-napatech.c index 0d2a35626f..059ce962f4 100644 --- a/plugins/napatech/util-napatech.c +++ b/plugins/napatech/util-napatech.c @@ -585,8 +585,10 @@ static void *NapatechStatsLoop(void *arg) #ifdef NAPATECH_ENABLE_BYPASS FlowStatsCounters flow_counters; if (bypass_supported) { - flow_counters.active_bypass_flows = StatsRegisterCounter("napa_bypass.active_flows", tv); - flow_counters.total_bypass_flows = StatsRegisterCounter("napa_bypass.total_flows", tv); + flow_counters.active_bypass_flows = + StatsRegisterCounter("napa_bypass.active_flows", &tv->stats); + flow_counters.total_bypass_flows = + StatsRegisterCounter("napa_bypass.total_flows", &tv->stats); } #endif /* NAPATECH_ENABLE_BYPASS */ diff --git a/plugins/pfring/source-pfring.c b/plugins/pfring/source-pfring.c index 5cc29fb299..6b444b2ece 100644 --- a/plugins/pfring/source-pfring.c +++ b/plugins/pfring/source-pfring.c @@ -573,10 +573,10 @@ TmEcode ReceivePfringThreadInit(ThreadVars *tv, const void *initdata, void **dat } } - ptv->capture_kernel_packets = StatsRegisterCounter("capture.kernel_packets", ptv->tv); - ptv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", ptv->tv); + ptv->capture_kernel_packets = StatsRegisterCounter("capture.kernel_packets", &ptv->tv->stats); + ptv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", &ptv->tv->stats); #ifdef HAVE_PF_RING_FLOW_OFFLOAD - ptv->capture_bypassed = StatsRegisterCounter("capture.bypassed", ptv->tv); + ptv->capture_bypassed = StatsRegisterCounter("capture.bypassed", &ptv->tv->stats); #endif /* If kernel is older than 3.0, VLAN is not stripped so we don't diff --git a/src/app-layer.c b/src/app-layer.c index 19f8eb2211..c405a8a6b7 100644 --- a/src/app-layer.c +++ b/src/app-layer.c @@ -1312,7 +1312,7 @@ void AppLayerRegisterThreadCounters(ThreadVars *tv) for (enum ExceptionPolicy i = EXCEPTION_POLICY_NOT_SET + 1; i < EXCEPTION_POLICY_MAX; i++) { if (IsAppLayerErrorExceptionPolicyStatsValid(i)) { eps_error_summary.eps_id[i] = - StatsRegisterCounter(app_layer_error_eps_stats.eps_name[i], tv); + StatsRegisterCounter(app_layer_error_eps_stats.eps_name[i], &tv->stats); } } } @@ -1323,25 +1323,25 @@ void AppLayerRegisterThreadCounters(ThreadVars *tv) for (AppProto alproto = 0; alproto < g_alproto_max; alproto++) { if (alprotos[alproto] == 1) { - applayer_counters[alproto][ipproto_map].counter_id = - StatsRegisterCounter(applayer_counter_names[alproto][ipproto_map].name, tv); + applayer_counters[alproto][ipproto_map].counter_id = StatsRegisterCounter( + applayer_counter_names[alproto][ipproto_map].name, &tv->stats); if (AppLayerParserProtoIsRegistered(ipproto, alproto) != 1) continue; applayer_counters[alproto][ipproto_map].counter_tx_id = StatsRegisterCounter( - applayer_counter_names[alproto][ipproto_map].tx_name, tv); + applayer_counter_names[alproto][ipproto_map].tx_name, &tv->stats); if (ipproto == IPPROTO_TCP) { applayer_counters[alproto][ipproto_map].gap_error_id = StatsRegisterCounter( - applayer_counter_names[alproto][ipproto_map].gap_error, tv); + applayer_counter_names[alproto][ipproto_map].gap_error, &tv->stats); } applayer_counters[alproto][ipproto_map].alloc_error_id = StatsRegisterCounter( - applayer_counter_names[alproto][ipproto_map].alloc_error, tv); + applayer_counter_names[alproto][ipproto_map].alloc_error, &tv->stats); applayer_counters[alproto][ipproto_map].parser_error_id = StatsRegisterCounter( - applayer_counter_names[alproto][ipproto_map].parser_error, tv); + applayer_counter_names[alproto][ipproto_map].parser_error, &tv->stats); applayer_counters[alproto][ipproto_map].internal_error_id = StatsRegisterCounter( - applayer_counter_names[alproto][ipproto_map].internal_error, tv); + applayer_counter_names[alproto][ipproto_map].internal_error, &tv->stats); /* We don't log stats counters if exception policy is `ignore`/`not set` */ if (g_stats_eps_per_app_proto_errors && g_applayerparser_error_policy != EXCEPTION_POLICY_NOT_SET) { @@ -1350,17 +1350,18 @@ void AppLayerRegisterThreadCounters(ThreadVars *tv) if (IsAppLayerErrorExceptionPolicyStatsValid(i)) { applayer_counters[alproto][ipproto_map] .eps_error.eps_id[i] = StatsRegisterCounter( - applayer_counter_names[alproto][ipproto_map].eps_name[i], tv); + applayer_counter_names[alproto][ipproto_map].eps_name[i], + &tv->stats); } } } } else if (alproto == ALPROTO_FAILED) { - applayer_counters[alproto][ipproto_map].counter_id = - StatsRegisterCounter(applayer_counter_names[alproto][ipproto_map].name, tv); + applayer_counters[alproto][ipproto_map].counter_id = StatsRegisterCounter( + applayer_counter_names[alproto][ipproto_map].name, &tv->stats); if (ipproto == IPPROTO_TCP) { applayer_counters[alproto][ipproto_map].gap_error_id = StatsRegisterCounter( - applayer_counter_names[alproto][ipproto_map].gap_error, tv); + applayer_counter_names[alproto][ipproto_map].gap_error, &tv->stats); } } } diff --git a/src/counters.c b/src/counters.c index 6e81805d84..5ba3f73f80 100644 --- a/src/counters.c +++ b/src/counters.c @@ -998,9 +998,9 @@ void StatsSpawnThreads(void) * \retval id Counter id for the newly registered counter, or the already * present counter */ -StatsCounterId StatsRegisterCounter(const char *name, struct ThreadVars_ *tv) +StatsCounterId StatsRegisterCounter(const char *name, StatsThreadContext *stats) { - uint16_t id = StatsRegisterQualifiedCounter(name, &tv->stats.pub, STATS_TYPE_NORMAL, NULL); + uint16_t id = StatsRegisterQualifiedCounter(name, &stats->pub, STATS_TYPE_NORMAL, NULL); StatsCounterId s = { .id = id }; return s; } @@ -1016,9 +1016,9 @@ StatsCounterId StatsRegisterCounter(const char *name, struct ThreadVars_ *tv) * \retval id Counter id for the newly registered counter, or the already * present counter */ -StatsCounterAvgId StatsRegisterAvgCounter(const char *name, struct ThreadVars_ *tv) +StatsCounterAvgId StatsRegisterAvgCounter(const char *name, StatsThreadContext *stats) { - uint16_t id = StatsRegisterQualifiedCounter(name, &tv->stats.pub, STATS_TYPE_AVERAGE, NULL); + uint16_t id = StatsRegisterQualifiedCounter(name, &stats->pub, STATS_TYPE_AVERAGE, NULL); StatsCounterAvgId s = { .id = id }; return s; } @@ -1034,9 +1034,9 @@ StatsCounterAvgId StatsRegisterAvgCounter(const char *name, struct ThreadVars_ * * \retval the counter id for the newly registered counter, or the already * present counter */ -StatsCounterMaxId StatsRegisterMaxCounter(const char *name, struct ThreadVars_ *tv) +StatsCounterMaxId StatsRegisterMaxCounter(const char *name, StatsThreadContext *stats) { - uint16_t id = StatsRegisterQualifiedCounter(name, &tv->stats.pub, STATS_TYPE_MAXIMUM, NULL); + uint16_t id = StatsRegisterQualifiedCounter(name, &stats->pub, STATS_TYPE_MAXIMUM, NULL); StatsCounterMaxId s = { .id = id }; return s; } diff --git a/src/counters.h b/src/counters.h index 77b43cbd1b..f6a121c8ee 100644 --- a/src/counters.h +++ b/src/counters.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2007-2015 Open Information Security Foundation +/* Copyright (C) 2007-2025 Open Information Security Foundation * * You can copy, redistribute or modify this Program under the terms of * the GNU General Public License version 2 as published by the Free @@ -27,9 +27,6 @@ #include "threads.h" -/* forward declaration of the ThreadVars structure */ -struct ThreadVars_; - typedef struct StatsCounterId { uint16_t id; } StatsCounterId; @@ -133,9 +130,9 @@ bool StatsEnabled(void); void StatsReleaseResources(void); /* counter registration functions */ -StatsCounterId StatsRegisterCounter(const char *, struct ThreadVars_ *); -StatsCounterAvgId StatsRegisterAvgCounter(const char *, struct ThreadVars_ *); -StatsCounterMaxId StatsRegisterMaxCounter(const char *, struct ThreadVars_ *); +StatsCounterId StatsRegisterCounter(const char *, StatsThreadContext *); +StatsCounterAvgId StatsRegisterAvgCounter(const char *, StatsThreadContext *); +StatsCounterMaxId StatsRegisterMaxCounter(const char *, StatsThreadContext *); StatsCounterGlobalId StatsRegisterGlobalCounter(const char *cname, uint64_t (*Func)(void)); /* functions used to update local counter values */ diff --git a/src/decode.c b/src/decode.c index 1dd1772ee7..e911e7d90d 100644 --- a/src/decode.c +++ b/src/decode.c @@ -632,90 +632,100 @@ static bool IsFlowMemcapExceptionPolicyStatsValid(enum ExceptionPolicy policy) void DecodeRegisterPerfCounters(DecodeThreadVars *dtv, ThreadVars *tv) { /* register counters */ - dtv->counter_pkts = StatsRegisterCounter("decoder.pkts", tv); - dtv->counter_bytes = StatsRegisterCounter("decoder.bytes", tv); - dtv->counter_invalid = StatsRegisterCounter("decoder.invalid", tv); - dtv->counter_ipv4 = StatsRegisterCounter("decoder.ipv4", tv); - dtv->counter_ipv6 = StatsRegisterCounter("decoder.ipv6", tv); - dtv->counter_eth = StatsRegisterCounter("decoder.ethernet", tv); - dtv->counter_arp = StatsRegisterCounter("decoder.arp", tv); - dtv->counter_ethertype_unknown = StatsRegisterCounter("decoder.unknown_ethertype", tv); - dtv->counter_chdlc = StatsRegisterCounter("decoder.chdlc", tv); - dtv->counter_raw = StatsRegisterCounter("decoder.raw", tv); - dtv->counter_null = StatsRegisterCounter("decoder.null", tv); - dtv->counter_sll = StatsRegisterCounter("decoder.sll", tv); - dtv->counter_sll2 = StatsRegisterCounter("decoder.sll2", tv); - dtv->counter_tcp = StatsRegisterCounter("decoder.tcp", tv); + dtv->counter_pkts = StatsRegisterCounter("decoder.pkts", &tv->stats); + dtv->counter_bytes = StatsRegisterCounter("decoder.bytes", &tv->stats); + dtv->counter_invalid = StatsRegisterCounter("decoder.invalid", &tv->stats); + dtv->counter_ipv4 = StatsRegisterCounter("decoder.ipv4", &tv->stats); + dtv->counter_ipv6 = StatsRegisterCounter("decoder.ipv6", &tv->stats); + dtv->counter_eth = StatsRegisterCounter("decoder.ethernet", &tv->stats); + dtv->counter_arp = StatsRegisterCounter("decoder.arp", &tv->stats); + dtv->counter_ethertype_unknown = StatsRegisterCounter("decoder.unknown_ethertype", &tv->stats); + dtv->counter_chdlc = StatsRegisterCounter("decoder.chdlc", &tv->stats); + dtv->counter_raw = StatsRegisterCounter("decoder.raw", &tv->stats); + dtv->counter_null = StatsRegisterCounter("decoder.null", &tv->stats); + dtv->counter_sll = StatsRegisterCounter("decoder.sll", &tv->stats); + dtv->counter_sll2 = StatsRegisterCounter("decoder.sll2", &tv->stats); + dtv->counter_tcp = StatsRegisterCounter("decoder.tcp", &tv->stats); - dtv->counter_tcp_syn = StatsRegisterCounter("tcp.syn", tv); - dtv->counter_tcp_synack = StatsRegisterCounter("tcp.synack", tv); - dtv->counter_tcp_rst = StatsRegisterCounter("tcp.rst", tv); - dtv->counter_tcp_urg = StatsRegisterCounter("tcp.urg", tv); + dtv->counter_tcp_syn = StatsRegisterCounter("tcp.syn", &tv->stats); + dtv->counter_tcp_synack = StatsRegisterCounter("tcp.synack", &tv->stats); + dtv->counter_tcp_rst = StatsRegisterCounter("tcp.rst", &tv->stats); + dtv->counter_tcp_urg = StatsRegisterCounter("tcp.urg", &tv->stats); - dtv->counter_udp = StatsRegisterCounter("decoder.udp", tv); - dtv->counter_sctp = StatsRegisterCounter("decoder.sctp", tv); - dtv->counter_esp = StatsRegisterCounter("decoder.esp", tv); - dtv->counter_icmpv4 = StatsRegisterCounter("decoder.icmpv4", tv); - dtv->counter_icmpv6 = StatsRegisterCounter("decoder.icmpv6", tv); - dtv->counter_ppp = StatsRegisterCounter("decoder.ppp", tv); - dtv->counter_pppoe = StatsRegisterCounter("decoder.pppoe", tv); - dtv->counter_geneve = StatsRegisterCounter("decoder.geneve", tv); - dtv->counter_gre = StatsRegisterCounter("decoder.gre", tv); - dtv->counter_vlan = StatsRegisterCounter("decoder.vlan", tv); - dtv->counter_vlan_qinq = StatsRegisterCounter("decoder.vlan_qinq", tv); - dtv->counter_vlan_qinqinq = StatsRegisterCounter("decoder.vlan_qinqinq", tv); - dtv->counter_vxlan = StatsRegisterCounter("decoder.vxlan", tv); - dtv->counter_vntag = StatsRegisterCounter("decoder.vntag", tv); - dtv->counter_etag = StatsRegisterCounter("decoder.etag", tv); - dtv->counter_ieee8021ah = StatsRegisterCounter("decoder.ieee8021ah", tv); - dtv->counter_teredo = StatsRegisterCounter("decoder.teredo", tv); - dtv->counter_ipv4inipv4 = StatsRegisterCounter("decoder.ipv4_in_ipv4", tv); - dtv->counter_ipv6inipv4 = StatsRegisterCounter("decoder.ipv6_in_ipv4", tv); - dtv->counter_ipv4inipv6 = StatsRegisterCounter("decoder.ipv4_in_ipv6", tv); - dtv->counter_ipv6inipv6 = StatsRegisterCounter("decoder.ipv6_in_ipv6", tv); - dtv->counter_mpls = StatsRegisterCounter("decoder.mpls", tv); - dtv->counter_avg_pkt_size = StatsRegisterAvgCounter("decoder.avg_pkt_size", tv); - dtv->counter_max_pkt_size = StatsRegisterMaxCounter("decoder.max_pkt_size", tv); - dtv->counter_max_mac_addrs_src = StatsRegisterMaxCounter("decoder.max_mac_addrs_src", tv); - dtv->counter_max_mac_addrs_dst = StatsRegisterMaxCounter("decoder.max_mac_addrs_dst", tv); - dtv->counter_erspan = StatsRegisterCounter("decoder.erspan", tv); - dtv->counter_nsh = StatsRegisterCounter("decoder.nsh", tv); - dtv->counter_flow_memcap = StatsRegisterCounter("flow.memcap", tv); + dtv->counter_udp = StatsRegisterCounter("decoder.udp", &tv->stats); + dtv->counter_sctp = StatsRegisterCounter("decoder.sctp", &tv->stats); + dtv->counter_esp = StatsRegisterCounter("decoder.esp", &tv->stats); + dtv->counter_icmpv4 = StatsRegisterCounter("decoder.icmpv4", &tv->stats); + dtv->counter_icmpv6 = StatsRegisterCounter("decoder.icmpv6", &tv->stats); + dtv->counter_ppp = StatsRegisterCounter("decoder.ppp", &tv->stats); + dtv->counter_pppoe = StatsRegisterCounter("decoder.pppoe", &tv->stats); + dtv->counter_geneve = StatsRegisterCounter("decoder.geneve", &tv->stats); + dtv->counter_gre = StatsRegisterCounter("decoder.gre", &tv->stats); + dtv->counter_vlan = StatsRegisterCounter("decoder.vlan", &tv->stats); + dtv->counter_vlan_qinq = StatsRegisterCounter("decoder.vlan_qinq", &tv->stats); + dtv->counter_vlan_qinqinq = StatsRegisterCounter("decoder.vlan_qinqinq", &tv->stats); + dtv->counter_vxlan = StatsRegisterCounter("decoder.vxlan", &tv->stats); + dtv->counter_vntag = StatsRegisterCounter("decoder.vntag", &tv->stats); + dtv->counter_etag = StatsRegisterCounter("decoder.etag", &tv->stats); + dtv->counter_ieee8021ah = StatsRegisterCounter("decoder.ieee8021ah", &tv->stats); + dtv->counter_teredo = StatsRegisterCounter("decoder.teredo", &tv->stats); + dtv->counter_ipv4inipv4 = StatsRegisterCounter("decoder.ipv4_in_ipv4", &tv->stats); + dtv->counter_ipv6inipv4 = StatsRegisterCounter("decoder.ipv6_in_ipv4", &tv->stats); + dtv->counter_ipv4inipv6 = StatsRegisterCounter("decoder.ipv4_in_ipv6", &tv->stats); + dtv->counter_ipv6inipv6 = StatsRegisterCounter("decoder.ipv6_in_ipv6", &tv->stats); + dtv->counter_mpls = StatsRegisterCounter("decoder.mpls", &tv->stats); + dtv->counter_avg_pkt_size = StatsRegisterAvgCounter("decoder.avg_pkt_size", &tv->stats); + dtv->counter_max_pkt_size = StatsRegisterMaxCounter("decoder.max_pkt_size", &tv->stats); + dtv->counter_max_mac_addrs_src = + StatsRegisterMaxCounter("decoder.max_mac_addrs_src", &tv->stats); + dtv->counter_max_mac_addrs_dst = + StatsRegisterMaxCounter("decoder.max_mac_addrs_dst", &tv->stats); + dtv->counter_erspan = StatsRegisterCounter("decoder.erspan", &tv->stats); + dtv->counter_nsh = StatsRegisterCounter("decoder.nsh", &tv->stats); + dtv->counter_flow_memcap = StatsRegisterCounter("flow.memcap", &tv->stats); ExceptionPolicySetStatsCounters(tv, &dtv->counter_flow_memcap_eps, &flow_memcap_eps_stats, FlowGetMemcapExceptionPolicy(), "exception_policy.flow.memcap.", IsFlowMemcapExceptionPolicyStatsValid); - dtv->counter_tcp_active_sessions = StatsRegisterCounter("tcp.active_sessions", tv); - dtv->counter_flow_total = StatsRegisterCounter("flow.total", tv); - dtv->counter_flow_active = StatsRegisterCounter("flow.active", tv); - dtv->counter_flow_tcp = StatsRegisterCounter("flow.tcp", tv); - dtv->counter_flow_udp = StatsRegisterCounter("flow.udp", tv); - dtv->counter_flow_icmp4 = StatsRegisterCounter("flow.icmpv4", tv); - dtv->counter_flow_icmp6 = StatsRegisterCounter("flow.icmpv6", tv); - dtv->counter_flow_tcp_reuse = StatsRegisterCounter("flow.tcp_reuse", tv); - dtv->counter_flow_elephant = StatsRegisterCounter("flow.elephant", tv); - dtv->counter_flow_get_used = StatsRegisterCounter("flow.get_used", tv); - dtv->counter_flow_get_used_eval = StatsRegisterCounter("flow.get_used_eval", tv); - dtv->counter_flow_get_used_eval_reject = StatsRegisterCounter("flow.get_used_eval_reject", tv); - dtv->counter_flow_get_used_eval_busy = StatsRegisterCounter("flow.get_used_eval_busy", tv); - dtv->counter_flow_get_used_failed = StatsRegisterCounter("flow.get_used_failed", tv); + dtv->counter_tcp_active_sessions = StatsRegisterCounter("tcp.active_sessions", &tv->stats); + dtv->counter_flow_total = StatsRegisterCounter("flow.total", &tv->stats); + dtv->counter_flow_active = StatsRegisterCounter("flow.active", &tv->stats); + dtv->counter_flow_tcp = StatsRegisterCounter("flow.tcp", &tv->stats); + dtv->counter_flow_udp = StatsRegisterCounter("flow.udp", &tv->stats); + dtv->counter_flow_icmp4 = StatsRegisterCounter("flow.icmpv4", &tv->stats); + dtv->counter_flow_icmp6 = StatsRegisterCounter("flow.icmpv6", &tv->stats); + dtv->counter_flow_tcp_reuse = StatsRegisterCounter("flow.tcp_reuse", &tv->stats); + dtv->counter_flow_elephant = StatsRegisterCounter("flow.elephant", &tv->stats); + dtv->counter_flow_get_used = StatsRegisterCounter("flow.get_used", &tv->stats); + dtv->counter_flow_get_used_eval = StatsRegisterCounter("flow.get_used_eval", &tv->stats); + dtv->counter_flow_get_used_eval_reject = + StatsRegisterCounter("flow.get_used_eval_reject", &tv->stats); + dtv->counter_flow_get_used_eval_busy = + StatsRegisterCounter("flow.get_used_eval_busy", &tv->stats); + dtv->counter_flow_get_used_failed = StatsRegisterCounter("flow.get_used_failed", &tv->stats); - dtv->counter_flow_spare_sync_avg = StatsRegisterAvgCounter("flow.wrk.spare_sync_avg", tv); - dtv->counter_flow_spare_sync = StatsRegisterCounter("flow.wrk.spare_sync", tv); - dtv->counter_flow_spare_sync_incomplete = StatsRegisterCounter("flow.wrk.spare_sync_incomplete", tv); - dtv->counter_flow_spare_sync_empty = StatsRegisterCounter("flow.wrk.spare_sync_empty", tv); + dtv->counter_flow_spare_sync_avg = + StatsRegisterAvgCounter("flow.wrk.spare_sync_avg", &tv->stats); + dtv->counter_flow_spare_sync = StatsRegisterCounter("flow.wrk.spare_sync", &tv->stats); + dtv->counter_flow_spare_sync_incomplete = + StatsRegisterCounter("flow.wrk.spare_sync_incomplete", &tv->stats); + dtv->counter_flow_spare_sync_empty = + StatsRegisterCounter("flow.wrk.spare_sync_empty", &tv->stats); - dtv->counter_defrag_ipv4_fragments = - StatsRegisterCounter("defrag.ipv4.fragments", tv); - dtv->counter_defrag_ipv4_reassembled = StatsRegisterCounter("defrag.ipv4.reassembled", tv); - dtv->counter_defrag_ipv6_fragments = - StatsRegisterCounter("defrag.ipv6.fragments", tv); - dtv->counter_defrag_ipv6_reassembled = StatsRegisterCounter("defrag.ipv6.reassembled", tv); - dtv->counter_defrag_max_hit = StatsRegisterCounter("defrag.max_trackers_reached", tv); - dtv->counter_defrag_no_frags = StatsRegisterCounter("defrag.max_frags_reached", tv); - dtv->counter_defrag_tracker_soft_reuse = StatsRegisterCounter("defrag.tracker_soft_reuse", tv); - dtv->counter_defrag_tracker_hard_reuse = StatsRegisterCounter("defrag.tracker_hard_reuse", tv); - dtv->counter_defrag_tracker_timeout = StatsRegisterCounter("defrag.wrk.tracker_timeout", tv); + dtv->counter_defrag_ipv4_fragments = StatsRegisterCounter("defrag.ipv4.fragments", &tv->stats); + dtv->counter_defrag_ipv4_reassembled = + StatsRegisterCounter("defrag.ipv4.reassembled", &tv->stats); + dtv->counter_defrag_ipv6_fragments = StatsRegisterCounter("defrag.ipv6.fragments", &tv->stats); + dtv->counter_defrag_ipv6_reassembled = + StatsRegisterCounter("defrag.ipv6.reassembled", &tv->stats); + dtv->counter_defrag_max_hit = StatsRegisterCounter("defrag.max_trackers_reached", &tv->stats); + dtv->counter_defrag_no_frags = StatsRegisterCounter("defrag.max_frags_reached", &tv->stats); + dtv->counter_defrag_tracker_soft_reuse = + StatsRegisterCounter("defrag.tracker_soft_reuse", &tv->stats); + dtv->counter_defrag_tracker_hard_reuse = + StatsRegisterCounter("defrag.tracker_hard_reuse", &tv->stats); + dtv->counter_defrag_tracker_timeout = + StatsRegisterCounter("defrag.wrk.tracker_timeout", &tv->stats); ExceptionPolicySetStatsCounters(tv, &dtv->counter_defrag_memcap_eps, &defrag_memcap_eps_stats, DefragGetMemcapExceptionPolicy(), "exception_policy.defrag.memcap.", @@ -761,13 +771,11 @@ void DecodeRegisterPerfCounters(DecodeThreadVars *dtv, ThreadVars *tv) "table name add failed"); found = add; } - dtv->counter_engine_events[i] = StatsRegisterCounter( - found, tv); + dtv->counter_engine_events[i] = StatsRegisterCounter(found, &tv->stats); SCMutexUnlock(&g_counter_table_mutex); } else { - dtv->counter_engine_events[i] = StatsRegisterCounter( - DEvents[i].event_name, tv); + dtv->counter_engine_events[i] = StatsRegisterCounter(DEvents[i].event_name, &tv->stats); } } } @@ -1039,14 +1047,14 @@ void CaptureStatsSetup(ThreadVars *tv) { if (EngineModeIsIPS()) { CaptureStats *s = &t_capture_stats; - s->counter_ips_accepted = StatsRegisterCounter("ips.accepted", tv); - s->counter_ips_blocked = StatsRegisterCounter("ips.blocked", tv); - s->counter_ips_rejected = StatsRegisterCounter("ips.rejected", tv); - s->counter_ips_replaced = StatsRegisterCounter("ips.replaced", tv); + s->counter_ips_accepted = StatsRegisterCounter("ips.accepted", &tv->stats); + s->counter_ips_blocked = StatsRegisterCounter("ips.blocked", &tv->stats); + s->counter_ips_rejected = StatsRegisterCounter("ips.rejected", &tv->stats); + s->counter_ips_replaced = StatsRegisterCounter("ips.replaced", &tv->stats); for (int i = PKT_DROP_REASON_NOT_SET; i < PKT_DROP_REASON_MAX; i++) { const char *name = PacketDropReasonToJsonString(i); if (name != NULL) - s->counter_drop_reason[i] = StatsRegisterCounter(name, tv); + s->counter_drop_reason[i] = StatsRegisterCounter(name, &tv->stats); } } } diff --git a/src/detect-engine.c b/src/detect-engine.c index 6c42fedd25..b6d2d42376 100644 --- a/src/detect-engine.c +++ b/src/detect-engine.c @@ -3393,31 +3393,34 @@ TmEcode DetectEngineThreadCtxInit(ThreadVars *tv, void *initdata, void **data) } /** alert counter setup */ - det_ctx->counter_alerts = StatsRegisterCounter("detect.alert", tv); - det_ctx->counter_alerts_overflow = StatsRegisterCounter("detect.alert_queue_overflow", tv); - det_ctx->counter_alerts_suppressed = StatsRegisterCounter("detect.alerts_suppressed", tv); + det_ctx->counter_alerts = StatsRegisterCounter("detect.alert", &tv->stats); + det_ctx->counter_alerts_overflow = + StatsRegisterCounter("detect.alert_queue_overflow", &tv->stats); + det_ctx->counter_alerts_suppressed = + StatsRegisterCounter("detect.alerts_suppressed", &tv->stats); /* Register counter for Lua rule errors. */ - det_ctx->lua_rule_errors = StatsRegisterCounter("detect.lua.errors", tv); + det_ctx->lua_rule_errors = StatsRegisterCounter("detect.lua.errors", &tv->stats); /* Register a counter for Lua blocked function attempts. */ det_ctx->lua_blocked_function_errors = - StatsRegisterCounter("detect.lua.blocked_function_errors", tv); + StatsRegisterCounter("detect.lua.blocked_function_errors", &tv->stats); /* Register a counter for Lua instruction limit errors. */ det_ctx->lua_instruction_limit_errors = - StatsRegisterCounter("detect.lua.instruction_limit_errors", tv); + StatsRegisterCounter("detect.lua.instruction_limit_errors", &tv->stats); /* Register a counter for Lua memory limit errors. */ - det_ctx->lua_memory_limit_errors = StatsRegisterCounter("detect.lua.memory_limit_errors", tv); + det_ctx->lua_memory_limit_errors = + StatsRegisterCounter("detect.lua.memory_limit_errors", &tv->stats); det_ctx->json_content = NULL; det_ctx->json_content_capacity = 0; det_ctx->json_content_len = 0; #ifdef PROFILING - det_ctx->counter_mpm_list = StatsRegisterAvgCounter("detect.mpm_list", tv); - det_ctx->counter_match_list = StatsRegisterAvgCounter("detect.match_list", tv); + det_ctx->counter_mpm_list = StatsRegisterAvgCounter("detect.mpm_list", &tv->stats); + det_ctx->counter_match_list = StatsRegisterAvgCounter("detect.match_list", &tv->stats); #endif if (DetectEngineMultiTenantEnabled()) { @@ -3473,12 +3476,14 @@ DetectEngineThreadCtx *DetectEngineThreadCtxInitForReload( } /** alert counter setup */ - det_ctx->counter_alerts = StatsRegisterCounter("detect.alert", tv); - det_ctx->counter_alerts_overflow = StatsRegisterCounter("detect.alert_queue_overflow", tv); - det_ctx->counter_alerts_suppressed = StatsRegisterCounter("detect.alerts_suppressed", tv); + det_ctx->counter_alerts = StatsRegisterCounter("detect.alert", &tv->stats); + det_ctx->counter_alerts_overflow = + StatsRegisterCounter("detect.alert_queue_overflow", &tv->stats); + det_ctx->counter_alerts_suppressed = + StatsRegisterCounter("detect.alerts_suppressed", &tv->stats); #ifdef PROFILING - det_ctx->counter_mpm_list = StatsRegisterAvgCounter("detect.mpm_list", tv); - det_ctx->counter_match_list = StatsRegisterAvgCounter("detect.match_list", tv); + det_ctx->counter_mpm_list = StatsRegisterAvgCounter("detect.mpm_list", &tv->stats); + det_ctx->counter_match_list = StatsRegisterAvgCounter("detect.match_list", &tv->stats); #endif if (mt && DetectEngineMultiTenantEnabledWithLock()) { diff --git a/src/flow-bypass.c b/src/flow-bypass.c index 35d13ee11c..4191b88a3e 100644 --- a/src/flow-bypass.c +++ b/src/flow-bypass.c @@ -139,9 +139,9 @@ static TmEcode BypassedFlowManagerThreadInit(ThreadVars *t, const void *initdata *data = ftd; - ftd->flow_bypassed_cnt_clo = StatsRegisterCounter("flow_bypassed.closed", t); - ftd->flow_bypassed_pkts = StatsRegisterCounter("flow_bypassed.pkts", t); - ftd->flow_bypassed_bytes = StatsRegisterCounter("flow_bypassed.bytes", t); + ftd->flow_bypassed_cnt_clo = StatsRegisterCounter("flow_bypassed.closed", &t->stats); + ftd->flow_bypassed_pkts = StatsRegisterCounter("flow_bypassed.pkts", &t->stats); + ftd->flow_bypassed_bytes = StatsRegisterCounter("flow_bypassed.bytes", &t->stats); return TM_ECODE_OK; } diff --git a/src/flow-manager.c b/src/flow-manager.c index cae425db79..49c9294000 100644 --- a/src/flow-manager.c +++ b/src/flow-manager.c @@ -679,26 +679,27 @@ typedef struct FlowManagerThreadData_ { static void FlowCountersInit(ThreadVars *t, FlowCounters *fc) { - fc->flow_mgr_full_pass = StatsRegisterCounter("flow.mgr.full_hash_pass", t); - fc->flow_mgr_rows_sec = StatsRegisterCounter("flow.mgr.rows_per_sec", t); + fc->flow_mgr_full_pass = StatsRegisterCounter("flow.mgr.full_hash_pass", &t->stats); + fc->flow_mgr_rows_sec = StatsRegisterCounter("flow.mgr.rows_per_sec", &t->stats); - fc->flow_mgr_spare = StatsRegisterCounter("flow.spare", t); - fc->flow_emerg_mode_enter = StatsRegisterCounter("flow.emerg_mode_entered", t); - fc->flow_emerg_mode_over = StatsRegisterCounter("flow.emerg_mode_over", t); + fc->flow_mgr_spare = StatsRegisterCounter("flow.spare", &t->stats); + fc->flow_emerg_mode_enter = StatsRegisterCounter("flow.emerg_mode_entered", &t->stats); + fc->flow_emerg_mode_over = StatsRegisterCounter("flow.emerg_mode_over", &t->stats); - fc->flow_mgr_rows_maxlen = StatsRegisterMaxCounter("flow.mgr.rows_maxlen", t); - fc->flow_mgr_flows_checked = StatsRegisterCounter("flow.mgr.flows_checked", t); - fc->flow_mgr_flows_notimeout = StatsRegisterCounter("flow.mgr.flows_notimeout", t); - fc->flow_mgr_flows_timeout = StatsRegisterCounter("flow.mgr.flows_timeout", t); - fc->flow_mgr_flows_aside = StatsRegisterCounter("flow.mgr.flows_evicted", t); - fc->flow_mgr_flows_aside_needs_work = StatsRegisterCounter("flow.mgr.flows_evicted_needs_work", t); + fc->flow_mgr_rows_maxlen = StatsRegisterMaxCounter("flow.mgr.rows_maxlen", &t->stats); + fc->flow_mgr_flows_checked = StatsRegisterCounter("flow.mgr.flows_checked", &t->stats); + fc->flow_mgr_flows_notimeout = StatsRegisterCounter("flow.mgr.flows_notimeout", &t->stats); + fc->flow_mgr_flows_timeout = StatsRegisterCounter("flow.mgr.flows_timeout", &t->stats); + fc->flow_mgr_flows_aside = StatsRegisterCounter("flow.mgr.flows_evicted", &t->stats); + fc->flow_mgr_flows_aside_needs_work = + StatsRegisterCounter("flow.mgr.flows_evicted_needs_work", &t->stats); - fc->flow_bypassed_cnt_clo = StatsRegisterCounter("flow_bypassed.closed", t); - fc->flow_bypassed_pkts = StatsRegisterCounter("flow_bypassed.pkts", t); - fc->flow_bypassed_bytes = StatsRegisterCounter("flow_bypassed.bytes", t); + fc->flow_bypassed_cnt_clo = StatsRegisterCounter("flow_bypassed.closed", &t->stats); + fc->flow_bypassed_pkts = StatsRegisterCounter("flow_bypassed.pkts", &t->stats); + fc->flow_bypassed_bytes = StatsRegisterCounter("flow_bypassed.bytes", &t->stats); - fc->memcap_pressure = StatsRegisterCounter("memcap.pressure", t); - fc->memcap_pressure_max = StatsRegisterMaxCounter("memcap.pressure_max", t); + fc->memcap_pressure = StatsRegisterCounter("memcap.pressure", &t->stats); + fc->memcap_pressure_max = StatsRegisterMaxCounter("memcap.pressure_max", &t->stats); } static void FlowCountersUpdate( @@ -753,8 +754,8 @@ static TmEcode FlowManagerThreadInit(ThreadVars *t, const void *initdata, void * *data = ftd; FlowCountersInit(t, &ftd->cnt); - ftd->counter_defrag_timeout = StatsRegisterCounter("defrag.mgr.tracker_timeout", t); - ftd->counter_defrag_memuse = StatsRegisterCounter("defrag.memuse", t); + ftd->counter_defrag_timeout = StatsRegisterCounter("defrag.mgr.tracker_timeout", &t->stats); + ftd->counter_defrag_memuse = StatsRegisterCounter("defrag.memuse", &t->stats); PacketPoolInit(); return TM_ECODE_OK; @@ -1060,12 +1061,12 @@ static TmEcode FlowRecyclerThreadInit(ThreadVars *t, const void *initdata, void } SCLogDebug("output_thread_data %p", ftd->output_thread_data); - ftd->counter_flows = StatsRegisterCounter("flow.recycler.recycled", t); - ftd->counter_queue_avg = StatsRegisterAvgCounter("flow.recycler.queue_avg", t); - ftd->counter_queue_max = StatsRegisterMaxCounter("flow.recycler.queue_max", t); + ftd->counter_flows = StatsRegisterCounter("flow.recycler.recycled", &t->stats); + ftd->counter_queue_avg = StatsRegisterAvgCounter("flow.recycler.queue_avg", &t->stats); + ftd->counter_queue_max = StatsRegisterMaxCounter("flow.recycler.queue_max", &t->stats); - ftd->counter_flow_active = StatsRegisterCounter("flow.active", t); - ftd->counter_tcp_active_sessions = StatsRegisterCounter("tcp.active_sessions", t); + ftd->counter_flow_active = StatsRegisterCounter("flow.active", &t->stats); + ftd->counter_tcp_active_sessions = StatsRegisterCounter("tcp.active_sessions", &t->stats); FlowEndCountersRegister(t, &ftd->fec); diff --git a/src/flow-util.c b/src/flow-util.c index 05508723a2..9a77a41a4a 100644 --- a/src/flow-util.c +++ b/src/flow-util.c @@ -261,7 +261,7 @@ void FlowEndCountersRegister(ThreadVars *t, FlowEndCounters *fec) #endif } if (name) { - fec->flow_state[i] = StatsRegisterCounter(name, t); + fec->flow_state[i] = StatsRegisterCounter(name, &t->stats); } } @@ -303,7 +303,7 @@ void FlowEndCountersRegister(ThreadVars *t, FlowEndCounters *fec) break; } - fec->flow_tcp_state[i] = StatsRegisterCounter(name, t); + fec->flow_tcp_state[i] = StatsRegisterCounter(name, &t->stats); } - fec->flow_tcp_liberal = StatsRegisterCounter("flow.end.tcp_liberal", t); + fec->flow_tcp_liberal = StatsRegisterCounter("flow.end.tcp_liberal", &t->stats); } diff --git a/src/flow-worker.c b/src/flow-worker.c index ebe5d38315..5178e309a0 100644 --- a/src/flow-worker.c +++ b/src/flow-worker.c @@ -253,16 +253,18 @@ static TmEcode FlowWorkerThreadInit(ThreadVars *tv, const void *initdata, void * SC_ATOMIC_INITPTR(fw->detect_thread); SC_ATOMIC_SET(fw->detect_thread, NULL); - fw->local_bypass_pkts = StatsRegisterCounter("flow_bypassed.local_pkts", tv); - fw->local_bypass_bytes = StatsRegisterCounter("flow_bypassed.local_bytes", tv); - fw->both_bypass_pkts = StatsRegisterCounter("flow_bypassed.local_capture_pkts", tv); - fw->both_bypass_bytes = StatsRegisterCounter("flow_bypassed.local_capture_bytes", tv); + fw->local_bypass_pkts = StatsRegisterCounter("flow_bypassed.local_pkts", &tv->stats); + fw->local_bypass_bytes = StatsRegisterCounter("flow_bypassed.local_bytes", &tv->stats); + fw->both_bypass_pkts = StatsRegisterCounter("flow_bypassed.local_capture_pkts", &tv->stats); + fw->both_bypass_bytes = StatsRegisterCounter("flow_bypassed.local_capture_bytes", &tv->stats); - fw->cnt.flows_aside_needs_work = StatsRegisterCounter("flow.wrk.flows_evicted_needs_work", tv); - fw->cnt.flows_aside_pkt_inject = StatsRegisterCounter("flow.wrk.flows_evicted_pkt_inject", tv); - fw->cnt.flows_removed = StatsRegisterCounter("flow.wrk.flows_evicted", tv); - fw->cnt.flows_injected = StatsRegisterCounter("flow.wrk.flows_injected", tv); - fw->cnt.flows_injected_max = StatsRegisterMaxCounter("flow.wrk.flows_injected_max", tv); + fw->cnt.flows_aside_needs_work = + StatsRegisterCounter("flow.wrk.flows_evicted_needs_work", &tv->stats); + fw->cnt.flows_aside_pkt_inject = + StatsRegisterCounter("flow.wrk.flows_evicted_pkt_inject", &tv->stats); + fw->cnt.flows_removed = StatsRegisterCounter("flow.wrk.flows_evicted", &tv->stats); + fw->cnt.flows_injected = StatsRegisterCounter("flow.wrk.flows_injected", &tv->stats); + fw->cnt.flows_injected_max = StatsRegisterMaxCounter("flow.wrk.flows_injected_max", &tv->stats); fw->fls.dtv = fw->dtv = DecodeThreadVarsAlloc(tv); if (fw->dtv == NULL) { diff --git a/src/log-pcap.c b/src/log-pcap.c index 83632ba241..8c4f3a434f 100644 --- a/src/log-pcap.c +++ b/src/log-pcap.c @@ -1053,8 +1053,8 @@ static TmEcode PcapLogDataInit(ThreadVars *t, const void *initdata, void **data) if (unlikely(td == NULL)) return TM_ECODE_FAILED; - td->counter_written = StatsRegisterCounter("pcap_log.written", t); - td->counter_filtered_bpf = StatsRegisterCounter("pcap_log.filtered_bpf", t); + td->counter_written = StatsRegisterCounter("pcap_log.written", &t->stats); + td->counter_filtered_bpf = StatsRegisterCounter("pcap_log.filtered_bpf", &t->stats); if (pl->mode == LOGMODE_MULTI) td->pcap_log = PcapLogDataCopy(pl); diff --git a/src/output-filestore.c b/src/output-filestore.c index 33fbb00564..84a68aa4e8 100644 --- a/src/output-filestore.c +++ b/src/output-filestore.c @@ -294,12 +294,12 @@ static TmEcode OutputFilestoreLogThreadInit(ThreadVars *t, const void *initdata, OutputFilestoreCtx *ctx = ((OutputCtx *)initdata)->data; aft->ctx = ctx; - aft->counter_max_hits = StatsRegisterCounter("file_store.open_files_max_hit", t); + aft->counter_max_hits = StatsRegisterCounter("file_store.open_files_max_hit", &t->stats); /* File system type errors (open, write, rename) will only be * logged once. But this stat will be incremented for every * occurrence. */ - aft->fs_error_counter = StatsRegisterCounter("file_store.fs_errors", t); + aft->fs_error_counter = StatsRegisterCounter("file_store.fs_errors", &t->stats); *data = (void *)aft; return TM_ECODE_OK; diff --git a/src/source-af-packet.c b/src/source-af-packet.c index d6a0907ff8..108271fb69 100644 --- a/src/source-af-packet.c +++ b/src/source-af-packet.c @@ -2634,21 +2634,23 @@ TmEcode ReceiveAFPThreadInit(ThreadVars *tv, const void *initdata, void **data) #endif #ifdef PACKET_STATISTICS - ptv->capture_kernel_packets = StatsRegisterCounter("capture.kernel_packets", - ptv->tv); - ptv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", - ptv->tv); - ptv->capture_errors = StatsRegisterCounter("capture.errors", - ptv->tv); + ptv->capture_kernel_packets = StatsRegisterCounter("capture.kernel_packets", &ptv->tv->stats); + ptv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", &ptv->tv->stats); + ptv->capture_errors = StatsRegisterCounter("capture.errors", &ptv->tv->stats); - ptv->afpacket_spin = StatsRegisterAvgCounter("capture.afpacket.busy_loop_avg", ptv->tv); + ptv->afpacket_spin = StatsRegisterAvgCounter("capture.afpacket.busy_loop_avg", &ptv->tv->stats); - ptv->capture_afp_poll = StatsRegisterCounter("capture.afpacket.polls", ptv->tv); - ptv->capture_afp_poll_signal = StatsRegisterCounter("capture.afpacket.poll_signal", ptv->tv); - ptv->capture_afp_poll_timeout = StatsRegisterCounter("capture.afpacket.poll_timeout", ptv->tv); - ptv->capture_afp_poll_data = StatsRegisterCounter("capture.afpacket.poll_data", ptv->tv); - ptv->capture_afp_poll_err = StatsRegisterCounter("capture.afpacket.poll_errors", ptv->tv); - ptv->capture_afp_send_err = StatsRegisterCounter("capture.afpacket.send_errors", ptv->tv); + ptv->capture_afp_poll = StatsRegisterCounter("capture.afpacket.polls", &ptv->tv->stats); + ptv->capture_afp_poll_signal = + StatsRegisterCounter("capture.afpacket.poll_signal", &ptv->tv->stats); + ptv->capture_afp_poll_timeout = + StatsRegisterCounter("capture.afpacket.poll_timeout", &ptv->tv->stats); + ptv->capture_afp_poll_data = + StatsRegisterCounter("capture.afpacket.poll_data", &ptv->tv->stats); + ptv->capture_afp_poll_err = + StatsRegisterCounter("capture.afpacket.poll_errors", &ptv->tv->stats); + ptv->capture_afp_send_err = + StatsRegisterCounter("capture.afpacket.send_errors", &ptv->tv->stats); #endif ptv->copy_mode = afpconfig->copy_mode; diff --git a/src/source-af-xdp.c b/src/source-af-xdp.c index 09ece5b793..9fbb30ebf3 100644 --- a/src/source-af-xdp.c +++ b/src/source-af-xdp.c @@ -660,15 +660,19 @@ static TmEcode ReceiveAFXDPThreadInit(ThreadVars *tv, const void *initdata, void ptv->napi_defer_hard_irqs = afxdpconfig->napi_defer_hard_irqs; /* Stats registration */ - ptv->capture_afxdp_packets = StatsRegisterCounter("capture.afxdp_packets", ptv->tv); - ptv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", ptv->tv); - ptv->capture_afxdp_poll = StatsRegisterCounter("capture.afxdp.poll", ptv->tv); - ptv->capture_afxdp_poll_timeout = StatsRegisterCounter("capture.afxdp.poll_timeout", ptv->tv); - ptv->capture_afxdp_poll_failed = StatsRegisterCounter("capture.afxdp.poll_failed", ptv->tv); - ptv->capture_afxdp_empty_reads = StatsRegisterCounter("capture.afxdp.empty_reads", ptv->tv); - ptv->capture_afxdp_failed_reads = StatsRegisterCounter("capture.afxdp.failed_reads", ptv->tv); + ptv->capture_afxdp_packets = StatsRegisterCounter("capture.afxdp_packets", &ptv->tv->stats); + ptv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", &ptv->tv->stats); + ptv->capture_afxdp_poll = StatsRegisterCounter("capture.afxdp.poll", &ptv->tv->stats); + ptv->capture_afxdp_poll_timeout = + StatsRegisterCounter("capture.afxdp.poll_timeout", &ptv->tv->stats); + ptv->capture_afxdp_poll_failed = + StatsRegisterCounter("capture.afxdp.poll_failed", &ptv->tv->stats); + ptv->capture_afxdp_empty_reads = + StatsRegisterCounter("capture.afxdp.empty_reads", &ptv->tv->stats); + ptv->capture_afxdp_failed_reads = + StatsRegisterCounter("capture.afxdp.failed_reads", &ptv->tv->stats); ptv->capture_afxdp_acquire_pkt_failed = - StatsRegisterCounter("capture.afxdp.acquire_pkt_failed", ptv->tv); + StatsRegisterCounter("capture.afxdp.acquire_pkt_failed", &ptv->tv->stats); /* Reserve memory for umem */ if (AcquireBuffer(ptv) != TM_ECODE_OK) { diff --git a/src/source-dpdk.c b/src/source-dpdk.c index 33f066c4bf..3fd7bf7e07 100644 --- a/src/source-dpdk.c +++ b/src/source-dpdk.c @@ -594,12 +594,12 @@ static TmEcode ReceiveDPDKThreadInit(ThreadVars *tv, const void *initdata, void ptv->bytes = 0; ptv->livedev = LiveGetDevice(dpdk_config->iface); - ptv->capture_dpdk_packets = StatsRegisterCounter("capture.packets", ptv->tv); - ptv->capture_dpdk_rx_errs = StatsRegisterCounter("capture.rx_errors", ptv->tv); - ptv->capture_dpdk_tx_errs = StatsRegisterCounter("capture.tx_errors", ptv->tv); - ptv->capture_dpdk_imissed = StatsRegisterCounter("capture.dpdk.imissed", ptv->tv); - ptv->capture_dpdk_rx_no_mbufs = StatsRegisterCounter("capture.dpdk.no_mbufs", ptv->tv); - ptv->capture_dpdk_ierrors = StatsRegisterCounter("capture.dpdk.ierrors", ptv->tv); + ptv->capture_dpdk_packets = StatsRegisterCounter("capture.packets", &ptv->tv->stats); + ptv->capture_dpdk_rx_errs = StatsRegisterCounter("capture.rx_errors", &ptv->tv->stats); + ptv->capture_dpdk_tx_errs = StatsRegisterCounter("capture.tx_errors", &ptv->tv->stats); + ptv->capture_dpdk_imissed = StatsRegisterCounter("capture.dpdk.imissed", &ptv->tv->stats); + ptv->capture_dpdk_rx_no_mbufs = StatsRegisterCounter("capture.dpdk.no_mbufs", &ptv->tv->stats); + ptv->capture_dpdk_ierrors = StatsRegisterCounter("capture.dpdk.ierrors", &ptv->tv->stats); ptv->copy_mode = dpdk_config->copy_mode; ptv->checksum_mode = dpdk_config->checksum_mode; diff --git a/src/source-netmap.c b/src/source-netmap.c index ef736f5be5..a4cc78182a 100644 --- a/src/source-netmap.c +++ b/src/source-netmap.c @@ -550,10 +550,8 @@ static TmEcode ReceiveNetmapThreadInit(ThreadVars *tv, const void *initdata, voi } /* basic counters */ - ntv->capture_kernel_packets = StatsRegisterCounter("capture.kernel_packets", - ntv->tv); - ntv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", - ntv->tv); + ntv->capture_kernel_packets = StatsRegisterCounter("capture.kernel_packets", &ntv->tv->stats); + ntv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", &ntv->tv->stats); if (aconf->in.bpf_filter) { SCLogConfig("%s: using BPF '%s'", ntv->ifsrc->ifname, aconf->in.bpf_filter); diff --git a/src/source-nflog.c b/src/source-nflog.c index aa4a8f0758..a9c27cfcaf 100644 --- a/src/source-nflog.c +++ b/src/source-nflog.c @@ -308,10 +308,8 @@ TmEcode ReceiveNFLOGThreadInit(ThreadVars *tv, const void *initdata, void **data } #ifdef PACKET_STATISTICS - ntv->capture_kernel_packets = StatsRegisterCounter("capture.kernel_packets", - ntv->tv); - ntv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", - ntv->tv); + ntv->capture_kernel_packets = StatsRegisterCounter("capture.kernel_packets", &ntv->tv->stats); + ntv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", &ntv->tv->stats); #endif char *active_runmode = RunmodeGetActive(); diff --git a/src/source-pcap.c b/src/source-pcap.c index 79f9f5c1d3..950abd967d 100644 --- a/src/source-pcap.c +++ b/src/source-pcap.c @@ -533,12 +533,9 @@ static TmEcode ReceivePcapThreadInit(ThreadVars *tv, const void *initdata, void pcapconfig->DerefFunc(pcapconfig); - ptv->capture_kernel_packets = StatsRegisterCounter("capture.kernel_packets", - ptv->tv); - ptv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", - ptv->tv); - ptv->capture_kernel_ifdrops = StatsRegisterCounter("capture.kernel_ifdrops", - ptv->tv); + ptv->capture_kernel_packets = StatsRegisterCounter("capture.kernel_packets", &ptv->tv->stats); + ptv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", &ptv->tv->stats); + ptv->capture_kernel_ifdrops = StatsRegisterCounter("capture.kernel_ifdrops", &ptv->tv->stats); *data = (void *)ptv; SCReturnInt(TM_ECODE_OK); diff --git a/src/stream-tcp.c b/src/stream-tcp.c index 6d26589199..3d89917d72 100644 --- a/src/stream-tcp.c +++ b/src/stream-tcp.c @@ -6111,18 +6111,18 @@ TmEcode StreamTcpThreadInit(ThreadVars *tv, void *initdata, void **data) *data = (void *)stt; - stt->counter_tcp_active_sessions = StatsRegisterCounter("tcp.active_sessions", tv); - stt->counter_tcp_sessions = StatsRegisterCounter("tcp.sessions", tv); - stt->counter_tcp_ssn_memcap = StatsRegisterCounter("tcp.ssn_memcap_drop", tv); - stt->counter_tcp_ssn_from_cache = StatsRegisterCounter("tcp.ssn_from_cache", tv); - stt->counter_tcp_ssn_from_pool = StatsRegisterCounter("tcp.ssn_from_pool", tv); + stt->counter_tcp_active_sessions = StatsRegisterCounter("tcp.active_sessions", &tv->stats); + stt->counter_tcp_sessions = StatsRegisterCounter("tcp.sessions", &tv->stats); + stt->counter_tcp_ssn_memcap = StatsRegisterCounter("tcp.ssn_memcap_drop", &tv->stats); + stt->counter_tcp_ssn_from_cache = StatsRegisterCounter("tcp.ssn_from_cache", &tv->stats); + stt->counter_tcp_ssn_from_pool = StatsRegisterCounter("tcp.ssn_from_pool", &tv->stats); ExceptionPolicySetStatsCounters(tv, &stt->counter_tcp_ssn_memcap_eps, &stream_memcap_eps_stats, stream_config.ssn_memcap_policy, "exception_policy.tcp.ssn_memcap.", IsStreamTcpSessionMemcapExceptionPolicyStatsValid); - stt->counter_tcp_pseudo = StatsRegisterCounter("tcp.pseudo", tv); - stt->counter_tcp_invalid_checksum = StatsRegisterCounter("tcp.invalid_checksum", tv); - stt->counter_tcp_midstream_pickups = StatsRegisterCounter("tcp.midstream_pickups", tv); + stt->counter_tcp_pseudo = StatsRegisterCounter("tcp.pseudo", &tv->stats); + stt->counter_tcp_invalid_checksum = StatsRegisterCounter("tcp.invalid_checksum", &tv->stats); + stt->counter_tcp_midstream_pickups = StatsRegisterCounter("tcp.midstream_pickups", &tv->stats); if (stream_config.midstream) { ExceptionPolicySetStatsCounters(tv, &stt->counter_tcp_midstream_eps, &stream_midstream_enabled_eps_stats, stream_config.midstream_policy, @@ -6133,31 +6133,37 @@ TmEcode StreamTcpThreadInit(ThreadVars *tv, void *initdata, void **data) "exception_policy.tcp.midstream.", IsMidstreamExceptionPolicyStatsValid); } - stt->counter_tcp_wrong_thread = StatsRegisterCounter("tcp.pkt_on_wrong_thread", tv); - stt->counter_tcp_ack_unseen_data = StatsRegisterCounter("tcp.ack_unseen_data", tv); + stt->counter_tcp_wrong_thread = StatsRegisterCounter("tcp.pkt_on_wrong_thread", &tv->stats); + stt->counter_tcp_ack_unseen_data = StatsRegisterCounter("tcp.ack_unseen_data", &tv->stats); /* init reassembly ctx */ stt->ra_ctx = StreamTcpReassembleInitThreadCtx(tv); if (stt->ra_ctx == NULL) SCReturnInt(TM_ECODE_FAILED); - stt->ra_ctx->counter_tcp_segment_memcap = StatsRegisterCounter("tcp.segment_memcap_drop", tv); + stt->ra_ctx->counter_tcp_segment_memcap = + StatsRegisterCounter("tcp.segment_memcap_drop", &tv->stats); ExceptionPolicySetStatsCounters(tv, &stt->ra_ctx->counter_tcp_reas_eps, &stream_reassembly_memcap_eps_stats, stream_config.reassembly_memcap_policy, "exception_policy.tcp.reassembly.", IsReassemblyMemcapExceptionPolicyStatsValid); stt->ra_ctx->counter_tcp_segment_from_cache = - StatsRegisterCounter("tcp.segment_from_cache", tv); - stt->ra_ctx->counter_tcp_segment_from_pool = StatsRegisterCounter("tcp.segment_from_pool", tv); - stt->ra_ctx->counter_tcp_stream_depth = StatsRegisterCounter("tcp.stream_depth_reached", tv); - stt->ra_ctx->counter_tcp_reass_gap = StatsRegisterCounter("tcp.reassembly_gap", tv); - stt->ra_ctx->counter_tcp_reass_overlap = StatsRegisterCounter("tcp.overlap", tv); - stt->ra_ctx->counter_tcp_reass_overlap_diff_data = StatsRegisterCounter("tcp.overlap_diff_data", tv); + StatsRegisterCounter("tcp.segment_from_cache", &tv->stats); + stt->ra_ctx->counter_tcp_segment_from_pool = + StatsRegisterCounter("tcp.segment_from_pool", &tv->stats); + stt->ra_ctx->counter_tcp_stream_depth = + StatsRegisterCounter("tcp.stream_depth_reached", &tv->stats); + stt->ra_ctx->counter_tcp_reass_gap = StatsRegisterCounter("tcp.reassembly_gap", &tv->stats); + stt->ra_ctx->counter_tcp_reass_overlap = StatsRegisterCounter("tcp.overlap", &tv->stats); + stt->ra_ctx->counter_tcp_reass_overlap_diff_data = + StatsRegisterCounter("tcp.overlap_diff_data", &tv->stats); - stt->ra_ctx->counter_tcp_reass_data_normal_fail = StatsRegisterCounter("tcp.insert_data_normal_fail", tv); - stt->ra_ctx->counter_tcp_reass_data_overlap_fail = StatsRegisterCounter("tcp.insert_data_overlap_fail", tv); - stt->ra_ctx->counter_tcp_urgent_oob = StatsRegisterCounter("tcp.urgent_oob_data", tv); + stt->ra_ctx->counter_tcp_reass_data_normal_fail = + StatsRegisterCounter("tcp.insert_data_normal_fail", &tv->stats); + stt->ra_ctx->counter_tcp_reass_data_overlap_fail = + StatsRegisterCounter("tcp.insert_data_overlap_fail", &tv->stats); + stt->ra_ctx->counter_tcp_urgent_oob = StatsRegisterCounter("tcp.urgent_oob_data", &tv->stats); SCLogDebug("StreamTcp thread specific ctx online at %p, reassembly ctx %p", stt, stt->ra_ctx); diff --git a/src/util-exception-policy.c b/src/util-exception-policy.c index f3404b54c6..1861bf9069 100644 --- a/src/util-exception-policy.c +++ b/src/util-exception-policy.c @@ -384,7 +384,7 @@ void ExceptionPolicySetStatsCounters(ThreadVars *tv, ExceptionPolicyCounters *co if (isExceptionPolicyValid(i)) { snprintf(setting->eps_name[i], sizeof(setting->eps_name[i]), "%s%s", default_str, ExceptionPolicyEnumToString(i, true)); - counter->eps_id[i] = StatsRegisterCounter(setting->eps_name[i], tv); + counter->eps_id[i] = StatsRegisterCounter(setting->eps_name[i], &tv->stats); } } }