counters: remove unused description

diff --git a/src/app-layer.c b/src/app-layer.c
index c14e5f4a508ae24b598b1b4f1ac3e552262c48ae..1f8590f5132b9b8bef6c0733556dbb6ccd7c3442 100644 (file)
--- a/src/app-layer.c
+++ b/src/app-layer.c
@@ -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;

diff --git a/src/counters.c b/src/counters.c
index f61da6abedde0715ec096e9a0fe94e22c43e8e50..468263720ef9847098f006464880c87495e8e321 100644 (file)
--- a/src/counters.c
+++ b/src/counters.c
@@ -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);

diff --git a/src/counters.h b/src/counters.h
index 877a65798803d3d335b8a082a6826c7e45244bb0..9a6cc8a29015babee80383c9436d063e1b5bfe28 100644 (file)
--- a/src/counters.h
+++ b/src/counters.h
@@ -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 *);

diff --git a/src/decode.c b/src/decode.c
index f578994cdeeee2a966cc88387efee04fe21b39c7..4e2613e79fd08a18dc4233d5550412c107910f05 100644 (file)
--- a/src/decode.c
+++ b/src/decode.c
@@ -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;
 }

diff --git a/src/detect-engine.c b/src/detect-engine.c
index ba02dfa228f11f4d57e32013ee551fd5bea69b00..355cdef9d141f0a4450ee84ec00afacaec3a95bd 100644 (file)
--- a/src/detect-engine.c
+++ b/src/detect-engine.c
@@ -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;

diff --git a/src/flow-manager.c b/src/flow-manager.c
index 48dba4efbaec1e243e4594e8ba6c820d38e1b177..71bdef657237917c34b0fc17f2e787243689123e 100644 (file)
--- a/src/flow-manager.c
+++ b/src/flow-manager.c
@@ -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));
 

diff --git a/src/source-af-packet.c b/src/source-af-packet.c
index d49898dfcff3e28cfa98c78e1ceb7adafb5f5fa4..3b50ba8f31673d1253f3ec6b40e402ab5851c434 100644 (file)
--- a/src/source-af-packet.c
+++ b/src/source-af-packet.c
@@ -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();

diff --git a/src/source-erf-dag.c b/src/source-erf-dag.c
index fbe21fe855f5d67fbfb5affadc216e290f4ea276..55b273e0aa9bb1a2574a4ea18601f887af21bec2 100644 (file)
--- a/src/source-erf-dag.c
+++ b/src/source-erf-dag.c
@@ -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;

diff --git a/src/source-mpipe.c b/src/source-mpipe.c
index f55f4218465942254641705c76cabf463b0a4c79..665282605e9f318f6e692d0e5a99f82c1ae53cd4 100644 (file)
--- a/src/source-mpipe.c
+++ b/src/source-mpipe.c
@@ -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[] = {

diff --git a/src/source-netmap.c b/src/source-netmap.c
index db853e19194db63d69746554f3a4855bfda44a24..adf330fc67f7aa4e6e2e628e7b0dea10059732d1 100644 (file)
--- a/src/source-netmap.c
+++ b/src/source-netmap.c
@@ -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)) {

diff --git a/src/source-nflog.c b/src/source-nflog.c
index d068acbb9dffa5631ee9abcfe655a9d863501b2d..98406ed504befc088b9ff8c1620b5ed6d1bfa6da 100644 (file)
--- a/src/source-nflog.c
+++ b/src/source-nflog.c
@@ -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();

diff --git a/src/source-pcap.c b/src/source-pcap.c
index 7a551d16ac228f2f69c2c0fd96c8e5646e1be257..57237fed14409e25bd743392d102b162f644cf61 100644 (file)
--- a/src/source-pcap.c
+++ b/src/source-pcap.c
@@ -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;
 

diff --git a/src/source-pfring.c b/src/source-pfring.c
index e0e9001960b614257f37bc52ad806e074e34b373..a7f1342a5c711313fa3fda9a2982465aba842e1f 100644 (file)
--- a/src/source-pfring.c
+++ b/src/source-pfring.c
@@ -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

diff --git a/src/stream-tcp.c b/src/stream-tcp.c
index c7d1098ed12cc5420ea715733f672f87b6d77849..5586c7a52c853d72392f95214843319b6cf0bf6d 100644 (file)
--- a/src/stream-tcp.c
+++ b/src/stream-tcp.c
@@ -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);