aiden
/
suricata
mirror of https://github.com/OISF/suricata
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

counters: remove unused description

Browse Source
pull/1508/head
Victor Julien 11 years ago
parent 711cd7b59b
commit b293a4b7d0
14 changed files with 135 additions and 207 deletions
Show Stats Download Patch File Download Diff File

6
src/app-layer.c
Unescape Escape View File

@ -604,11 +604,11 @@ 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, "NULL");
SC_PERF_TYPE_UINT64);
app_tctx->counter_dns_memcap_state = SCPerfTVRegisterCounter("dns.memcap_state", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
app_tctx->counter_dns_memcap_global = SCPerfTVRegisterCounter("dns.memcap_global", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
}
goto done;

82
src/counters.c
Unescape Escape View File

@ -497,9 +497,6 @@ static void SCPerfReleaseCounter(SCPerfCounter *pc)
if (pc->tm_name != NULL)
SCFree(pc->tm_name);
if (pc->desc != NULL)
SCFree(pc->desc);
SCFree(pc);
}
@ -512,7 +509,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 desc Description of this counter
* \param pctx SCPerfPublicContext for this tm-tv instance
* \param type_q Qualifier describing the type of counter to be registered
*
@ -521,8 +517,8 @@ static void SCPerfReleaseCounter(SCPerfCounter *pc)
* \retval 0 on failure
*/
static uint16_t SCPerfRegisterQualifiedCounter(char *cname, char *tm_name,
int type, char *desc,
SCPerfPublicContext *pctx, int type_q)
int type, SCPerfPublicContext *pctx,
int type_q)
{
SCPerfCounter **head = &pctx->head;
SCPerfCounter *temp = NULL;
@ -575,11 +571,6 @@ static uint16_t SCPerfRegisterQualifiedCounter(char *cname, char *tm_name,
* PerfContext. Please note that the id start from 1, and not 0 */
pc->id = ++(pctx->curr_id);
if (desc != NULL && (pc->desc = SCStrdup(desc)) == NULL) {
SCLogError(SC_ERR_MEM_ALLOC, "Error allocating memory");
exit(EXIT_FAILURE);
}
pc->type = type_q;
/* we now add the counter to the list */
@ -887,17 +878,15 @@ void SCPerfSpawnThreads(void)
* \param tv Pointer to the ThreadVars instance for which the counter would
* be registered
* \param type Datatype of this counter variable
* \param desc Description of this counter
*
* \retval id Counter id for the newly registered counter, or the already
* present counter
*/
uint16_t SCPerfTVRegisterCounter(char *cname, struct ThreadVars_ *tv, int type,
char *desc)
uint16_t SCPerfTVRegisterCounter(char *cname, struct ThreadVars_ *tv, int type)
{
uint16_t id = SCPerfRegisterQualifiedCounter(cname,
(tv->thread_group_name != NULL) ? tv->thread_group_name : tv->name,
type, desc,
type,
&tv->perf_public_ctx,
SC_PERF_TYPE_Q_NORMAL);
@ -912,17 +901,16 @@ uint16_t SCPerfTVRegisterCounter(char *cname, struct ThreadVars_ *tv, int type,
* \param tv Pointer to the ThreadVars instance for which the counter would
* be registered
* \param type Datatype of this counter variable
* \param desc Description of this counter
*
* \retval id Counter id for the newly registered counter, or the already
* present counter
*/
uint16_t SCPerfTVRegisterAvgCounter(char *cname, struct ThreadVars_ *tv,
int type, char *desc)
int type)
{
uint16_t id = SCPerfRegisterQualifiedCounter(cname,
(tv->thread_group_name != NULL) ? tv->thread_group_name : tv->name,
type, desc,
type,
&tv->perf_public_ctx,
SC_PERF_TYPE_Q_AVERAGE);
@ -937,17 +925,16 @@ uint16_t SCPerfTVRegisterAvgCounter(char *cname, struct ThreadVars_ *tv,
* \param tv Pointer to the ThreadVars instance for which the counter would
* be registered
* \param type Datatype of this counter variable
* \param desc Description of this counter
*
* \retval the counter id for the newly registered counter, or the already
* present counter
*/
uint16_t SCPerfTVRegisterMaxCounter(char *cname, struct ThreadVars_ *tv,
int type, char *desc)
int type)
{
uint16_t id = SCPerfRegisterQualifiedCounter(cname,
(tv->thread_group_name != NULL) ? tv->thread_group_name : tv->name,
type, desc,
type,
&tv->perf_public_ctx,
SC_PERF_TYPE_Q_MAXIMUM);
@ -961,17 +948,16 @@ uint16_t SCPerfTVRegisterMaxCounter(char *cname, struct ThreadVars_ *tv,
* \param tm_name Name of the engine module under which the counter has to be
* registered
* \param type Datatype of this counter variable
* \param desc Description of this counter
* \param pctx SCPerfPublicContext corresponding to the tm_name key under which the
* key has to be registered
*
* \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, char *desc,
static uint16_t SCPerfRegisterCounter(char *cname, char *tm_name, int type,
SCPerfPublicContext *pctx)
{
uint16_t id = SCPerfRegisterQualifiedCounter(cname, tm_name, type, desc,
uint16_t id = SCPerfRegisterQualifiedCounter(cname, tm_name, type,
pctx, SC_PERF_TYPE_Q_NORMAL);
return id;
@ -1307,7 +1293,7 @@ static int SCPerfTestCounterReg01()
memset(&pctx, 0, sizeof(SCPerfPublicContext));
return SCPerfRegisterCounter("t1", "c1", 5, NULL, &pctx);
return SCPerfRegisterCounter("t1", "c1", 5, &pctx);
}
static int SCPerfTestCounterReg02()
@ -1316,7 +1302,7 @@ static int SCPerfTestCounterReg02()
memset(&pctx, 0, sizeof(SCPerfPublicContext));
return SCPerfRegisterCounter(NULL, NULL, SC_PERF_TYPE_UINT64, NULL, &pctx);
return SCPerfRegisterCounter(NULL, NULL, SC_PERF_TYPE_UINT64, &pctx);
}
static int SCPerfTestCounterReg03()
@ -1326,7 +1312,7 @@ static int SCPerfTestCounterReg03()
memset(&pctx, 0, sizeof(SCPerfPublicContext));
result = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, NULL, &pctx);
result = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, &pctx);
SCPerfReleasePerfCounterS(pctx.head);
@ -1340,11 +1326,11 @@ static int SCPerfTestCounterReg04()
memset(&pctx, 0, sizeof(SCPerfPublicContext));
SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, NULL, &pctx);
SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64, NULL, &pctx);
SCPerfRegisterCounter("t3", "c3", SC_PERF_TYPE_UINT64, NULL, &pctx);
SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, &pctx);
SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64, &pctx);
SCPerfRegisterCounter("t3", "c3", SC_PERF_TYPE_UINT64, &pctx);
result = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, NULL, &pctx);
result = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, &pctx);
SCPerfReleasePerfCounterS(pctx.head);
@ -1358,7 +1344,7 @@ static int SCPerfTestGetCntArray05()
memset(&tv, 0, sizeof(ThreadVars));
id = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, NULL,
id = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
if (id != 1) {
printf("id %d: ", id);
@ -1377,7 +1363,7 @@ static int SCPerfTestGetCntArray06()
memset(&tv, 0, sizeof(ThreadVars));
id = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, NULL,
id = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
if (id != 1)
return 0;
@ -1402,9 +1388,9 @@ static int SCPerfTestCntArraySize07()
//pca = (SCPerfPrivateContext *)&tv.perf_private_ctx;
SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, NULL,
SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64, NULL,
SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx);
@ -1430,7 +1416,7 @@ static int SCPerfTestUpdateCounter08()
memset(&tv, 0, sizeof(ThreadVars));
id = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, NULL,
id = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx);
@ -1456,15 +1442,15 @@ static int SCPerfTestUpdateCounter09()
memset(&tv, 0, sizeof(ThreadVars));
id1 = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, NULL,
id1 = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64, NULL,
SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
SCPerfRegisterCounter("t3", "c3", SC_PERF_TYPE_UINT64, NULL,
SCPerfRegisterCounter("t3", "c3", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
SCPerfRegisterCounter("t4", "c4", SC_PERF_TYPE_UINT64, NULL,
SCPerfRegisterCounter("t4", "c4", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
id2 = SCPerfRegisterCounter("t5", "c5", SC_PERF_TYPE_UINT64, NULL,
id2 = SCPerfRegisterCounter("t5", "c5", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx);
@ -1491,11 +1477,11 @@ static int SCPerfTestUpdateGlobalCounter10()
memset(&tv, 0, sizeof(ThreadVars));
id1 = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, NULL,
id1 = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
id2 = SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64, NULL,
id2 = SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
id3 = SCPerfRegisterCounter("t3", "c3", SC_PERF_TYPE_UINT64, NULL,
id3 = SCPerfRegisterCounter("t3", "c3", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx);
@ -1528,13 +1514,13 @@ static int SCPerfTestCounterValues11()
memset(&tv, 0, sizeof(ThreadVars));
id1 = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, NULL,
id1 = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
id2 = SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64, NULL,
id2 = SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
id3 = SCPerfRegisterCounter("t3", "c3", SC_PERF_TYPE_UINT64, NULL,
id3 = SCPerfRegisterCounter("t3", "c3", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
id4 = SCPerfRegisterCounter("t4", "c4", SC_PERF_TYPE_UINT64, NULL,
id4 = SCPerfRegisterCounter("t4", "c4", SC_PERF_TYPE_UINT64,
&tv.perf_public_ctx);
SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx);

9
src/counters.h
Unescape Escape View File

@ -59,9 +59,6 @@ typedef struct SCPerfCounter_ {
/* the next perfcounter for this tv's tm instance */
struct SCPerfCounter_ *next;
/* description of this counter */
char *desc;
} SCPerfCounter;
/**
@ -117,9 +114,9 @@ void SCPerfSpawnThreads(void);
void SCPerfRegisterTests(void);
/* counter registration functions */
uint16_t SCPerfTVRegisterCounter(char *, struct ThreadVars_ *, int, char *);
uint16_t SCPerfTVRegisterAvgCounter(char *, struct ThreadVars_ *, int, char *);
uint16_t SCPerfTVRegisterMaxCounter(char *, struct ThreadVars_ *, int, char *);
uint16_t SCPerfTVRegisterCounter(char *, struct ThreadVars_ *, int);
uint16_t SCPerfTVRegisterAvgCounter(char *, struct ThreadVars_ *, int);
uint16_t SCPerfTVRegisterMaxCounter(char *, struct ThreadVars_ *, int);
/* utility functions */
int SCPerfUpdateCounterArray(SCPerfPrivateContext *, SCPerfPublicContext *);

64
src/decode.c
Unescape Escape View File

@ -371,77 +371,77 @@ void DecodeRegisterPerfCounters(DecodeThreadVars *dtv, ThreadVars *tv)
{
/* register counters */
dtv->counter_pkts = SCPerfTVRegisterCounter("decoder.pkts", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_bytes = SCPerfTVRegisterCounter("decoder.bytes", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_invalid = SCPerfTVRegisterCounter("decoder.invalid", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_ipv4 = SCPerfTVRegisterCounter("decoder.ipv4", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_ipv6 = SCPerfTVRegisterCounter("decoder.ipv6", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_eth = SCPerfTVRegisterCounter("decoder.ethernet", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_raw = SCPerfTVRegisterCounter("decoder.raw", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_null = SCPerfTVRegisterCounter("decoder.null", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_sll = SCPerfTVRegisterCounter("decoder.sll", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_tcp = SCPerfTVRegisterCounter("decoder.tcp", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_udp = SCPerfTVRegisterCounter("decoder.udp", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_sctp = SCPerfTVRegisterCounter("decoder.sctp", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_icmpv4 = SCPerfTVRegisterCounter("decoder.icmpv4", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_icmpv6 = SCPerfTVRegisterCounter("decoder.icmpv6", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_ppp = SCPerfTVRegisterCounter("decoder.ppp", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_pppoe = SCPerfTVRegisterCounter("decoder.pppoe", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_gre = SCPerfTVRegisterCounter("decoder.gre", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_vlan = SCPerfTVRegisterCounter("decoder.vlan", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_vlan_qinq = SCPerfTVRegisterCounter("decoder.vlan_qinq", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_teredo = SCPerfTVRegisterCounter("decoder.teredo", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_ipv4inipv6 = SCPerfTVRegisterCounter("decoder.ipv4_in_ipv6", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_ipv6inipv6 = SCPerfTVRegisterCounter("decoder.ipv6_in_ipv6", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_mpls = SCPerfTVRegisterCounter("decoder.mpls", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_avg_pkt_size = SCPerfTVRegisterAvgCounter("decoder.avg_pkt_size", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_max_pkt_size = SCPerfTVRegisterMaxCounter("decoder.max_pkt_size", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_defrag_ipv4_fragments =
SCPerfTVRegisterCounter("defrag.ipv4.fragments", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_defrag_ipv4_reassembled =
SCPerfTVRegisterCounter("defrag.ipv4.reassembled", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_defrag_ipv4_timeouts =
SCPerfTVRegisterCounter("defrag.ipv4.timeouts", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_defrag_ipv6_fragments =
SCPerfTVRegisterCounter("defrag.ipv6.fragments", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_defrag_ipv6_reassembled =
SCPerfTVRegisterCounter("defrag.ipv6.reassembled", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_defrag_ipv6_timeouts =
SCPerfTVRegisterCounter("defrag.ipv6.timeouts", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
dtv->counter_defrag_max_hit =
SCPerfTVRegisterCounter("defrag.max_frag_hits", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
return;
}

20
src/detect-engine.c
Unescape Escape View File

@ -1348,16 +1348,16 @@ 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, "NULL");
SC_PERF_TYPE_UINT64);
#ifdef PROFILING
uint16_t counter_mpm_list = SCPerfTVRegisterAvgCounter("detect.mpm_list", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
uint16_t counter_nonmpm_list = SCPerfTVRegisterAvgCounter("detect.nonmpm_list", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
uint16_t counter_fnonmpm_list = SCPerfTVRegisterAvgCounter("detect.fnonmpm_list", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
uint16_t counter_match_list = SCPerfTVRegisterAvgCounter("detect.match_list", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
#endif
DetectEngineThreadCtx *det_ctx = SCMalloc(sizeof(DetectEngineThreadCtx));
if (unlikely(det_ctx == NULL))
@ -1432,16 +1432,16 @@ static DetectEngineThreadCtx *DetectEngineThreadCtxInitForReload(
/** alert counter setup */
det_ctx->counter_alerts = SCPerfTVRegisterCounter("detect.alert", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
#ifdef PROFILING
uint16_t counter_mpm_list = SCPerfTVRegisterAvgCounter("detect.mpm_list", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
uint16_t counter_nonmpm_list = SCPerfTVRegisterAvgCounter("detect.nonmpm_list", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
uint16_t counter_fnonmpm_list = SCPerfTVRegisterAvgCounter("detect.fnonmpm_list", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
uint16_t counter_match_list = SCPerfTVRegisterAvgCounter("detect.match_list", tv,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
det_ctx->counter_mpm_list = counter_mpm_list;
det_ctx->counter_nonmpm_list = counter_nonmpm_list;
det_ctx->counter_fnonmpm_list = counter_fnonmpm_list;

25
src/flow-manager.c
Unescape Escape View File

@ -525,21 +525,21 @@ static TmEcode FlowManagerThreadInit(ThreadVars *t, void *initdata, void **data)
*data = ftd;
ftd->flow_mgr_cnt_clo = SCPerfTVRegisterCounter("flow_mgr.closed_pruned", t,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
ftd->flow_mgr_cnt_new = SCPerfTVRegisterCounter("flow_mgr.new_pruned", t,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
ftd->flow_mgr_cnt_est = SCPerfTVRegisterCounter("flow_mgr.est_pruned", t,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
ftd->flow_mgr_memuse = SCPerfTVRegisterCounter("flow.memuse", t,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
ftd->flow_mgr_spare = SCPerfTVRegisterCounter("flow.spare", t,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
ftd->flow_emerg_mode_enter = SCPerfTVRegisterCounter("flow.emerg_mode_entered", t,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
ftd->flow_emerg_mode_over = SCPerfTVRegisterCounter("flow.emerg_mode_over", t,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
ftd->flow_tcp_reuse = SCPerfTVRegisterCounter("flow.tcp_reuse", t,
SC_PERF_TYPE_UINT64, "NULL");
SC_PERF_TYPE_UINT64);
PacketPoolInit();
return TM_ECODE_OK;
@ -576,14 +576,11 @@ static TmEcode FlowManager(ThreadVars *th_v, void *thread_data)
/* 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,
"NULL");
SC_PERF_TYPE_UINT64);
uint16_t flow_mgr_host_active = SCPerfTVRegisterCounter("hosts.active", th_v,
SC_PERF_TYPE_Q_NORMAL,
"NULL");
SC_PERF_TYPE_UINT64);
uint16_t flow_mgr_host_spare = SCPerfTVRegisterCounter("hosts.spare", th_v,
SC_PERF_TYPE_Q_NORMAL,
"NULL");
SC_PERF_TYPE_UINT64);
*/
memset(&ts, 0, sizeof(ts));

8
src/source-af-packet.c
Unescape Escape View File

@ -1715,13 +1715,9 @@ 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,
"NULL");
ptv->tv, SC_PERF_TYPE_UINT64);
ptv->capture_kernel_drops = SCPerfTVRegisterCounter("capture.kernel_drops",
ptv->tv,
SC_PERF_TYPE_UINT64,
"NULL");
ptv->tv, SC_PERF_TYPE_UINT64);
#endif
char *active_runmode = RunmodeGetActive();

4
src/source-erf-dag.c
Unescape Escape View File

@ -305,9 +305,9 @@ ReceiveErfDagThreadInit(ThreadVars *tv, void *initdata, void **data)
}
ewtn->packets = SCPerfTVRegisterCounter("capture.dag_packets",
tv, SC_PERF_TYPE_UINT64, "NULL");
tv, SC_PERF_TYPE_UINT64);
ewtn->drops = SCPerfTVRegisterCounter("capture.dag_drops",
tv, SC_PERF_TYPE_UINT64, "NULL");
tv, SC_PERF_TYPE_UINT64);
ewtn->tv = tv;
*data = (void *)ewtn;

30
src/source-mpipe.c
Unescape Escape View File

@ -438,36 +438,26 @@ static void MpipeRegisterPerfCounters(MpipeThreadVars *ptv, ThreadVars *tv)
/* register counters */
ptv->max_mpipe_depth = SCPerfTVRegisterCounter("mpipe.max_mpipe_depth",
tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
ptv->mpipe_drop = SCPerfTVRegisterCounter("mpipe.drop",
tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
ptv->counter_no_buffers_0 = SCPerfTVRegisterCounter("mpipe.no_buf0", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
ptv->counter_no_buffers_1 = SCPerfTVRegisterCounter("mpipe.no_buf1", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
ptv->counter_no_buffers_2 = SCPerfTVRegisterCounter("mpipe.no_buf2", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
ptv->counter_no_buffers_3 = SCPerfTVRegisterCounter("mpipe.no_buf3", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
ptv->counter_no_buffers_4 = SCPerfTVRegisterCounter("mpipe.no_buf4", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
ptv->counter_no_buffers_5 = SCPerfTVRegisterCounter("mpipe.no_buf5", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
ptv->counter_no_buffers_6 = SCPerfTVRegisterCounter("mpipe.no_buf6", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
ptv->counter_no_buffers_7 = SCPerfTVRegisterCounter("mpipe.no_buf7", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
}
static const gxio_mpipe_buffer_size_enum_t gxio_buffer_sizes[] = {

8
src/source-netmap.c
Unescape Escape View File

@ -555,13 +555,9 @@ 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,
"NULL");
ntv->tv, SC_PERF_TYPE_UINT64);
ntv->capture_kernel_drops = SCPerfTVRegisterCounter("capture.kernel_drops",
ntv->tv,
SC_PERF_TYPE_UINT64,
"NULL");
ntv->tv, SC_PERF_TYPE_UINT64);
char const *active_runmode = RunmodeGetActive();
if (active_runmode && !strcmp("workers", active_runmode)) {

6
src/source-nflog.c
Unescape Escape View File

@ -309,12 +309,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,
"NULL");
SC_PERF_TYPE_UINT64);
ntv->capture_kernel_drops = SCPerfTVRegisterCounter("capture.kernel_drops",
ntv->tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
#endif
char *active_runmode = RunmodeGetActive();

24
src/source-pcap.c
Unescape Escape View File

@ -522,17 +522,11 @@ 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,
"NULL");
ptv->tv, SC_PERF_TYPE_UINT64);
ptv->capture_kernel_drops = SCPerfTVRegisterCounter("capture.kernel_drops",
ptv->tv,
SC_PERF_TYPE_UINT64,
"NULL");
ptv->tv, SC_PERF_TYPE_UINT64);
ptv->capture_kernel_ifdrops = SCPerfTVRegisterCounter("capture.kernel_ifdrops",
ptv->tv,
SC_PERF_TYPE_UINT64,
"NULL");
ptv->tv, SC_PERF_TYPE_UINT64);
*data = (void *)ptv;
SCReturnInt(TM_ECODE_OK);
@ -627,17 +621,11 @@ 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,
"NULL");
ptv->tv, SC_PERF_TYPE_UINT64);
ptv->capture_kernel_drops = SCPerfTVRegisterCounter("capture.kernel_drops",
ptv->tv,
SC_PERF_TYPE_UINT64,
"NULL");
ptv->tv, SC_PERF_TYPE_UINT64);
ptv->capture_kernel_ifdrops = SCPerfTVRegisterCounter("capture.kernel_ifdrops",
ptv->tv,
SC_PERF_TYPE_UINT64,
"NULL");
ptv->tv, SC_PERF_TYPE_UINT64);
*data = (void *)ptv;

8
src/source-pfring.c
Unescape Escape View File

@ -498,13 +498,9 @@ TmEcode ReceivePfringThreadInit(ThreadVars *tv, void *initdata, void **data)
}
ptv->capture_kernel_packets = SCPerfTVRegisterCounter("capture.kernel_packets",
ptv->tv,
SC_PERF_TYPE_UINT64,
"NULL");
ptv->tv, SC_PERF_TYPE_UINT64);
ptv->capture_kernel_drops = SCPerfTVRegisterCounter("capture.kernel_drops",
ptv->tv,
SC_PERF_TYPE_UINT64,
"NULL");
ptv->tv, SC_PERF_TYPE_UINT64);
/* 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

48
src/stream-tcp.c
Unescape Escape View File

@ -5073,35 +5073,25 @@ TmEcode StreamTcpThreadInit(ThreadVars *tv, void *initdata, void **data)
*data = (void *)stt;
stt->counter_tcp_sessions = SCPerfTVRegisterCounter("tcp.sessions", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
stt->counter_tcp_ssn_memcap = SCPerfTVRegisterCounter("tcp.ssn_memcap_drop", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
stt->counter_tcp_pseudo = SCPerfTVRegisterCounter("tcp.pseudo", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
stt->counter_tcp_pseudo_failed = SCPerfTVRegisterCounter("tcp.pseudo_failed", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
stt->counter_tcp_invalid_checksum = SCPerfTVRegisterCounter("tcp.invalid_checksum", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
stt->counter_tcp_no_flow = SCPerfTVRegisterCounter("tcp.no_flow", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
stt->counter_tcp_memuse = SCPerfTVRegisterCounter("tcp.memuse", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
stt->counter_tcp_syn = SCPerfTVRegisterCounter("tcp.syn", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
stt->counter_tcp_synack = SCPerfTVRegisterCounter("tcp.synack", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
stt->counter_tcp_rst = SCPerfTVRegisterCounter("tcp.rst", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
/* init reassembly ctx */
stt->ra_ctx = StreamTcpReassembleInitThreadCtx(tv);
@ -5109,24 +5099,18 @@ TmEcode StreamTcpThreadInit(ThreadVars *tv, void *initdata, void **data)
SCReturnInt(TM_ECODE_FAILED);
stt->ra_ctx->counter_tcp_segment_memcap = SCPerfTVRegisterCounter("tcp.segment_memcap_drop", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
stt->ra_ctx->counter_tcp_stream_depth = SCPerfTVRegisterCounter("tcp.stream_depth_reached", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
stt->ra_ctx->counter_tcp_reass_memuse = SCPerfTVRegisterCounter("tcp.reassembly_memuse", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
stt->ra_ctx->counter_tcp_reass_gap = SCPerfTVRegisterCounter("tcp.reassembly_gap", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
/** \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,
"NULL");
SC_PERF_TYPE_UINT64);
stt->ra_ctx->counter_htp_memcap = SCPerfTVRegisterCounter("http.memcap", tv,
SC_PERF_TYPE_UINT64,
"NULL");
SC_PERF_TYPE_UINT64);
SCLogDebug("StreamTcp thread specific ctx online at %p, reassembly ctx %p",
stt, stt->ra_ctx);

Write Preview
Loading…
Cancel
Save