counters: s/SCPerfCounterIncr/StatsIncr/g

diff --git a/src/counters.c b/src/counters.c
index 5473b01b4a3c99afc5e1e49009dc03715f778d0d..6fcd66e23b7a3915c7c5d8433b902abfa907b704 100644 (file)
--- a/src/counters.c
+++ b/src/counters.c
@@ -140,7 +140,7 @@ void StatsAddUI64(ThreadVars *tv, uint16_t id, uint64_t x)
  * \param id  Index of the counter in the counter array
  * \param pca Counter array that holds the local counters for this TM
  */
-void SCPerfCounterIncr(ThreadVars *tv, uint16_t id)
+void StatsIncr(ThreadVars *tv, uint16_t id)
 {
     SCPerfPrivateContext *pca = &tv->perf_private_ctx;
 #ifdef UNITTESTS
@@ -1432,8 +1432,8 @@ static int SCPerfTestCntArraySize07()
     SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx);
     pca = &tv.perf_private_ctx;
 
-    SCPerfCounterIncr(&tv, 1);
-    SCPerfCounterIncr(&tv, 2);
+    StatsIncr(&tv, 1);
+    StatsIncr(&tv, 2);
 
     result = pca->size;
 
@@ -1457,7 +1457,7 @@ static int SCPerfTestUpdateCounter08()
     SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx);
     pca = &tv.perf_private_ctx;
 
-    SCPerfCounterIncr(&tv, id);
+    StatsIncr(&tv, id);
     StatsAddUI64(&tv, id, 100);
 
     result = pca->head[id].value;
@@ -1486,7 +1486,7 @@ static int SCPerfTestUpdateCounter09()
     SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx);
     pca = &tv.perf_private_ctx;
 
-    SCPerfCounterIncr(&tv, id2);
+    StatsIncr(&tv, id2);
     StatsAddUI64(&tv, id2, 100);
 
     result = (pca->head[id1].value == 0) && (pca->head[id2].value == 101);
@@ -1514,9 +1514,9 @@ static int SCPerfTestUpdateGlobalCounter10()
     SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx);
     pca = &tv.perf_private_ctx;
 
-    SCPerfCounterIncr(&tv, id1);
+    StatsIncr(&tv, id1);
     StatsAddUI64(&tv, id2, 100);
-    SCPerfCounterIncr(&tv, id3);
+    StatsIncr(&tv, id3);
     StatsAddUI64(&tv, id3, 100);
 
     SCPerfUpdateCounterArray(pca, &tv.perf_public_ctx);
@@ -1549,7 +1549,7 @@ static int SCPerfTestCounterValues11()
     SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx);
     pca = &tv.perf_private_ctx;
 
-    SCPerfCounterIncr(&tv, id1);
+    StatsIncr(&tv, id1);
     StatsAddUI64(&tv, id2, 256);
     StatsAddUI64(&tv, id3, 257);
     StatsAddUI64(&tv, id4, 16843024);

diff --git a/src/counters.h b/src/counters.h
index 7f463d91c6682cef2089373f826882c3e0193f0b..693141fd5d9fccc078e8af0a8eb7cf3031cf680b 100644 (file)
--- a/src/counters.h
+++ b/src/counters.h
@@ -126,7 +126,7 @@ void SCPerfReleasePCA(SCPerfPrivateContext *);
 /* functions used to update local counter values */
 void StatsAddUI64(struct ThreadVars_ *, uint16_t, uint64_t);
 void SCPerfCounterSetUI64(struct ThreadVars_ *, uint16_t, uint64_t);
-void SCPerfCounterIncr(struct ThreadVars_ *, uint16_t);
+void StatsIncr(struct ThreadVars_ *, uint16_t);
 
 #define SCPerfSyncCounters(tv) \
     SCPerfUpdateCounterArray(&(tv)->perf_private_ctx, &(tv)->perf_public_ctx);  \

diff --git a/src/decode-ethernet.c b/src/decode-ethernet.c
index d77b7ac3b32f7d225ad61ef88d21bb8173ae558f..ee4157236cb8b819f588615795fe0214e15fc2fc 100644 (file)
--- a/src/decode-ethernet.c
+++ b/src/decode-ethernet.c
@@ -41,7 +41,7 @@
 int DecodeEthernet(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
                    uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_eth);
+    StatsIncr(tv, dtv->counter_eth);
 
     if (unlikely(len < ETHERNET_HEADER_LEN)) {
         ENGINE_SET_INVALID_EVENT(p, ETHERNET_PKT_TOO_SMALL);

diff --git a/src/decode-gre.c b/src/decode-gre.c
index 42459446bd1452a0c802301d7cbfc19011968e4f..af4c1af55b080c69d8c8366e9a8860739cab241a 100644 (file)
--- a/src/decode-gre.c
+++ b/src/decode-gre.c
@@ -48,7 +48,7 @@ int DecodeGRE(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, ui
     uint16_t header_len = GRE_HDR_LEN;
     GRESreHdr *gsre = NULL;
 
-    SCPerfCounterIncr(tv, dtv->counter_gre);
+    StatsIncr(tv, dtv->counter_gre);
 
     if(len < GRE_HDR_LEN)    {
         ENGINE_SET_INVALID_EVENT(p, GRE_PKT_TOO_SMALL);

diff --git a/src/decode-icmpv4.c b/src/decode-icmpv4.c
index af094e4259fe83844b62e1b753982962eefdb231..5af012ce9ac8026f54ed534f31e02670f75f6c06 100644 (file)
--- a/src/decode-icmpv4.c
+++ b/src/decode-icmpv4.c
@@ -153,7 +153,7 @@ void DecodePartialIPV4( Packet* p, uint8_t* partial_packet, uint16_t len )
  */
 int DecodeICMPV4(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_icmpv4);
+    StatsIncr(tv, dtv->counter_icmpv4);
 
     if (len < ICMPV4_HEADER_LEN) {
         ENGINE_SET_INVALID_EVENT(p, ICMPV4_PKT_TOO_SMALL);

diff --git a/src/decode-icmpv6.c b/src/decode-icmpv6.c
index d9bc41db656969b5e473db44cc0ae1aa6b1d424f..7972ea797c98af30636bb619cd2a0adf5bf0d743 100644 (file)
--- a/src/decode-icmpv6.c
+++ b/src/decode-icmpv6.c
@@ -168,7 +168,7 @@ int DecodeICMPV6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
                   uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
     int full_hdr = 0;
-    SCPerfCounterIncr(tv, dtv->counter_icmpv6);
+    StatsIncr(tv, dtv->counter_icmpv6);
 
     if (len < ICMPV6_HEADER_LEN) {
         SCLogDebug("ICMPV6_PKT_TOO_SMALL");

diff --git a/src/decode-ipv4.c b/src/decode-ipv4.c
index a0ca8c173ced1de930701717f029240e42fb5b53..856ae5b6d6473a558b7dc27e0e2312aeb4f63117 100644 (file)
--- a/src/decode-ipv4.c
+++ b/src/decode-ipv4.c
@@ -519,7 +519,7 @@ static int DecodeIPV4Packet(Packet *p, uint8_t *pkt, uint16_t len)
 
 int DecodeIPV4(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_ipv4);
+    StatsIncr(tv, dtv->counter_ipv4);
 
     SCLogDebug("pkt %p len %"PRIu16"", pkt, len);
 

diff --git a/src/decode-ipv6.c b/src/decode-ipv6.c
index 12ba7705d90460a8d1fd2f840f415869a5f76028..efd6f10f5033416da7c3aa06557c8a9f020cb38c 100644 (file)
--- a/src/decode-ipv6.c
+++ b/src/decode-ipv6.c
@@ -65,7 +65,7 @@ static void DecodeIPv4inIPv6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, u
                 PKT_SET_SRC(tp, PKT_SRC_DECODER_IPV6);
                 /* add the tp to the packet queue. */
                 PacketEnqueue(pq,tp);
-                SCPerfCounterIncr(tv, dtv->counter_ipv4inipv6);
+                StatsIncr(tv, dtv->counter_ipv4inipv6);
                 return;
             }
         }
@@ -92,7 +92,7 @@ static int DecodeIP6inIP6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint
             if (tp != NULL) {
                 PKT_SET_SRC(tp, PKT_SRC_DECODER_IPV6);
                 PacketEnqueue(pq,tp);
-                SCPerfCounterIncr(tv, dtv->counter_ipv6inipv6);
+                StatsIncr(tv, dtv->counter_ipv6inipv6);
             }
         }
     } else {
@@ -601,7 +601,7 @@ int DecodeIPV6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, u
 {
     int ret;
 
-    SCPerfCounterIncr(tv, dtv->counter_ipv6);
+    StatsIncr(tv, dtv->counter_ipv6);
 
     /* do the actual decoding */
     ret = DecodeIPV6Packet (tv, dtv, p, pkt, len);

diff --git a/src/decode-mpls.c b/src/decode-mpls.c
index f8a77b5831b85253856f1c11a0ebc34f42d11a7e..1569ebfbf6b7cd194c743b73191ab45a46a533f0 100644 (file)
--- a/src/decode-mpls.c
+++ b/src/decode-mpls.c
@@ -51,7 +51,7 @@ int DecodeMPLS(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt,
     int label;
     int event = 0;
 
-    SCPerfCounterIncr(tv, dtv->counter_mpls);
+    StatsIncr(tv, dtv->counter_mpls);
 
     do {
         if (len < MPLS_HEADER_LEN) {

diff --git a/src/decode-null.c b/src/decode-null.c
index 445a33331c2e8e5cce0de47577d566acd4a63729..b3bcb0667c2176cd23219fe1b4e02385469c482f 100644 (file)
--- a/src/decode-null.c
+++ b/src/decode-null.c
@@ -47,7 +47,7 @@
 
 int DecodeNull(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_null);
+    StatsIncr(tv, dtv->counter_null);
 
     if (unlikely(len < HDR_SIZE)) {
         ENGINE_SET_INVALID_EVENT(p, LTNULL_PKT_TOO_SMALL);

diff --git a/src/decode-ppp.c b/src/decode-ppp.c
index d6ec902512c9625b274cd1af9f29a3b1f6602f35..f4ea670cfe49067241840506d2d5959b0711858d 100644 (file)
--- a/src/decode-ppp.c
+++ b/src/decode-ppp.c
@@ -42,7 +42,7 @@
 
 int DecodePPP(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_ppp);
+    StatsIncr(tv, dtv->counter_ppp);
 
     if (unlikely(len < PPP_HEADER_LEN)) {
         ENGINE_SET_INVALID_EVENT(p, PPP_PKT_TOO_SMALL);

diff --git a/src/decode-pppoe.c b/src/decode-pppoe.c
index 565a9f5894cd9573f21b4a162e1817960ec77c83..b6f5031fa7db7fe9f1b0b32df71adee94b818167 100644 (file)
--- a/src/decode-pppoe.c
+++ b/src/decode-pppoe.c
@@ -49,7 +49,7 @@
  */
 int DecodePPPOEDiscovery(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_pppoe);
+    StatsIncr(tv, dtv->counter_pppoe);
 
     if (len < PPPOE_DISCOVERY_HEADER_MIN_LEN) {
         ENGINE_SET_INVALID_EVENT(p, PPPOE_PKT_TOO_SMALL);
@@ -128,7 +128,7 @@ int DecodePPPOEDiscovery(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8
  */
 int DecodePPPOESession(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_pppoe);
+    StatsIncr(tv, dtv->counter_pppoe);
 
     if (len < PPPOE_SESSION_HEADER_LEN) {
         ENGINE_SET_INVALID_EVENT(p, PPPOE_PKT_TOO_SMALL);

diff --git a/src/decode-raw.c b/src/decode-raw.c
index dc31c944cac5834fda603c9f6ea49feeb15e0b1b..22e1b9e1e9087b323d007f494b98ef93778c2ba8 100644 (file)
--- a/src/decode-raw.c
+++ b/src/decode-raw.c
@@ -45,7 +45,7 @@
 
 int DecodeRaw(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_raw);
+    StatsIncr(tv, dtv->counter_raw);
 
     /* If it is ipv4 or ipv6 it should at least be the size of ipv4 */
     if (unlikely(len < IPV4_HEADER_LEN)) {

diff --git a/src/decode-sctp.c b/src/decode-sctp.c
index 25607421256be6410a243bb0787fec2195864e59..2d493c6690fe3760b61bde9f9b2c33ef9f9da49e 100644 (file)
--- a/src/decode-sctp.c
+++ b/src/decode-sctp.c
@@ -61,7 +61,7 @@ static int DecodeSCTPPacket(ThreadVars *tv, Packet *p, uint8_t *pkt, uint16_t le
 
 int DecodeSCTP(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_sctp);
+    StatsIncr(tv, dtv->counter_sctp);
 
     if (unlikely(DecodeSCTPPacket(tv, p,pkt,len) < 0)) {
         p->sctph = NULL;

diff --git a/src/decode-sll.c b/src/decode-sll.c
index 0da071da9351f42bc6b3cbfd597c42af07d87c44..eed61a4c39fee8b31efee1468b1a8e0b2832df95 100644 (file)
--- a/src/decode-sll.c
+++ b/src/decode-sll.c
@@ -38,7 +38,7 @@
 
 int DecodeSll(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_sll);
+    StatsIncr(tv, dtv->counter_sll);
 
     if (unlikely(len < SLL_HEADER_LEN)) {
         ENGINE_SET_INVALID_EVENT(p, SLL_PKT_TOO_SMALL);

diff --git a/src/decode-tcp.c b/src/decode-tcp.c
index ae85df48d382b45998310cdc52a8fcb380013475..428e7ae4e39079b380092ac2043ec9696dcf2db6 100644 (file)
--- a/src/decode-tcp.c
+++ b/src/decode-tcp.c
@@ -186,7 +186,7 @@ static int DecodeTCPPacket(ThreadVars *tv, Packet *p, uint8_t *pkt, uint16_t len
 
 int DecodeTCP(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_tcp);
+    StatsIncr(tv, dtv->counter_tcp);
 
     if (unlikely(DecodeTCPPacket(tv, p,pkt,len) < 0)) {
         SCLogDebug("invalid TCP packet");

diff --git a/src/decode-teredo.c b/src/decode-teredo.c
index ba8cd311b37bf658c656888563c999b50834dc95..b4199a052d64c13a38aa0afa6caa7825f331d15c 100644 (file)
--- a/src/decode-teredo.c
+++ b/src/decode-teredo.c
@@ -96,7 +96,7 @@ int DecodeTeredo(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt,
                     PKT_SET_SRC(tp, PKT_SRC_DECODER_TEREDO);
                     /* add the tp to the packet queue. */
                     PacketEnqueue(pq,tp);
-                    SCPerfCounterIncr(tv, dtv->counter_teredo);
+                    StatsIncr(tv, dtv->counter_teredo);
                     return TM_ECODE_OK;
                 }
             }

diff --git a/src/decode-udp.c b/src/decode-udp.c
index a5be2a43125d27c43ac39c8e23c1287c45e464b5..14ba7887d3aa7809c2f7bd60caddcc475bc5d92b 100644 (file)
--- a/src/decode-udp.c
+++ b/src/decode-udp.c
@@ -72,7 +72,7 @@ static int DecodeUDPPacket(ThreadVars *t, Packet *p, uint8_t *pkt, uint16_t len)
 
 int DecodeUDP(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_udp);
+    StatsIncr(tv, dtv->counter_udp);
 
     if (unlikely(DecodeUDPPacket(tv, p,pkt,len) < 0)) {
         p->udph = NULL;

diff --git a/src/decode-vlan.c b/src/decode-vlan.c
index 95eb3e6845d45f67a908c5fad3cabb3156d429c3..59495594e7e6cd60430371bac710b6fd2f195337 100644 (file)
--- a/src/decode-vlan.c
+++ b/src/decode-vlan.c
@@ -61,9 +61,9 @@ int DecodeVLAN(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, u
     uint32_t proto;
 
     if (p->vlan_idx == 0)
-        SCPerfCounterIncr(tv, dtv->counter_vlan);
+        StatsIncr(tv, dtv->counter_vlan);
     else if (p->vlan_idx == 1)
-        SCPerfCounterIncr(tv, dtv->counter_vlan_qinq);
+        StatsIncr(tv, dtv->counter_vlan_qinq);
 
     if(len < VLAN_HEADER_LEN)    {
         ENGINE_SET_INVALID_EVENT(p, VLAN_HEADER_TOO_SMALL);

diff --git a/src/decode.c b/src/decode.c
index b096bf5753ee03374ef87902d2e638f393a74469..16f5476b411a670df8b21db476e7c80c3dd131e5 100644 (file)
--- a/src/decode.c
+++ b/src/decode.c
@@ -106,7 +106,7 @@ void PacketDecodeFinalize(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p)
 {
 
     if (p->flags & PKT_IS_INVALID)
-        SCPerfCounterIncr(tv, dtv->counter_invalid);
+        StatsIncr(tv, dtv->counter_invalid);
 
 #ifdef __SC_CUDA_SUPPORT__
     if (dtv->cuda_vars.mpm_is_cuda)

diff --git a/src/defrag.c b/src/defrag.c
index 0d1ab333dc7c9821a41b7fe43ef2c8ed3c92a048..7418b93c665f6107fec4ade30d9615621ad70b14 100644 (file)
--- a/src/defrag.c
+++ b/src/defrag.c
@@ -771,7 +771,7 @@ insert:
         if (tracker->af == AF_INET) {
             r = Defrag4Reassemble(tv, tracker, p);
             if (r != NULL && tv != NULL && dtv != NULL) {
-                SCPerfCounterIncr(tv, dtv->counter_defrag_ipv4_reassembled);
+                StatsIncr(tv, dtv->counter_defrag_ipv4_reassembled);
                 if (pq && DecodeIPV4(tv, dtv, r, (void *)r->ip4h,
                                IPV4_GET_IPLEN(r), pq) != TM_ECODE_OK) {
                     TmqhOutputPacketpool(tv, r);
@@ -783,7 +783,7 @@ insert:
         else if (tracker->af == AF_INET6) {
             r = Defrag6Reassemble(tv, tracker, p);
             if (r != NULL && tv != NULL && dtv != NULL) {
-                SCPerfCounterIncr(tv, dtv->counter_defrag_ipv6_reassembled);
+                StatsIncr(tv, dtv->counter_defrag_ipv6_reassembled);
                 if (pq && DecodeIPV6(tv, dtv, r, (uint8_t *)r->ip6h,
                                IPV6_GET_PLEN(r) + IPV6_HEADER_LEN,
                                pq) != TM_ECODE_OK) {
@@ -923,10 +923,10 @@ Defrag(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, PacketQueue *pq)
 
     if (tv != NULL && dtv != NULL) {
         if (af == AF_INET) {
-            SCPerfCounterIncr(tv, dtv->counter_defrag_ipv4_fragments);
+            StatsIncr(tv, dtv->counter_defrag_ipv4_fragments);
         }
         else if (af == AF_INET6) {
-            SCPerfCounterIncr(tv, dtv->counter_defrag_ipv6_fragments);
+            StatsIncr(tv, dtv->counter_defrag_ipv6_fragments);
         }
     }
 

diff --git a/src/flow-manager.c b/src/flow-manager.c
index eca211f09c1b4ed03edaba511b9217ad91239439..4076abdca1688b7b6f9becdc84f5cb0bebb1734e 100644 (file)
--- a/src/flow-manager.c
+++ b/src/flow-manager.c
@@ -591,7 +591,7 @@ static TmEcode FlowManager(ThreadVars *th_v, void *thread_data)
 
                 SCLogDebug("Flow emergency mode entered...");
 
-                SCPerfCounterIncr(th_v, ftd->flow_emerg_mode_enter);
+                StatsIncr(th_v, ftd->flow_emerg_mode_enter);
             }
         }
 
@@ -662,7 +662,7 @@ static TmEcode FlowManager(ThreadVars *th_v, void *thread_data)
                           "%% flows at the queue", (uintmax_t)ts.tv_sec,
                           (uintmax_t)ts.tv_usec, len * 100 / flow_config.prealloc);
 
-                SCPerfCounterIncr(th_v, ftd->flow_emerg_mode_over);
+                StatsIncr(th_v, ftd->flow_emerg_mode_over);
             } else {
                 flow_update_delay_sec = FLOW_EMERG_MODE_UPDATE_DELAY_SEC;
                 flow_update_delay_nsec = FLOW_EMERG_MODE_UPDATE_DELAY_NSEC;

diff --git a/src/source-af-packet.c b/src/source-af-packet.c
index 1fffe2ba0f625c67758c05e01bcc5a39f05cfde7..be06b4e95ef283157c33c3f8a8a12cec61e55239 100644 (file)
--- a/src/source-af-packet.c
+++ b/src/source-af-packet.c
@@ -1852,15 +1852,15 @@ TmEcode DecodeAFP(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packet
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-    //SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+    //StatsIncr(tv, dtv->counter_pkts_per_sec);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
 
     /* If suri has set vlan during reading, we increase vlan counter */
     if (p->vlan_idx) {
-        SCPerfCounterIncr(tv, dtv->counter_vlan);
+        StatsIncr(tv, dtv->counter_vlan);
     }
 
     /* call the decoder */

diff --git a/src/source-erf-dag.c b/src/source-erf-dag.c
index 7394ddd04354e446f0d38dd3bd591d57b7f3e407..f8b6b16b286b7d84fcff3a86faf6735a38f58590 100644 (file)
--- a/src/source-erf-dag.c
+++ b/src/source-erf-dag.c
@@ -535,7 +535,7 @@ ProcessErfDagRecord(ErfDagThreadVars *ewtn, char *prec)
         p->ts.tv_sec++;
     }
 
-    SCPerfCounterIncr(tv, ewtn->packets);
+    StatsIncr(tv, ewtn->packets);
     ewtn->bytes += wlen;
 
     if (TmThreadsSlotProcessPkt(ewtn->tv, ewtn->slot, p) != TM_ECODE_OK) {
@@ -621,8 +621,8 @@ DecodeErfDag(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-    //SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+    //StatsIncr(tv, dtv->counter_pkts_per_sec);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));

diff --git a/src/source-erf-file.c b/src/source-erf-file.c
index 5bc4c38f5c6a9b60e1551ae19a5148f169bc09ec..b1ab61938d9383a4d4febb605c8792eee7bf2172 100644 (file)
--- a/src/source-erf-file.c
+++ b/src/source-erf-file.c
@@ -284,8 +284,8 @@ DecodeErfFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueu
         return TM_ECODE_OK;
 
     /* Update counters. */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-    //SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+    //StatsIncr(tv, dtv->counter_pkts_per_sec);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));

diff --git a/src/source-ipfw.c b/src/source-ipfw.c
index 75965465076c9f254ddf0af047d847dcce8d3f2b..3fb8ef3361ed51c626bf2579ae33a1f7da46e417 100644 (file)
--- a/src/source-ipfw.c
+++ b/src/source-ipfw.c
@@ -452,7 +452,7 @@ TmEcode DecodeIPFW(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packe
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
+    StatsIncr(tv, dtv->counter_pkts);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));

diff --git a/src/source-mpipe.c b/src/source-mpipe.c
index 5a9d60eeebb7fbf8b75a96c6f3ad2c8a8b8183ce..511e298f1ce3522aff3fd77a3e670fedfec80248 100644 (file)
--- a/src/source-mpipe.c
+++ b/src/source-mpipe.c
@@ -398,10 +398,10 @@ TmEcode ReceiveMpipeLoop(ThreadVars *tv, void *data, void *slot)
                     if (idesc->be) {
                         /* Buffer Error - No buffer available, so mPipe
                          * dropped the packet. */
-                        SCPerfCounterIncr(tv, XlateStack(ptv, idesc->stack_idx));
+                        StatsIncr(tv, XlateStack(ptv, idesc->stack_idx));
                     } else {
                         /* Bad packet. CRC error */
-                        SCPerfCounterIncr(tv, ptv->mpipe_drop);
+                        StatsIncr(tv, ptv->mpipe_drop);
                         gxio_mpipe_iqueue_drop(iqueue, idesc);
                     }
                     gxio_mpipe_iqueue_release(iqueue, idesc);
@@ -1039,8 +1039,8 @@ TmEcode DecodeMpipe(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-//    SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+//    StatsIncr(tv, dtv->counter_pkts_per_sec);
 
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
 

diff --git a/src/source-napatech.c b/src/source-napatech.c
index ed32ded4948bd38e4a318949ccb6f191063c2ed7..b508e03ac61fcc24bd12e494a5220e9e3d856035 100644 (file)
--- a/src/source-napatech.c
+++ b/src/source-napatech.c
@@ -357,8 +357,8 @@ TmEcode NapatechDecode(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-//    SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+//    StatsIncr(tv, dtv->counter_pkts_per_sec);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));

diff --git a/src/source-netmap.c b/src/source-netmap.c
index e0e52977134dd1ed38e752a9f990751ff3941af4..0a96a148f02da05f1314d9cb89f260822d702065 100644 (file)
--- a/src/source-netmap.c
+++ b/src/source-netmap.c
@@ -930,7 +930,7 @@ static TmEcode DecodeNetmap(ThreadVars *tv, Packet *p, void *data, PacketQueue *
         SCReturnInt(TM_ECODE_OK);
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
+    StatsIncr(tv, dtv->counter_pkts);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));

diff --git a/src/source-nflog.c b/src/source-nflog.c
index f8dc318ce928af1943269206fa5478083ca0016b..d37959807c05c415d09f98d864b4a22a84b3831f 100644 (file)
--- a/src/source-nflog.c
+++ b/src/source-nflog.c
@@ -499,7 +499,7 @@ TmEcode DecodeNFLOG(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Pack
     IPV6Hdr *ip6h = (IPV6Hdr *)GET_PKT_DATA(p);
     DecodeThreadVars *dtv = (DecodeThreadVars *)data;
 
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
+    StatsIncr(tv, dtv->counter_pkts);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));

diff --git a/src/source-nfq.c b/src/source-nfq.c
index ea2bdf83d39db9ab42a88994db90324c8abca110..9596ed45382a96b14fdc0cce4dda59976d600965 100644 (file)
--- a/src/source-nfq.c
+++ b/src/source-nfq.c
@@ -1223,7 +1223,7 @@ TmEcode DecodeNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packet
     if (p->flags & PKT_PSEUDO_STREAM_END)
         return TM_ECODE_OK;
 
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
+    StatsIncr(tv, dtv->counter_pkts);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));

diff --git a/src/source-pcap-file.c b/src/source-pcap-file.c
index 7e7b8ba79b424ef4a51d0a99cf3879f909caf71e..c46c8a6bd73b668c9397ba3e275c0d570e5809ad 100644 (file)
--- a/src/source-pcap-file.c
+++ b/src/source-pcap-file.c
@@ -401,8 +401,8 @@ TmEcode DecodePcapFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, P
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-    //SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+    //StatsIncr(tv, dtv->counter_pkts_per_sec);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));

diff --git a/src/source-pcap.c b/src/source-pcap.c
index b9283189951461188658e0e2e8ecead51bf10547..aa67b60adadafa4771a6d7ce013bf644b37d3773 100644 (file)
--- a/src/source-pcap.c
+++ b/src/source-pcap.c
@@ -704,8 +704,8 @@ TmEcode DecodePcap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packe
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-    //SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+    //StatsIncr(tv, dtv->counter_pkts_per_sec);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));

diff --git a/src/source-pfring.c b/src/source-pfring.c
index 6e997be920ed323318449b350211c3ff0b045307..6b60df9adda4a91237edd33814126501cc6f32f8 100644 (file)
--- a/src/source-pfring.c
+++ b/src/source-pfring.c
@@ -602,15 +602,15 @@ TmEcode DecodePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Pac
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-    //SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+    //StatsIncr(tv, dtv->counter_pkts_per_sec);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
 
     /* If suri has set vlan during reading, we increase vlan counter */
     if (p->vlan_idx) {
-        SCPerfCounterIncr(tv, dtv->counter_vlan);
+        StatsIncr(tv, dtv->counter_vlan);
     }
 
     DecodeEthernet(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);

diff --git a/src/stream-tcp-reassemble.c b/src/stream-tcp-reassemble.c
index 839a9ccd55f4a57032954f01c041a44e9c28b0ad..c0979b9459ad802d47939a0d59c3b6fc036a57b6 100644 (file)
--- a/src/stream-tcp-reassemble.c
+++ b/src/stream-tcp-reassemble.c
@@ -1906,7 +1906,7 @@ int StreamTcpReassembleHandleSegmentHandleData(ThreadVars *tv, TcpReassemblyThre
 
     if (stream->flags & STREAMTCP_STREAM_FLAG_DEPTH_REACHED) {
         /* increment stream depth counter */
-        SCPerfCounterIncr(tv, ra_ctx->counter_tcp_stream_depth);
+        StatsIncr(tv, ra_ctx->counter_tcp_stream_depth);
 
         stream->flags |= STREAMTCP_STREAM_FLAG_NOREASSEMBLY;
         SCLogDebug("ssn %p: reassembly depth reached, "
@@ -2607,7 +2607,7 @@ int DoHandleGap(ThreadVars *tv, TcpReassemblyThreadCtx *ra_ctx,
         stream->flags |= STREAMTCP_STREAM_FLAG_GAP;
 
         StreamTcpSetEvent(p, STREAM_REASSEMBLY_SEQ_GAP);
-        SCPerfCounterIncr(tv, ra_ctx->counter_tcp_reass_gap);
+        StatsIncr(tv, ra_ctx->counter_tcp_reass_gap);
 #ifdef DEBUG
         dbg_app_layer_gap++;
 #endif
@@ -2953,7 +2953,7 @@ int StreamTcpReassembleAppLayer (ThreadVars *tv, TcpReassemblyThreadCtx *ra_ctx,
             stream->flags |= STREAMTCP_STREAM_FLAG_GAP;
 
             StreamTcpSetEvent(p, STREAM_REASSEMBLY_SEQ_GAP);
-            SCPerfCounterIncr(tv, ra_ctx->counter_tcp_reass_gap);
+            StatsIncr(tv, ra_ctx->counter_tcp_reass_gap);
 #ifdef DEBUG
             dbg_app_layer_gap++;
 #endif
@@ -3596,7 +3596,7 @@ TcpSegment* StreamTcpGetSegment(ThreadVars *tv, TcpReassemblyThreadCtx *ra_ctx,
                    segment_pool[idx]->allocated);
         /* Increment the counter to show that we are not able to serve the
            segment request due to memcap limit */
-        SCPerfCounterIncr(tv, ra_ctx->counter_tcp_segment_memcap);
+        StatsIncr(tv, ra_ctx->counter_tcp_segment_memcap);
     } else {
         seg->flags = stream_config.segment_init_flags;
         seg->next = NULL;

diff --git a/src/stream-tcp.c b/src/stream-tcp.c
index 00e1e423a53f07814beb6303b985faad5eb2904a..afc19fc054517550b306eee6ebdb298e1c54a213 100644 (file)
--- a/src/stream-tcp.c
+++ b/src/stream-tcp.c
@@ -844,10 +844,10 @@ static int StreamTcpPacketStateNone(ThreadVars *tv, Packet *p,
         if (ssn == NULL) {
             ssn = StreamTcpNewSession(p, stt->ssn_pool_id);
             if (ssn == NULL) {
-                SCPerfCounterIncr(tv, stt->counter_tcp_ssn_memcap);
+                StatsIncr(tv, stt->counter_tcp_ssn_memcap);
                 return -1;
             }
-            SCPerfCounterIncr(tv, stt->counter_tcp_sessions);
+            StatsIncr(tv, stt->counter_tcp_sessions);
         }
         /* set the state */
         StreamTcpPacketSetState(p, ssn, TCP_SYN_RECV);
@@ -925,11 +925,11 @@ static int StreamTcpPacketStateNone(ThreadVars *tv, Packet *p,
         if (ssn == NULL) {
             ssn = StreamTcpNewSession(p, stt->ssn_pool_id);
             if (ssn == NULL) {
-                SCPerfCounterIncr(tv, stt->counter_tcp_ssn_memcap);
+                StatsIncr(tv, stt->counter_tcp_ssn_memcap);
                 return -1;
             }
 
-            SCPerfCounterIncr(tv, stt->counter_tcp_sessions);
+            StatsIncr(tv, stt->counter_tcp_sessions);
         }
 
         /* set the state */
@@ -978,10 +978,10 @@ static int StreamTcpPacketStateNone(ThreadVars *tv, Packet *p,
         if (ssn == NULL) {
             ssn = StreamTcpNewSession(p, stt->ssn_pool_id);
             if (ssn == NULL) {
-                SCPerfCounterIncr(tv, stt->counter_tcp_ssn_memcap);
+                StatsIncr(tv, stt->counter_tcp_ssn_memcap);
                 return -1;
             }
-            SCPerfCounterIncr(tv, stt->counter_tcp_sessions);
+            StatsIncr(tv, stt->counter_tcp_sessions);
         }
         /* set the state */
         StreamTcpPacketSetState(p, ssn, TCP_ESTABLISHED);
@@ -4461,12 +4461,12 @@ int StreamTcpPacket (ThreadVars *tv, Packet *p, StreamTcpThread *stt,
 
     /* update counters */
     if ((p->tcph->th_flags & (TH_SYN|TH_ACK)) == (TH_SYN|TH_ACK)) {
-        SCPerfCounterIncr(tv, stt->counter_tcp_synack);
+        StatsIncr(tv, stt->counter_tcp_synack);
     } else if (p->tcph->th_flags & (TH_SYN)) {
-        SCPerfCounterIncr(tv, stt->counter_tcp_syn);
+        StatsIncr(tv, stt->counter_tcp_syn);
     }
     if (p->tcph->th_flags & (TH_RST)) {
-        SCPerfCounterIncr(tv, stt->counter_tcp_rst);
+        StatsIncr(tv, stt->counter_tcp_rst);
     }
 
     /* broken TCP http://ask.wireshark.org/questions/3183/acknowledgment-number-broken-tcp-the-acknowledge-field-is-nonzero-while-the-ack-flag-is-not-set */
@@ -5020,13 +5020,13 @@ TmEcode StreamTcp (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packe
         return TM_ECODE_OK;
 
     if (p->flow == NULL) {
-        SCPerfCounterIncr(tv, stt->counter_tcp_no_flow);
+        StatsIncr(tv, stt->counter_tcp_no_flow);
         return TM_ECODE_OK;
     }
 
     if (stream_config.flags & STREAMTCP_INIT_FLAG_CHECKSUM_VALIDATION) {
         if (StreamTcpValidateChecksum(p) == 0) {
-            SCPerfCounterIncr(tv, stt->counter_tcp_invalid_checksum);
+            StatsIncr(tv, stt->counter_tcp_invalid_checksum);
             return TM_ECODE_OK;
         }
     } else {
@@ -5864,7 +5864,7 @@ void StreamTcpPseudoPacketCreateStreamEndPacket(ThreadVars *tv, StreamTcpThread
     Packet *np = StreamTcpPseudoSetup(p, GET_PKT_DATA(p), GET_PKT_LEN(p));
     if (np == NULL) {
         SCLogDebug("The packet received from packet allocation is NULL");
-        SCPerfCounterIncr(tv, stt->counter_tcp_pseudo_failed);
+        StatsIncr(tv, stt->counter_tcp_pseudo_failed);
         SCReturn;
     }
     PKT_SET_SRC(np, PKT_SRC_STREAM_TCP_STREAM_END_PSEUDO);
@@ -5899,7 +5899,7 @@ void StreamTcpPseudoPacketCreateStreamEndPacket(ThreadVars *tv, StreamTcpThread
 
     PacketEnqueue(pq, np);
 
-    SCPerfCounterIncr(tv, stt->counter_tcp_pseudo);
+    StatsIncr(tv, stt->counter_tcp_pseudo);
     SCReturn;
 }