From: Victor Julien Date: Tue, 26 May 2015 12:33:21 +0000 (+0200) Subject: counters: rename register API calls X-Git-Tag: suricata-3.0RC1~367 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=1ef786e7cba546780ecd8e8e48f13b4af26b9963;p=thirdparty%2Fsuricata.git counters: rename register API calls Also remove 'type' parameter which was always the same. --- diff --git a/src/app-layer.c b/src/app-layer.c index 1f8590f513..5dfd433c61 100644 --- a/src/app-layer.c +++ b/src/app-layer.c @@ -603,12 +603,9 @@ AppLayerThreadCtx *AppLayerGetCtxThread(ThreadVars *tv) /* tv is allowed to be NULL in unittests */ if (tv != NULL) { - app_tctx->counter_dns_memuse = SCPerfTVRegisterCounter("dns.memuse", tv, - SC_PERF_TYPE_UINT64); - app_tctx->counter_dns_memcap_state = SCPerfTVRegisterCounter("dns.memcap_state", tv, - SC_PERF_TYPE_UINT64); - app_tctx->counter_dns_memcap_global = SCPerfTVRegisterCounter("dns.memcap_global", tv, - SC_PERF_TYPE_UINT64); + app_tctx->counter_dns_memuse = StatsRegisterCounter("dns.memuse", tv); + app_tctx->counter_dns_memcap_state = StatsRegisterCounter("dns.memcap_state", tv); + app_tctx->counter_dns_memcap_global = StatsRegisterCounter("dns.memcap_global", tv); } goto done; diff --git a/src/counters.c b/src/counters.c index acf2a1c9ba..0e686191cf 100644 --- a/src/counters.c +++ b/src/counters.c @@ -496,7 +496,6 @@ static void SCPerfReleaseCounter(SCPerfCounter *pc) * * \param cname Name of the counter, to be registered * \param tm_name Thread module to which this counter belongs - * \param type Datatype of this counter variable * \param pctx SCPerfPublicContext for this tm-tv instance * \param type_q Qualifier describing the type of counter to be registered * @@ -504,9 +503,9 @@ static void SCPerfReleaseCounter(SCPerfCounter *pc) * present counter on success * \retval 0 on failure */ -static uint16_t SCPerfRegisterQualifiedCounter(char *cname, char *tm_name, - int type, SCPerfPublicContext *pctx, - int type_q, uint64_t (*Func)(void)) +static uint16_t StatsRegisterQualifiedCounter(char *cname, char *tm_name, + SCPerfPublicContext *pctx, + int type_q, uint64_t (*Func)(void)) { SCPerfCounter **head = &pctx->head; SCPerfCounter *temp = NULL; @@ -518,12 +517,6 @@ static uint16_t SCPerfRegisterQualifiedCounter(char *cname, char *tm_name, return 0; } - if ((type >= SC_PERF_TYPE_MAX) || (type < 0)) { - SCLogError(SC_ERR_INVALID_ARGUMENTS, "Counters of type %" PRId32 " can't " - "be registered", type); - return 0; - } - temp = prev = *head; while (temp != NULL) { prev = temp; @@ -946,16 +939,14 @@ void SCPerfSpawnThreads(void) * \param cname Name of the counter, to be registered * \param tv Pointer to the ThreadVars instance for which the counter would * be registered - * \param type Datatype of this counter variable * * \retval id Counter id for the newly registered counter, or the already * present counter */ -uint16_t SCPerfTVRegisterCounter(char *cname, struct ThreadVars_ *tv, int type) +uint16_t StatsRegisterCounter(char *cname, struct ThreadVars_ *tv) { - uint16_t id = SCPerfRegisterQualifiedCounter(cname, + uint16_t id = StatsRegisterQualifiedCounter(cname, (tv->thread_group_name != NULL) ? tv->thread_group_name : tv->name, - type, &tv->perf_public_ctx, STATS_TYPE_NORMAL, NULL); @@ -969,17 +960,14 @@ uint16_t SCPerfTVRegisterCounter(char *cname, struct ThreadVars_ *tv, int type) * \param cname Name of the counter, to be registered * \param tv Pointer to the ThreadVars instance for which the counter would * be registered - * \param type Datatype of this counter variable * * \retval id Counter id for the newly registered counter, or the already * present counter */ -uint16_t SCPerfTVRegisterAvgCounter(char *cname, struct ThreadVars_ *tv, - int type) +uint16_t StatsRegisterAvgCounter(char *cname, struct ThreadVars_ *tv) { - uint16_t id = SCPerfRegisterQualifiedCounter(cname, + uint16_t id = StatsRegisterQualifiedCounter(cname, (tv->thread_group_name != NULL) ? tv->thread_group_name : tv->name, - type, &tv->perf_public_ctx, STATS_TYPE_AVERAGE, NULL); @@ -993,17 +981,14 @@ uint16_t SCPerfTVRegisterAvgCounter(char *cname, struct ThreadVars_ *tv, * \param cname Name of the counter, to be registered * \param tv Pointer to the ThreadVars instance for which the counter would * be registered - * \param type Datatype of this counter variable * * \retval the counter id for the newly registered counter, or the already * present counter */ -uint16_t SCPerfTVRegisterMaxCounter(char *cname, struct ThreadVars_ *tv, - int type) +uint16_t StatsRegisterMaxCounter(char *cname, struct ThreadVars_ *tv) { - uint16_t id = SCPerfRegisterQualifiedCounter(cname, + uint16_t id = StatsRegisterQualifiedCounter(cname, (tv->thread_group_name != NULL) ? tv->thread_group_name : tv->name, - type, &tv->perf_public_ctx, STATS_TYPE_MAXIMUM, NULL); @@ -1019,7 +1004,7 @@ uint16_t SCPerfTVRegisterMaxCounter(char *cname, struct ThreadVars_ *tv, * \retval id Counter id for the newly registered counter, or the already * present counter */ -uint16_t SCPerfTVRegisterGlobalCounter(char *cname, uint64_t (*Func)(void)) +uint16_t StatsRegisterGlobalCounter(char *cname, uint64_t (*Func)(void)) { #ifdef UNITTESTS if (sc_perf_op_ctx == NULL) @@ -1027,8 +1012,7 @@ uint16_t SCPerfTVRegisterGlobalCounter(char *cname, uint64_t (*Func)(void)) #else BUG_ON(sc_perf_op_ctx == NULL); #endif - uint16_t id = SCPerfRegisterQualifiedCounter(cname, NULL, - SC_PERF_TYPE_UINT64, + uint16_t id = StatsRegisterQualifiedCounter(cname, NULL, &(sc_perf_op_ctx->global_counter_ctx), STATS_TYPE_FUNC, Func); @@ -1048,11 +1032,11 @@ uint16_t SCPerfTVRegisterGlobalCounter(char *cname, uint64_t (*Func)(void)) * \retval id Counter id for the newly registered counter, or the already * present counter */ -static uint16_t SCPerfRegisterCounter(char *cname, char *tm_name, int type, +static uint16_t SCPerfRegisterCounter(char *cname, char *tm_name, SCPerfPublicContext *pctx) { - uint16_t id = SCPerfRegisterQualifiedCounter(cname, tm_name, type, pctx, - STATS_TYPE_NORMAL, NULL); + uint16_t id = StatsRegisterQualifiedCounter(cname, tm_name, pctx, + STATS_TYPE_NORMAL, NULL); return id; } @@ -1358,22 +1342,13 @@ void SCPerfReleasePCA(SCPerfPrivateContext *pca) /*----------------------------------Unit_Tests--------------------------------*/ #ifdef UNITTESTS -static int SCPerfTestCounterReg01() -{ - SCPerfPublicContext pctx; - - memset(&pctx, 0, sizeof(SCPerfPublicContext)); - - return SCPerfRegisterCounter("t1", "c1", 5, &pctx); -} - static int SCPerfTestCounterReg02() { SCPerfPublicContext pctx; memset(&pctx, 0, sizeof(SCPerfPublicContext)); - return SCPerfRegisterCounter(NULL, NULL, SC_PERF_TYPE_UINT64, &pctx); + return SCPerfRegisterCounter(NULL, NULL, &pctx); } static int SCPerfTestCounterReg03() @@ -1383,7 +1358,7 @@ static int SCPerfTestCounterReg03() memset(&pctx, 0, sizeof(SCPerfPublicContext)); - result = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, &pctx); + result = SCPerfRegisterCounter("t1", "c1", &pctx); SCPerfReleasePerfCounterS(pctx.head); @@ -1397,11 +1372,11 @@ static int SCPerfTestCounterReg04() memset(&pctx, 0, sizeof(SCPerfPublicContext)); - SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, &pctx); - SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64, &pctx); - SCPerfRegisterCounter("t3", "c3", SC_PERF_TYPE_UINT64, &pctx); + SCPerfRegisterCounter("t1", "c1", &pctx); + SCPerfRegisterCounter("t2", "c2", &pctx); + SCPerfRegisterCounter("t3", "c3", &pctx); - result = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, &pctx); + result = SCPerfRegisterCounter("t1", "c1", &pctx); SCPerfReleasePerfCounterS(pctx.head); @@ -1415,8 +1390,7 @@ static int SCPerfTestGetCntArray05() memset(&tv, 0, sizeof(ThreadVars)); - id = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); + id = SCPerfRegisterCounter("t1", "c1", &tv.perf_public_ctx); if (id != 1) { printf("id %d: ", id); return 0; @@ -1434,8 +1408,7 @@ static int SCPerfTestGetCntArray06() memset(&tv, 0, sizeof(ThreadVars)); - id = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); + id = SCPerfRegisterCounter("t1", "c1", &tv.perf_public_ctx); if (id != 1) return 0; @@ -1459,10 +1432,8 @@ static int SCPerfTestCntArraySize07() //pca = (SCPerfPrivateContext *)&tv.perf_private_ctx; - SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); - SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); + SCPerfRegisterCounter("t1", "c1", &tv.perf_public_ctx); + SCPerfRegisterCounter("t2", "c2", &tv.perf_public_ctx); SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx); pca = &tv.perf_private_ctx; @@ -1487,8 +1458,7 @@ static int SCPerfTestUpdateCounter08() memset(&tv, 0, sizeof(ThreadVars)); - id = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); + id = SCPerfRegisterCounter("t1", "c1", &tv.perf_public_ctx); SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx); pca = &tv.perf_private_ctx; @@ -1513,16 +1483,11 @@ static int SCPerfTestUpdateCounter09() memset(&tv, 0, sizeof(ThreadVars)); - id1 = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); - SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); - SCPerfRegisterCounter("t3", "c3", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); - SCPerfRegisterCounter("t4", "c4", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); - id2 = SCPerfRegisterCounter("t5", "c5", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); + id1 = SCPerfRegisterCounter("t1", "c1", &tv.perf_public_ctx); + SCPerfRegisterCounter("t2", "c2", &tv.perf_public_ctx); + SCPerfRegisterCounter("t3", "c3", &tv.perf_public_ctx); + SCPerfRegisterCounter("t4", "c4", &tv.perf_public_ctx); + id2 = SCPerfRegisterCounter("t5", "c5", &tv.perf_public_ctx); SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx); pca = &tv.perf_private_ctx; @@ -1548,12 +1513,9 @@ static int SCPerfTestUpdateGlobalCounter10() memset(&tv, 0, sizeof(ThreadVars)); - id1 = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); - id2 = SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); - id3 = SCPerfRegisterCounter("t3", "c3", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); + id1 = SCPerfRegisterCounter("t1", "c1", &tv.perf_public_ctx); + id2 = SCPerfRegisterCounter("t2", "c2", &tv.perf_public_ctx); + id3 = SCPerfRegisterCounter("t3", "c3", &tv.perf_public_ctx); SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx); pca = &tv.perf_private_ctx; @@ -1585,14 +1547,10 @@ static int SCPerfTestCounterValues11() memset(&tv, 0, sizeof(ThreadVars)); - id1 = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); - id2 = SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); - id3 = SCPerfRegisterCounter("t3", "c3", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); - id4 = SCPerfRegisterCounter("t4", "c4", SC_PERF_TYPE_UINT64, - &tv.perf_public_ctx); + id1 = SCPerfRegisterCounter("t1", "c1", &tv.perf_public_ctx); + id2 = SCPerfRegisterCounter("t2", "c2", &tv.perf_public_ctx); + id3 = SCPerfRegisterCounter("t3", "c3", &tv.perf_public_ctx); + id4 = SCPerfRegisterCounter("t4", "c4", &tv.perf_public_ctx); SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx); pca = &tv.perf_private_ctx; @@ -1623,7 +1581,6 @@ static int SCPerfTestCounterValues11() void SCPerfRegisterTests() { #ifdef UNITTESTS - UtRegisterTest("SCPerfTestCounterReg01", SCPerfTestCounterReg01, 0); UtRegisterTest("SCPerfTestCounterReg02", SCPerfTestCounterReg02, 0); UtRegisterTest("SCPerfTestCounterReg03", SCPerfTestCounterReg03, 1); UtRegisterTest("SCPerfTestCounterReg04", SCPerfTestCounterReg04, 1); diff --git a/src/counters.h b/src/counters.h index 8d9113f684..82378c02fe 100644 --- a/src/counters.h +++ b/src/counters.h @@ -28,14 +28,6 @@ /* forward declaration of the ThreadVars structure */ struct ThreadVars_; -/** - * \brief Data type for different kind of Perf counters that can be registered - */ -enum { - SC_PERF_TYPE_UINT64, - SC_PERF_TYPE_MAX, -}; - /** * \brief Container to hold the counter variable */ @@ -117,10 +109,10 @@ void SCPerfSpawnThreads(void); void SCPerfRegisterTests(void); /* counter registration functions */ -uint16_t SCPerfTVRegisterCounter(char *, struct ThreadVars_ *, int); -uint16_t SCPerfTVRegisterAvgCounter(char *, struct ThreadVars_ *, int); -uint16_t SCPerfTVRegisterMaxCounter(char *, struct ThreadVars_ *, int); -uint16_t SCPerfTVRegisterGlobalCounter(char *cname, uint64_t (*Func)(void)); +uint16_t StatsRegisterCounter(char *, struct ThreadVars_ *); +uint16_t StatsRegisterAvgCounter(char *, struct ThreadVars_ *); +uint16_t StatsRegisterMaxCounter(char *, struct ThreadVars_ *); +uint16_t StatsRegisterGlobalCounter(char *cname, uint64_t (*Func)(void)); /* utility functions */ int SCPerfUpdateCounterArray(SCPerfPrivateContext *, SCPerfPublicContext *); diff --git a/src/decode.c b/src/decode.c index 4e2613e79f..b096bf5753 100644 --- a/src/decode.c +++ b/src/decode.c @@ -370,78 +370,46 @@ void PacketDefragPktSetupParent(Packet *parent) void DecodeRegisterPerfCounters(DecodeThreadVars *dtv, ThreadVars *tv) { /* register counters */ - dtv->counter_pkts = SCPerfTVRegisterCounter("decoder.pkts", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_bytes = SCPerfTVRegisterCounter("decoder.bytes", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_invalid = SCPerfTVRegisterCounter("decoder.invalid", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_ipv4 = SCPerfTVRegisterCounter("decoder.ipv4", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_ipv6 = SCPerfTVRegisterCounter("decoder.ipv6", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_eth = SCPerfTVRegisterCounter("decoder.ethernet", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_raw = SCPerfTVRegisterCounter("decoder.raw", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_null = SCPerfTVRegisterCounter("decoder.null", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_sll = SCPerfTVRegisterCounter("decoder.sll", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_tcp = SCPerfTVRegisterCounter("decoder.tcp", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_udp = SCPerfTVRegisterCounter("decoder.udp", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_sctp = SCPerfTVRegisterCounter("decoder.sctp", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_icmpv4 = SCPerfTVRegisterCounter("decoder.icmpv4", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_icmpv6 = SCPerfTVRegisterCounter("decoder.icmpv6", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_ppp = SCPerfTVRegisterCounter("decoder.ppp", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_pppoe = SCPerfTVRegisterCounter("decoder.pppoe", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_gre = SCPerfTVRegisterCounter("decoder.gre", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_vlan = SCPerfTVRegisterCounter("decoder.vlan", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_vlan_qinq = SCPerfTVRegisterCounter("decoder.vlan_qinq", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_teredo = SCPerfTVRegisterCounter("decoder.teredo", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_ipv4inipv6 = SCPerfTVRegisterCounter("decoder.ipv4_in_ipv6", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_ipv6inipv6 = SCPerfTVRegisterCounter("decoder.ipv6_in_ipv6", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_mpls = SCPerfTVRegisterCounter("decoder.mpls", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_avg_pkt_size = SCPerfTVRegisterAvgCounter("decoder.avg_pkt_size", tv, - SC_PERF_TYPE_UINT64); - dtv->counter_max_pkt_size = SCPerfTVRegisterMaxCounter("decoder.max_pkt_size", tv, - SC_PERF_TYPE_UINT64); + 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_raw = StatsRegisterCounter("decoder.raw", tv); + dtv->counter_null = StatsRegisterCounter("decoder.null", tv); + dtv->counter_sll = StatsRegisterCounter("decoder.sll", tv); + dtv->counter_tcp = StatsRegisterCounter("decoder.tcp", tv); + dtv->counter_udp = StatsRegisterCounter("decoder.udp", tv); + dtv->counter_sctp = StatsRegisterCounter("decoder.sctp", 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_gre = StatsRegisterCounter("decoder.gre", tv); + dtv->counter_vlan = StatsRegisterCounter("decoder.vlan", tv); + dtv->counter_vlan_qinq = StatsRegisterCounter("decoder.vlan_qinq", tv); + dtv->counter_teredo = StatsRegisterCounter("decoder.teredo", 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_defrag_ipv4_fragments = - SCPerfTVRegisterCounter("defrag.ipv4.fragments", tv, - SC_PERF_TYPE_UINT64); + StatsRegisterCounter("defrag.ipv4.fragments", tv); dtv->counter_defrag_ipv4_reassembled = - SCPerfTVRegisterCounter("defrag.ipv4.reassembled", tv, - SC_PERF_TYPE_UINT64); + StatsRegisterCounter("defrag.ipv4.reassembled", tv); dtv->counter_defrag_ipv4_timeouts = - SCPerfTVRegisterCounter("defrag.ipv4.timeouts", tv, - SC_PERF_TYPE_UINT64); + StatsRegisterCounter("defrag.ipv4.timeouts", tv); dtv->counter_defrag_ipv6_fragments = - SCPerfTVRegisterCounter("defrag.ipv6.fragments", tv, - SC_PERF_TYPE_UINT64); + StatsRegisterCounter("defrag.ipv6.fragments", tv); dtv->counter_defrag_ipv6_reassembled = - SCPerfTVRegisterCounter("defrag.ipv6.reassembled", tv, - SC_PERF_TYPE_UINT64); + StatsRegisterCounter("defrag.ipv6.reassembled", tv); dtv->counter_defrag_ipv6_timeouts = - SCPerfTVRegisterCounter("defrag.ipv6.timeouts", tv, - SC_PERF_TYPE_UINT64); + StatsRegisterCounter("defrag.ipv6.timeouts", tv); dtv->counter_defrag_max_hit = - SCPerfTVRegisterCounter("defrag.max_frag_hits", tv, - SC_PERF_TYPE_UINT64); + StatsRegisterCounter("defrag.max_frag_hits", tv); return; } diff --git a/src/detect-engine.c b/src/detect-engine.c index 355cdef9d1..6c27b76da0 100644 --- a/src/detect-engine.c +++ b/src/detect-engine.c @@ -1347,17 +1347,12 @@ TmEcode DetectEngineThreadCtxInit(ThreadVars *tv, void *initdata, void **data) { /* first register the counter. In delayed detect mode we exit right after if the * rules haven't been loaded yet. */ - uint16_t counter_alerts = SCPerfTVRegisterCounter("detect.alert", tv, - SC_PERF_TYPE_UINT64); + uint16_t counter_alerts = StatsRegisterCounter("detect.alert", tv); #ifdef PROFILING - uint16_t counter_mpm_list = SCPerfTVRegisterAvgCounter("detect.mpm_list", tv, - SC_PERF_TYPE_UINT64); - uint16_t counter_nonmpm_list = SCPerfTVRegisterAvgCounter("detect.nonmpm_list", tv, - SC_PERF_TYPE_UINT64); - uint16_t counter_fnonmpm_list = SCPerfTVRegisterAvgCounter("detect.fnonmpm_list", tv, - SC_PERF_TYPE_UINT64); - uint16_t counter_match_list = SCPerfTVRegisterAvgCounter("detect.match_list", tv, - SC_PERF_TYPE_UINT64); + uint16_t counter_mpm_list = StatsRegisterAvgCounter("detect.mpm_list", tv); + uint16_t counter_nonmpm_list = StatsRegisterAvgCounter("detect.nonmpm_list", tv); + uint16_t counter_fnonmpm_list = StatsRegisterAvgCounter("detect.fnonmpm_list", tv); + uint16_t counter_match_list = StatsRegisterAvgCounter("detect.match_list", tv); #endif DetectEngineThreadCtx *det_ctx = SCMalloc(sizeof(DetectEngineThreadCtx)); if (unlikely(det_ctx == NULL)) @@ -1431,17 +1426,12 @@ static DetectEngineThreadCtx *DetectEngineThreadCtxInitForReload( } /** alert counter setup */ - det_ctx->counter_alerts = SCPerfTVRegisterCounter("detect.alert", tv, - SC_PERF_TYPE_UINT64); + det_ctx->counter_alerts = StatsRegisterCounter("detect.alert", tv); #ifdef PROFILING - uint16_t counter_mpm_list = SCPerfTVRegisterAvgCounter("detect.mpm_list", tv, - SC_PERF_TYPE_UINT64); - uint16_t counter_nonmpm_list = SCPerfTVRegisterAvgCounter("detect.nonmpm_list", tv, - SC_PERF_TYPE_UINT64); - uint16_t counter_fnonmpm_list = SCPerfTVRegisterAvgCounter("detect.fnonmpm_list", tv, - SC_PERF_TYPE_UINT64); - uint16_t counter_match_list = SCPerfTVRegisterAvgCounter("detect.match_list", tv, - SC_PERF_TYPE_UINT64); + uint16_t counter_mpm_list = StatsRegisterAvgCounter("detect.mpm_list", tv); + uint16_t counter_nonmpm_list = StatsRegisterAvgCounter("detect.nonmpm_list", tv); + uint16_t counter_fnonmpm_list = StatsRegisterAvgCounter("detect.fnonmpm_list", tv); + uint16_t counter_match_list = StatsRegisterAvgCounter("detect.match_list", tv); det_ctx->counter_mpm_list = counter_mpm_list; det_ctx->counter_nonmpm_list = counter_nonmpm_list; det_ctx->counter_fnonmpm_list = counter_fnonmpm_list; diff --git a/src/flow-manager.c b/src/flow-manager.c index 71bdef6572..1b5b24c496 100644 --- a/src/flow-manager.c +++ b/src/flow-manager.c @@ -524,22 +524,14 @@ static TmEcode FlowManagerThreadInit(ThreadVars *t, void *initdata, void **data) /* pass thread data back to caller */ *data = ftd; - ftd->flow_mgr_cnt_clo = SCPerfTVRegisterCounter("flow_mgr.closed_pruned", t, - SC_PERF_TYPE_UINT64); - ftd->flow_mgr_cnt_new = SCPerfTVRegisterCounter("flow_mgr.new_pruned", t, - SC_PERF_TYPE_UINT64); - ftd->flow_mgr_cnt_est = SCPerfTVRegisterCounter("flow_mgr.est_pruned", t, - SC_PERF_TYPE_UINT64); - ftd->flow_mgr_memuse = SCPerfTVRegisterCounter("flow.memuse", t, - SC_PERF_TYPE_UINT64); - ftd->flow_mgr_spare = SCPerfTVRegisterCounter("flow.spare", t, - SC_PERF_TYPE_UINT64); - ftd->flow_emerg_mode_enter = SCPerfTVRegisterCounter("flow.emerg_mode_entered", t, - SC_PERF_TYPE_UINT64); - ftd->flow_emerg_mode_over = SCPerfTVRegisterCounter("flow.emerg_mode_over", t, - SC_PERF_TYPE_UINT64); - ftd->flow_tcp_reuse = SCPerfTVRegisterCounter("flow.tcp_reuse", t, - SC_PERF_TYPE_UINT64); + ftd->flow_mgr_cnt_clo = StatsRegisterCounter("flow_mgr.closed_pruned", t); + ftd->flow_mgr_cnt_new = StatsRegisterCounter("flow_mgr.new_pruned", t); + ftd->flow_mgr_cnt_est = StatsRegisterCounter("flow_mgr.est_pruned", t); + ftd->flow_mgr_memuse = StatsRegisterCounter("flow.memuse", t); + ftd->flow_mgr_spare = StatsRegisterCounter("flow.spare", t); + ftd->flow_emerg_mode_enter = StatsRegisterCounter("flow.emerg_mode_entered", t); + ftd->flow_emerg_mode_over = StatsRegisterCounter("flow.emerg_mode_over", t); + ftd->flow_tcp_reuse = StatsRegisterCounter("flow.tcp_reuse", t); PacketPoolInit(); return TM_ECODE_OK; @@ -575,12 +567,9 @@ static TmEcode FlowManager(ThreadVars *th_v, void *thread_data) int flow_update_delay_nsec = FLOW_NORMAL_MODE_UPDATE_DELAY_NSEC; /* VJ leaving disabled for now, as hosts are only used by tags and the numbers * are really low. Might confuse ppl - uint16_t flow_mgr_host_prune = SCPerfTVRegisterCounter("hosts.pruned", th_v, - SC_PERF_TYPE_UINT64); - uint16_t flow_mgr_host_active = SCPerfTVRegisterCounter("hosts.active", th_v, - SC_PERF_TYPE_UINT64); - uint16_t flow_mgr_host_spare = SCPerfTVRegisterCounter("hosts.spare", th_v, - SC_PERF_TYPE_UINT64); + uint16_t flow_mgr_host_prune = StatsRegisterCounter("hosts.pruned", th_v); + uint16_t flow_mgr_host_active = StatsRegisterCounter("hosts.active", th_v); + uint16_t flow_mgr_host_spare = StatsRegisterCounter("hosts.spare", th_v); */ memset(&ts, 0, sizeof(ts)); diff --git a/src/source-af-packet.c b/src/source-af-packet.c index 3b50ba8f31..5fdaa80317 100644 --- a/src/source-af-packet.c +++ b/src/source-af-packet.c @@ -1714,10 +1714,10 @@ TmEcode ReceiveAFPThreadInit(ThreadVars *tv, void *initdata, void **data) } #ifdef PACKET_STATISTICS - ptv->capture_kernel_packets = SCPerfTVRegisterCounter("capture.kernel_packets", - ptv->tv, SC_PERF_TYPE_UINT64); - ptv->capture_kernel_drops = SCPerfTVRegisterCounter("capture.kernel_drops", - ptv->tv, SC_PERF_TYPE_UINT64); + ptv->capture_kernel_packets = StatsRegisterCounter("capture.kernel_packets", + ptv->tv); + ptv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", + ptv->tv); #endif char *active_runmode = RunmodeGetActive(); diff --git a/src/source-erf-dag.c b/src/source-erf-dag.c index 55b273e0aa..0854a87c57 100644 --- a/src/source-erf-dag.c +++ b/src/source-erf-dag.c @@ -304,10 +304,8 @@ ReceiveErfDagThreadInit(ThreadVars *tv, void *initdata, void **data) SCReturnInt(TM_ECODE_FAILED); } - ewtn->packets = SCPerfTVRegisterCounter("capture.dag_packets", - tv, SC_PERF_TYPE_UINT64); - ewtn->drops = SCPerfTVRegisterCounter("capture.dag_drops", - tv, SC_PERF_TYPE_UINT64); + ewtn->packets = StatsRegisterCounter("capture.dag_packets", tv); + ewtn->drops = StatsRegisterCounter("capture.dag_drops", tv); ewtn->tv = tv; *data = (void *)ewtn; diff --git a/src/source-mpipe.c b/src/source-mpipe.c index 665282605e..bb3655afdb 100644 --- a/src/source-mpipe.c +++ b/src/source-mpipe.c @@ -436,28 +436,16 @@ TmEcode ReceiveMpipeLoop(ThreadVars *tv, void *data, void *slot) static void MpipeRegisterPerfCounters(MpipeThreadVars *ptv, ThreadVars *tv) { /* register counters */ - ptv->max_mpipe_depth = SCPerfTVRegisterCounter("mpipe.max_mpipe_depth", - tv, - SC_PERF_TYPE_UINT64); - ptv->mpipe_drop = SCPerfTVRegisterCounter("mpipe.drop", - tv, - SC_PERF_TYPE_UINT64); - ptv->counter_no_buffers_0 = SCPerfTVRegisterCounter("mpipe.no_buf0", tv, - SC_PERF_TYPE_UINT64); - ptv->counter_no_buffers_1 = SCPerfTVRegisterCounter("mpipe.no_buf1", tv, - SC_PERF_TYPE_UINT64); - ptv->counter_no_buffers_2 = SCPerfTVRegisterCounter("mpipe.no_buf2", tv, - SC_PERF_TYPE_UINT64); - ptv->counter_no_buffers_3 = SCPerfTVRegisterCounter("mpipe.no_buf3", tv, - SC_PERF_TYPE_UINT64); - ptv->counter_no_buffers_4 = SCPerfTVRegisterCounter("mpipe.no_buf4", tv, - SC_PERF_TYPE_UINT64); - ptv->counter_no_buffers_5 = SCPerfTVRegisterCounter("mpipe.no_buf5", tv, - SC_PERF_TYPE_UINT64); - ptv->counter_no_buffers_6 = SCPerfTVRegisterCounter("mpipe.no_buf6", tv, - SC_PERF_TYPE_UINT64); - ptv->counter_no_buffers_7 = SCPerfTVRegisterCounter("mpipe.no_buf7", tv, - SC_PERF_TYPE_UINT64); + ptv->max_mpipe_depth = StatsRegisterCounter("mpipe.max_mpipe_depth", tv); + ptv->mpipe_drop = StatsRegisterCounter("mpipe.drop", tv); + ptv->counter_no_buffers_0 = StatsRegisterCounter("mpipe.no_buf0", tv); + ptv->counter_no_buffers_1 = StatsRegisterCounter("mpipe.no_buf1", tv); + ptv->counter_no_buffers_2 = StatsRegisterCounter("mpipe.no_buf2", tv); + ptv->counter_no_buffers_3 = StatsRegisterCounter("mpipe.no_buf3", tv); + ptv->counter_no_buffers_4 = StatsRegisterCounter("mpipe.no_buf4", tv); + ptv->counter_no_buffers_5 = StatsRegisterCounter("mpipe.no_buf5", tv); + ptv->counter_no_buffers_6 = StatsRegisterCounter("mpipe.no_buf6", tv); + ptv->counter_no_buffers_7 = StatsRegisterCounter("mpipe.no_buf7", tv); } static const gxio_mpipe_buffer_size_enum_t gxio_buffer_sizes[] = { diff --git a/src/source-netmap.c b/src/source-netmap.c index adf330fc67..0b70c6a6c6 100644 --- a/src/source-netmap.c +++ b/src/source-netmap.c @@ -554,10 +554,10 @@ static TmEcode ReceiveNetmapThreadInit(ThreadVars *tv, void *initdata, void **da } /* basic counters */ - ntv->capture_kernel_packets = SCPerfTVRegisterCounter("capture.kernel_packets", - ntv->tv, SC_PERF_TYPE_UINT64); - ntv->capture_kernel_drops = SCPerfTVRegisterCounter("capture.kernel_drops", - ntv->tv, SC_PERF_TYPE_UINT64); + ntv->capture_kernel_packets = StatsRegisterCounter("capture.kernel_packets", + ntv->tv); + ntv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", + ntv->tv); char const *active_runmode = RunmodeGetActive(); if (active_runmode && !strcmp("workers", active_runmode)) { diff --git a/src/source-nflog.c b/src/source-nflog.c index 98406ed504..cb462af57e 100644 --- a/src/source-nflog.c +++ b/src/source-nflog.c @@ -307,12 +307,10 @@ TmEcode ReceiveNFLOGThreadInit(ThreadVars *tv, void *initdata, void **data) } #ifdef PACKET_STATISTICS - ntv->capture_kernel_packets = SCPerfTVRegisterCounter("capture.kernel_packets", - ntv->tv, - SC_PERF_TYPE_UINT64); - ntv->capture_kernel_drops = SCPerfTVRegisterCounter("capture.kernel_drops", - ntv->tv, - SC_PERF_TYPE_UINT64); + ntv->capture_kernel_packets = StatsRegisterCounter("capture.kernel_packets", + ntv->tv); + ntv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", + ntv->tv); #endif char *active_runmode = RunmodeGetActive(); diff --git a/src/source-pcap.c b/src/source-pcap.c index 57237fed14..a092a7599e 100644 --- a/src/source-pcap.c +++ b/src/source-pcap.c @@ -521,12 +521,12 @@ TmEcode ReceivePcapThreadInit(ThreadVars *tv, void *initdata, void **data) pcapconfig->DerefFunc(pcapconfig); - ptv->capture_kernel_packets = SCPerfTVRegisterCounter("capture.kernel_packets", - ptv->tv, SC_PERF_TYPE_UINT64); - ptv->capture_kernel_drops = SCPerfTVRegisterCounter("capture.kernel_drops", - ptv->tv, SC_PERF_TYPE_UINT64); - ptv->capture_kernel_ifdrops = SCPerfTVRegisterCounter("capture.kernel_ifdrops", - ptv->tv, SC_PERF_TYPE_UINT64); + 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); *data = (void *)ptv; SCReturnInt(TM_ECODE_OK); @@ -620,12 +620,12 @@ TmEcode ReceivePcapThreadInit(ThreadVars *tv, void *initdata, void **data) ptv->datalink = pcap_datalink(ptv->pcap_handle); - ptv->capture_kernel_packets = SCPerfTVRegisterCounter("capture.kernel_packets", - ptv->tv, SC_PERF_TYPE_UINT64); - ptv->capture_kernel_drops = SCPerfTVRegisterCounter("capture.kernel_drops", - ptv->tv, SC_PERF_TYPE_UINT64); - ptv->capture_kernel_ifdrops = SCPerfTVRegisterCounter("capture.kernel_ifdrops", - ptv->tv, SC_PERF_TYPE_UINT64); + 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); *data = (void *)ptv; diff --git a/src/source-pfring.c b/src/source-pfring.c index a7f1342a5c..a9fff4cbe2 100644 --- a/src/source-pfring.c +++ b/src/source-pfring.c @@ -497,10 +497,10 @@ TmEcode ReceivePfringThreadInit(ThreadVars *tv, void *initdata, void **data) } } - ptv->capture_kernel_packets = SCPerfTVRegisterCounter("capture.kernel_packets", - ptv->tv, SC_PERF_TYPE_UINT64); - ptv->capture_kernel_drops = SCPerfTVRegisterCounter("capture.kernel_drops", - ptv->tv, SC_PERF_TYPE_UINT64); + ptv->capture_kernel_packets = StatsRegisterCounter("capture.kernel_packets", + ptv->tv); + ptv->capture_kernel_drops = StatsRegisterCounter("capture.kernel_drops", + ptv->tv); /* A bit strange to have this here but we only have vlan information * during reading so we need to know if we want to keep vlan during diff --git a/src/stream-tcp-reassemble.c b/src/stream-tcp-reassemble.c index 7331db1bd3..839a9ccd55 100644 --- a/src/stream-tcp-reassemble.c +++ b/src/stream-tcp-reassemble.c @@ -514,7 +514,7 @@ int StreamTcpReassembleInit(char quiet) SCMutexInit(&segment_pool_cnt_mutex, NULL); #endif - SCPerfTVRegisterGlobalCounter("tcp.reassembly_memuse", + StatsRegisterGlobalCounter("tcp.reassembly_memuse", StreamTcpReassembleMemuseGlobalCounter); return 0; } diff --git a/src/stream-tcp.c b/src/stream-tcp.c index 2136a8f5d5..00e1e423a5 100644 --- a/src/stream-tcp.c +++ b/src/stream-tcp.c @@ -5073,43 +5073,28 @@ TmEcode StreamTcpThreadInit(ThreadVars *tv, void *initdata, void **data) *data = (void *)stt; - stt->counter_tcp_sessions = SCPerfTVRegisterCounter("tcp.sessions", tv, - SC_PERF_TYPE_UINT64); - stt->counter_tcp_ssn_memcap = SCPerfTVRegisterCounter("tcp.ssn_memcap_drop", tv, - SC_PERF_TYPE_UINT64); - stt->counter_tcp_pseudo = SCPerfTVRegisterCounter("tcp.pseudo", tv, - SC_PERF_TYPE_UINT64); - stt->counter_tcp_pseudo_failed = SCPerfTVRegisterCounter("tcp.pseudo_failed", tv, - SC_PERF_TYPE_UINT64); - stt->counter_tcp_invalid_checksum = SCPerfTVRegisterCounter("tcp.invalid_checksum", tv, - SC_PERF_TYPE_UINT64); - stt->counter_tcp_no_flow = SCPerfTVRegisterCounter("tcp.no_flow", tv, - SC_PERF_TYPE_UINT64); - stt->counter_tcp_memuse = SCPerfTVRegisterCounter("tcp.memuse", tv, - SC_PERF_TYPE_UINT64); - stt->counter_tcp_syn = SCPerfTVRegisterCounter("tcp.syn", tv, - SC_PERF_TYPE_UINT64); - stt->counter_tcp_synack = SCPerfTVRegisterCounter("tcp.synack", tv, - SC_PERF_TYPE_UINT64); - stt->counter_tcp_rst = SCPerfTVRegisterCounter("tcp.rst", tv, - SC_PERF_TYPE_UINT64); + stt->counter_tcp_sessions = StatsRegisterCounter("tcp.sessions", tv); + stt->counter_tcp_ssn_memcap = StatsRegisterCounter("tcp.ssn_memcap_drop", tv); + stt->counter_tcp_pseudo = StatsRegisterCounter("tcp.pseudo", tv); + stt->counter_tcp_pseudo_failed = StatsRegisterCounter("tcp.pseudo_failed", tv); + stt->counter_tcp_invalid_checksum = StatsRegisterCounter("tcp.invalid_checksum", tv); + stt->counter_tcp_no_flow = StatsRegisterCounter("tcp.no_flow", tv); + stt->counter_tcp_memuse = StatsRegisterCounter("tcp.memuse", tv); + stt->counter_tcp_syn = StatsRegisterCounter("tcp.syn", tv); + stt->counter_tcp_synack = StatsRegisterCounter("tcp.synack", tv); + stt->counter_tcp_rst = StatsRegisterCounter("tcp.rst", tv); /* init reassembly ctx */ stt->ra_ctx = StreamTcpReassembleInitThreadCtx(tv); if (stt->ra_ctx == NULL) SCReturnInt(TM_ECODE_FAILED); - stt->ra_ctx->counter_tcp_segment_memcap = SCPerfTVRegisterCounter("tcp.segment_memcap_drop", tv, - SC_PERF_TYPE_UINT64); - stt->ra_ctx->counter_tcp_stream_depth = SCPerfTVRegisterCounter("tcp.stream_depth_reached", tv, - SC_PERF_TYPE_UINT64); - stt->ra_ctx->counter_tcp_reass_gap = SCPerfTVRegisterCounter("tcp.reassembly_gap", tv, - SC_PERF_TYPE_UINT64); + stt->ra_ctx->counter_tcp_segment_memcap = StatsRegisterCounter("tcp.segment_memcap_drop", 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); /** \fixme Find a better place in 2.1 as it is linked with app layer */ - stt->ra_ctx->counter_htp_memuse = SCPerfTVRegisterCounter("http.memuse", tv, - SC_PERF_TYPE_UINT64); - stt->ra_ctx->counter_htp_memcap = SCPerfTVRegisterCounter("http.memcap", tv, - SC_PERF_TYPE_UINT64); + stt->ra_ctx->counter_htp_memuse = StatsRegisterCounter("http.memuse", tv); + stt->ra_ctx->counter_htp_memcap = StatsRegisterCounter("http.memcap", tv); SCLogDebug("StreamTcp thread specific ctx online at %p, reassembly ctx %p", stt, stt->ra_ctx);