counters: make increment call take threadvars

This hides the implementation from the caller.

diff --git a/src/app-layer-htp-mem.c b/src/app-layer-htp-mem.c
index f676af0617bdb496d69988c04163b16070dfeb94..18aa223a6bf83fe82f621778bdcdcda109290655 100644 (file)
--- a/src/app-layer-htp-mem.c
+++ b/src/app-layer-htp-mem.c
@@ -81,9 +81,9 @@ void HTPDecrMemuse(uint64_t size)
 void HTPMemuseCounter(ThreadVars *tv,  TcpReassemblyThreadCtx *trt)
 {
     uint64_t tmpval = SC_ATOMIC_GET(htp_memuse);
-    SCPerfCounterSetUI64(trt->counter_htp_memuse, tv->perf_private_ctx, tmpval);
+    SCPerfCounterSetUI64(tv, trt->counter_htp_memuse, tmpval);
     tmpval = SC_ATOMIC_GET(htp_memcap);
-    SCPerfCounterSetUI64(trt->counter_htp_memcap, tv->perf_private_ctx, tmpval);
+    SCPerfCounterSetUI64(tv, trt->counter_htp_memcap, tmpval);
     return;
 }
 /**

diff --git a/src/app-layer.c b/src/app-layer.c
index 711bec3a0587c8bfe7fff114650e3347efc91854..c14e5f4a508ae24b598b1b4f1ac3e552262c48ae 100644 (file)
--- a/src/app-layer.c
+++ b/src/app-layer.c
@@ -78,12 +78,9 @@ static void DNSUpdateCounters(ThreadVars *tv, AppLayerThreadCtx *app_tctx)
 
     DNSMemcapGetCounters(&memuse, &memcap_state, &memcap_global);
 
-    SCPerfCounterSetUI64(app_tctx->counter_dns_memuse,
-                         tv->perf_private_ctx, memuse);
-    SCPerfCounterSetUI64(app_tctx->counter_dns_memcap_state,
-                         tv->perf_private_ctx, memcap_state);
-    SCPerfCounterSetUI64(app_tctx->counter_dns_memcap_global,
-                         tv->perf_private_ctx, memcap_global);
+    SCPerfCounterSetUI64(tv, app_tctx->counter_dns_memuse, memuse);
+    SCPerfCounterSetUI64(tv, app_tctx->counter_dns_memcap_state, memcap_state);
+    SCPerfCounterSetUI64(tv, app_tctx->counter_dns_memcap_global, memcap_global);
 }
 
 /***** L7 layer dispatchers *****/

diff --git a/src/counters.c b/src/counters.c
index 3ccbccae96159362a479619a717ed04f3909ebfa..184852f78b80d92b4f312bee827e02c2a525b747 100644 (file)
--- a/src/counters.c
+++ b/src/counters.c
@@ -79,8 +79,10 @@ void SCPerfOutputCounters(ThreadVars *tv)
  * \param pca Counter array that holds the local counter for this TM
  * \param x   Value to add to this local counter
  */
-void SCPerfCounterAddUI64(uint16_t id, SCPerfPrivateContext *pca, uint64_t x)
+void SCPerfCounterAddUI64(ThreadVars *tv, uint16_t id, uint64_t x)
 {
+    SCPerfPrivateContext *pca = tv->perf_private_ctx;
+
     if (!pca) {
         SCLogDebug("counterarray is NULL");
         return;
@@ -99,8 +101,10 @@ void SCPerfCounterAddUI64(uint16_t id, SCPerfPrivateContext *pca, 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(uint16_t id, SCPerfPrivateContext *pca)
+void SCPerfCounterIncr(ThreadVars *tv, uint16_t id)
 {
+    SCPerfPrivateContext *pca = tv->perf_private_ctx;
+
     if (pca == NULL) {
         SCLogDebug("counterarray is NULL");
         return;
@@ -122,9 +126,10 @@ void SCPerfCounterIncr(uint16_t id, SCPerfPrivateContext *pca)
  * \param pca Pointer to the SCPerfPrivateContext
  * \param x   The value to set for the counter
  */
-void SCPerfCounterSetUI64(uint16_t id, SCPerfPrivateContext *pca,
-                                 uint64_t x)
+void SCPerfCounterSetUI64(ThreadVars *tv, uint16_t id, uint64_t x)
 {
+    SCPerfPrivateContext *pca = tv->perf_private_ctx;
+
     if (!pca) {
         SCLogDebug("counterarray is NULL");
         return;
@@ -1435,10 +1440,10 @@ static int SCPerfTestCntArraySize07()
     SCPerfRegisterCounter("t2", "c2", SC_PERF_TYPE_UINT64, NULL,
                           &tv.perf_public_ctx);
 
-    pca = SCPerfGetAllCountersArray(&tv.perf_public_ctx);
+    pca = tv.perf_private_ctx = SCPerfGetAllCountersArray(&tv.perf_public_ctx);
 
-    SCPerfCounterIncr(1, pca);
-    SCPerfCounterIncr(2, pca);
+    SCPerfCounterIncr(&tv, 1);
+    SCPerfCounterIncr(&tv, 2);
 
     result = pca->size;
 
@@ -1460,10 +1465,10 @@ static int SCPerfTestUpdateCounter08()
     id = SCPerfRegisterCounter("t1", "c1", SC_PERF_TYPE_UINT64, NULL,
                                &tv.perf_public_ctx);
 
-    pca = SCPerfGetAllCountersArray(&tv.perf_public_ctx);
+    pca = tv.perf_private_ctx = SCPerfGetAllCountersArray(&tv.perf_public_ctx);
 
-    SCPerfCounterIncr(id, pca);
-    SCPerfCounterAddUI64(id, pca, 100);
+    SCPerfCounterIncr(&tv, id);
+    SCPerfCounterAddUI64(&tv, id, 100);
 
     result = pca->head[id].ui64_cnt;
 
@@ -1493,10 +1498,10 @@ static int SCPerfTestUpdateCounter09()
     id2 = SCPerfRegisterCounter("t5", "c5", SC_PERF_TYPE_UINT64, NULL,
                                 &tv.perf_public_ctx);
 
-    pca = SCPerfGetAllCountersArray(&tv.perf_public_ctx);
+    pca = tv.perf_private_ctx = SCPerfGetAllCountersArray(&tv.perf_public_ctx);
 
-    SCPerfCounterIncr(id2, pca);
-    SCPerfCounterAddUI64(id2, pca, 100);
+    SCPerfCounterIncr(&tv, id2);
+    SCPerfCounterAddUI64(&tv, id2, 100);
 
     result = (pca->head[id1].ui64_cnt == 0) && (pca->head[id2].ui64_cnt == 101);
 
@@ -1523,12 +1528,12 @@ static int SCPerfTestUpdateGlobalCounter10()
     id3 = SCPerfRegisterCounter("t3", "c3", SC_PERF_TYPE_UINT64, NULL,
                                 &tv.perf_public_ctx);
 
-    pca = SCPerfGetAllCountersArray(&tv.perf_public_ctx);
+    pca = tv.perf_private_ctx = SCPerfGetAllCountersArray(&tv.perf_public_ctx);
 
-    SCPerfCounterIncr(id1, pca);
-    SCPerfCounterAddUI64(id2, pca, 100);
-    SCPerfCounterIncr(id3, pca);
-    SCPerfCounterAddUI64(id3, pca, 100);
+    SCPerfCounterIncr(&tv, id1);
+    SCPerfCounterAddUI64(&tv, id2, 100);
+    SCPerfCounterIncr(&tv, id3);
+    SCPerfCounterAddUI64(&tv, id3, 100);
 
     SCPerfUpdateCounterArray(pca, &tv.perf_public_ctx);
 
@@ -1561,12 +1566,12 @@ static int SCPerfTestCounterValues11()
     id4 = SCPerfRegisterCounter("t4", "c4", SC_PERF_TYPE_UINT64, NULL,
                                 &tv.perf_public_ctx);
 
-    pca = SCPerfGetAllCountersArray(&tv.perf_public_ctx);
+    pca = tv.perf_private_ctx = SCPerfGetAllCountersArray(&tv.perf_public_ctx);
 
-    SCPerfCounterIncr(id1, pca);
-    SCPerfCounterAddUI64(id2, pca, 256);
-    SCPerfCounterAddUI64(id3, pca, 257);
-    SCPerfCounterAddUI64(id4, pca, 16843024);
+    SCPerfCounterIncr(&tv, id1);
+    SCPerfCounterAddUI64(&tv, id2, 256);
+    SCPerfCounterAddUI64(&tv, id3, 257);
+    SCPerfCounterAddUI64(&tv, id4, 16843024);
 
     SCPerfUpdateCounterArray(pca, &tv.perf_public_ctx);
 

diff --git a/src/counters.h b/src/counters.h
index 3eff9ef6e63216de439d1b2c7339247c14602b16..8c0f6286849547a8a0d0f07b7b9dfdbd4bc0b7b1 100644 (file)
--- a/src/counters.h
+++ b/src/counters.h
@@ -171,13 +171,13 @@ void SCPerfReleaseResources(void);
 void SCPerfReleasePerfCounterS(SCPerfCounter *);
 void SCPerfReleasePCA(SCPerfPrivateContext *);
 
-void SCPerfCounterSetUI64(uint16_t, SCPerfPrivateContext *, uint64_t);
-void SCPerfCounterIncr(uint16_t, SCPerfPrivateContext *);
+void SCPerfCounterSetUI64(struct ThreadVars_ *, uint16_t, uint64_t);
+void SCPerfCounterIncr(struct ThreadVars_ *, uint16_t);
 
 void SCPerfRegisterTests(void);
 
 /* functions used to update local counter values */
-void SCPerfCounterAddUI64(uint16_t, SCPerfPrivateContext *, uint64_t);
+void SCPerfCounterAddUI64(struct ThreadVars_ *, uint16_t, uint64_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 32f737a7ddc571acb3fb3d702aaf7072c6dd6c69..d77b7ac3b32f7d225ad61ef88d21bb8173ae558f 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(dtv->counter_eth, tv->perf_private_ctx);
+    SCPerfCounterIncr(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 b686663d34cb200a5850b269841751c723cb8b20..42459446bd1452a0c802301d7cbfc19011968e4f 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(dtv->counter_gre, tv->perf_private_ctx);
+    SCPerfCounterIncr(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 a1926ec210cbb47636c64155e183a95549926531..af094e4259fe83844b62e1b753982962eefdb231 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(dtv->counter_icmpv4, tv->perf_private_ctx);
+    SCPerfCounterIncr(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 a56a0db6602a0b49394ea5c8e2885b3ce1a9c0fc..d9bc41db656969b5e473db44cc0ae1aa6b1d424f 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(dtv->counter_icmpv6, tv->perf_private_ctx);
+    SCPerfCounterIncr(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 03fd4782ab99ee5178446bb28f08b5e8b9ee1464..a0ca8c173ced1de930701717f029240e42fb5b53 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(dtv->counter_ipv4, tv->perf_private_ctx);
+    SCPerfCounterIncr(tv, dtv->counter_ipv4);
 
     SCLogDebug("pkt %p len %"PRIu16"", pkt, len);
 

diff --git a/src/decode-ipv6.c b/src/decode-ipv6.c
index bb2b40269c602bf6ae99e80ae84708c3f38d3d9a..12ba7705d90460a8d1fd2f840f415869a5f76028 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(dtv->counter_ipv4inipv6, tv->perf_private_ctx);
+                SCPerfCounterIncr(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(dtv->counter_ipv6inipv6, tv->perf_private_ctx);
+                SCPerfCounterIncr(tv, dtv->counter_ipv6inipv6);
             }
         }
     } else {
@@ -601,7 +601,7 @@ int DecodeIPV6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, u
 {
     int ret;
 
-    SCPerfCounterIncr(dtv->counter_ipv6, tv->perf_private_ctx);
+    SCPerfCounterIncr(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 e8ff0371e2d63f46da768387acf76381cbb6155b..f8a77b5831b85253856f1c11a0ebc34f42d11a7e 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(dtv->counter_mpls, tv->perf_private_ctx);
+    SCPerfCounterIncr(tv, dtv->counter_mpls);
 
     do {
         if (len < MPLS_HEADER_LEN) {

diff --git a/src/decode-null.c b/src/decode-null.c
index fa1738436aa9f01b1cf9aa2697ce9b5fff766727..445a33331c2e8e5cce0de47577d566acd4a63729 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(dtv->counter_null, tv->perf_private_ctx);
+    SCPerfCounterIncr(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 1f2c395924fc1f17cb3d79a161c5e716f124b767..d6ec902512c9625b274cd1af9f29a3b1f6602f35 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(dtv->counter_ppp, tv->perf_private_ctx);
+    SCPerfCounterIncr(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 1cec70076c3739fc067786ab9a800a01704d0b4e..565a9f5894cd9573f21b4a162e1817960ec77c83 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(dtv->counter_pppoe, tv->perf_private_ctx);
+    SCPerfCounterIncr(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(dtv->counter_pppoe, tv->perf_private_ctx);
+    SCPerfCounterIncr(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 06eaec39c78f991d0f24e80847f81770e5f04761..dc31c944cac5834fda603c9f6ea49feeb15e0b1b 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(dtv->counter_raw, tv->perf_private_ctx);
+    SCPerfCounterIncr(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 cc287e0d48dd35a6e1b8ed0ece8b3bc118ddaaed..25607421256be6410a243bb0787fec2195864e59 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(dtv->counter_sctp, tv->perf_private_ctx);
+    SCPerfCounterIncr(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 65c1c57db42aa361a91ef33b5ed3eb089267b1c5..0da071da9351f42bc6b3cbfd597c42af07d87c44 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(dtv->counter_sll, tv->perf_private_ctx);
+    SCPerfCounterIncr(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 206669e4dc4c8fb92d201be2e3cbbea59e2d5a5b..ae85df48d382b45998310cdc52a8fcb380013475 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(dtv->counter_tcp, tv->perf_private_ctx);
+    SCPerfCounterIncr(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 6c557a3d2d4e147b593823fe49e2e57fc0062923..ba8cd311b37bf658c656888563c999b50834dc95 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(dtv->counter_teredo, tv->perf_private_ctx);
+                    SCPerfCounterIncr(tv, dtv->counter_teredo);
                     return TM_ECODE_OK;
                 }
             }

diff --git a/src/decode-udp.c b/src/decode-udp.c
index dbbe8cae86d7ebf7de287004c616437c11ae58c2..a5be2a43125d27c43ac39c8e23c1287c45e464b5 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(dtv->counter_udp, tv->perf_private_ctx);
+    SCPerfCounterIncr(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 60b463c24d7274e6a92c6bdf7876afc328a80f9f..95eb3e6845d45f67a908c5fad3cabb3156d429c3 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(dtv->counter_vlan, tv->perf_private_ctx);
+        SCPerfCounterIncr(tv, dtv->counter_vlan);
     else if (p->vlan_idx == 1)
-        SCPerfCounterIncr(dtv->counter_vlan_qinq, tv->perf_private_ctx);
+        SCPerfCounterIncr(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 b4b48281422a8b10b4bb1977391eabe75c0cad98..f578994cdeeee2a966cc88387efee04fe21b39c7 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(dtv->counter_invalid, tv->perf_private_ctx);
+        SCPerfCounterIncr(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 b170afcfc92416e63c2604678661100b0419f37a..0d1ab333dc7c9821a41b7fe43ef2c8ed3c92a048 100644 (file)
--- a/src/defrag.c
+++ b/src/defrag.c
@@ -771,8 +771,7 @@ insert:
         if (tracker->af == AF_INET) {
             r = Defrag4Reassemble(tv, tracker, p);
             if (r != NULL && tv != NULL && dtv != NULL) {
-                SCPerfCounterIncr(dtv->counter_defrag_ipv4_reassembled,
-                    tv->perf_private_ctx);
+                SCPerfCounterIncr(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);
@@ -784,8 +783,7 @@ insert:
         else if (tracker->af == AF_INET6) {
             r = Defrag6Reassemble(tv, tracker, p);
             if (r != NULL && tv != NULL && dtv != NULL) {
-                SCPerfCounterIncr(dtv->counter_defrag_ipv6_reassembled,
-                        tv->perf_private_ctx);
+                SCPerfCounterIncr(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) {
@@ -925,12 +923,10 @@ Defrag(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, PacketQueue *pq)
 
     if (tv != NULL && dtv != NULL) {
         if (af == AF_INET) {
-            SCPerfCounterIncr(dtv->counter_defrag_ipv4_fragments,
-                tv->perf_private_ctx);
+            SCPerfCounterIncr(tv, dtv->counter_defrag_ipv4_fragments);
         }
         else if (af == AF_INET6) {
-            SCPerfCounterIncr(dtv->counter_defrag_ipv6_fragments,
-                tv->perf_private_ctx);
+            SCPerfCounterIncr(tv, dtv->counter_defrag_ipv6_fragments);
         }
     }
 

diff --git a/src/detect.c b/src/detect.c
index b55d4456dcb58624131390ca444688f74374a57a..bca51a25c92f2017e90e211c1a79099b0faec1e8 100644 (file)
--- a/src/detect.c
+++ b/src/detect.c
@@ -1437,13 +1437,13 @@ int SigMatchSignatures(ThreadVars *th_v, DetectEngineCtx *de_ctx, DetectEngineTh
     PACKET_PROFILING_DETECT_END(p, PROF_DETECT_MPM);
 #ifdef PROFILING
     if (th_v) {
-        SCPerfCounterAddUI64(det_ctx->counter_mpm_list, th_v->perf_private_ctx,
+        SCPerfCounterAddUI64(th_v, det_ctx->counter_mpm_list,
                              (uint64_t)det_ctx->pmq.rule_id_array_cnt);
-        SCPerfCounterAddUI64(det_ctx->counter_nonmpm_list, th_v->perf_private_ctx,
+        SCPerfCounterAddUI64(th_v, det_ctx->counter_nonmpm_list,
                              (uint64_t)det_ctx->sgh->non_mpm_store_cnt);
         /* non mpm sigs after mask prefilter */
-        SCPerfCounterAddUI64(det_ctx->counter_fnonmpm_list,
-                th_v->perf_private_ctx, (uint64_t)det_ctx->non_mpm_id_cnt);
+        SCPerfCounterAddUI64(th_v, det_ctx->counter_fnonmpm_list,
+                             (uint64_t)det_ctx->non_mpm_id_cnt);
     }
 #endif
 
@@ -1457,7 +1457,7 @@ int SigMatchSignatures(ThreadVars *th_v, DetectEngineCtx *de_ctx, DetectEngineTh
     SigIntId match_cnt = det_ctx->match_array_cnt;
 #ifdef PROFILING
     if (th_v) {
-        SCPerfCounterAddUI64(det_ctx->counter_match_list, th_v->perf_private_ctx,
+        SCPerfCounterAddUI64(th_v, det_ctx->counter_match_list,
                              (uint64_t)match_cnt);
     }
 #endif
@@ -1790,7 +1790,7 @@ end:
     PACKET_PROFILING_DETECT_START(p, PROF_DETECT_ALERT);
     PacketAlertFinalize(de_ctx, det_ctx, p);
     if (p->alerts.cnt > 0) {
-        SCPerfCounterAddUI64(det_ctx->counter_alerts, det_ctx->tv->perf_private_ctx, (uint64_t)p->alerts.cnt);
+        SCPerfCounterAddUI64(th_v, det_ctx->counter_alerts, (uint64_t)p->alerts.cnt);
     }
     PACKET_PROFILING_DETECT_END(p, PROF_DETECT_ALERT);
 

diff --git a/src/flow-manager.c b/src/flow-manager.c
index 2587c9fd2e79b854b148c3a51bfefc51b590d881..48dba4efbaec1e243e4594e8ba6c820d38e1b177 100644 (file)
--- a/src/flow-manager.c
+++ b/src/flow-manager.c
@@ -605,7 +605,7 @@ static TmEcode FlowManager(ThreadVars *th_v, void *thread_data)
 
                 SCLogDebug("Flow emergency mode entered...");
 
-                SCPerfCounterIncr(ftd->flow_emerg_mode_enter, th_v->perf_private_ctx);
+                SCPerfCounterIncr(th_v, ftd->flow_emerg_mode_enter);
             }
         }
 
@@ -635,24 +635,24 @@ static TmEcode FlowManager(ThreadVars *th_v, void *thread_data)
             IPPairTimeoutHash(&ts);
         }
 /*
-        SCPerfCounterAddUI64(flow_mgr_host_prune, th_v->perf_private_ctx, (uint64_t)hosts_pruned);
+        SCPerfCounterAddUI64(th_v, flow_mgr_host_prune, (uint64_t)hosts_pruned);
         uint32_t hosts_active = HostGetActiveCount();
-        SCPerfCounterSetUI64(flow_mgr_host_active, th_v->perf_private_ctx, (uint64_t)hosts_active);
+        SCPerfCounterSetUI64(th_v, flow_mgr_host_active, (uint64_t)hosts_active);
         uint32_t hosts_spare = HostGetSpareCount();
-        SCPerfCounterSetUI64(flow_mgr_host_spare, th_v->perf_private_ctx, (uint64_t)hosts_spare);
+        SCPerfCounterSetUI64(th_v, flow_mgr_host_spare, (uint64_t)hosts_spare);
 */
-        SCPerfCounterAddUI64(ftd->flow_mgr_cnt_clo, th_v->perf_private_ctx, (uint64_t)counters.clo);
-        SCPerfCounterAddUI64(ftd->flow_mgr_cnt_new, th_v->perf_private_ctx, (uint64_t)counters.new);
-        SCPerfCounterAddUI64(ftd->flow_mgr_cnt_est, th_v->perf_private_ctx, (uint64_t)counters.est);
+        SCPerfCounterAddUI64(th_v, ftd->flow_mgr_cnt_clo, (uint64_t)counters.clo);
+        SCPerfCounterAddUI64(th_v, ftd->flow_mgr_cnt_new, (uint64_t)counters.new);
+        SCPerfCounterAddUI64(th_v, ftd->flow_mgr_cnt_est, (uint64_t)counters.est);
         long long unsigned int flow_memuse = SC_ATOMIC_GET(flow_memuse);
-        SCPerfCounterSetUI64(ftd->flow_mgr_memuse, th_v->perf_private_ctx, (uint64_t)flow_memuse);
-        SCPerfCounterAddUI64(ftd->flow_tcp_reuse, th_v->perf_private_ctx, (uint64_t)counters.tcp_reuse);
+        SCPerfCounterSetUI64(th_v, ftd->flow_mgr_memuse, (uint64_t)flow_memuse);
+        SCPerfCounterAddUI64(th_v, ftd->flow_tcp_reuse, (uint64_t)counters.tcp_reuse);
 
         uint32_t len = 0;
         FQLOCK_LOCK(&flow_spare_q);
         len = flow_spare_q.len;
         FQLOCK_UNLOCK(&flow_spare_q);
-        SCPerfCounterSetUI64(ftd->flow_mgr_spare, th_v->perf_private_ctx, (uint64_t)len);
+        SCPerfCounterSetUI64(th_v, ftd->flow_mgr_spare, (uint64_t)len);
 
         /* Don't fear, FlowManagerThread is here...
          * clear emergency bit if we have at least xx flows pruned. */
@@ -676,7 +676,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(ftd->flow_emerg_mode_over, th_v->perf_private_ctx);
+                SCPerfCounterIncr(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 29d20df205980c0129f485656c9cc329b0359fc7..fa384fc345c695ad72f7e58004cc1742a51befd7 100644 (file)
--- a/src/source-af-packet.c
+++ b/src/source-af-packet.c
@@ -511,8 +511,8 @@ static inline void AFPDumpCounters(AFPThreadVars *ptv)
         SCLogDebug("(%s) Kernel: Packets %" PRIu32 ", dropped %" PRIu32 "",
                 ptv->tv->name,
                 kstats.tp_packets, kstats.tp_drops);
-        SCPerfCounterAddUI64(ptv->capture_kernel_packets, ptv->tv->perf_private_ctx, kstats.tp_packets);
-        SCPerfCounterAddUI64(ptv->capture_kernel_drops, ptv->tv->perf_private_ctx, kstats.tp_drops);
+        SCPerfCounterAddUI64(ptv->tv, ptv->capture_kernel_packets, kstats.tp_packets);
+        SCPerfCounterAddUI64(ptv->tv, ptv->capture_kernel_drops, kstats.tp_drops);
         (void) SC_ATOMIC_ADD(ptv->livedev->drop, (uint64_t) kstats.tp_drops);
         (void) SC_ATOMIC_ADD(ptv->livedev->pkts, (uint64_t) kstats.tp_packets);
     }
@@ -1856,22 +1856,22 @@ TmEcode DecodeAFP(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packet
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(dtv->counter_pkts, tv->perf_private_ctx);
-//    SCPerfCounterIncr(dtv->counter_pkts_per_sec, tv->perf_private_ctx);
+    SCPerfCounterIncr(tv, dtv->counter_pkts);
+//    SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
 
-    SCPerfCounterAddUI64(dtv->counter_bytes, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
 #if 0
     SCPerfCounterAddDouble(dtv->counter_bytes_per_sec, tv->perf_private_ctx, GET_PKT_LEN(p));
     SCPerfCounterAddDouble(dtv->counter_mbit_per_sec, tv->perf_private_ctx,
                            (GET_PKT_LEN(p) * 8)/1000000.0);
 #endif
 
-    SCPerfCounterAddUI64(dtv->counter_avg_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterSetUI64(dtv->counter_max_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(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(dtv->counter_vlan, tv->perf_private_ctx);
+        SCPerfCounterIncr(tv, dtv->counter_vlan);
     }
 
     /* call the decoder */

diff --git a/src/source-erf-dag.c b/src/source-erf-dag.c
index dbf6a79a5076148dd81c8e48af98df1544476b3b..b73f2fd6fa9d2bd5595a0a8c02f0801f6013de78 100644 (file)
--- a/src/source-erf-dag.c
+++ b/src/source-erf-dag.c
@@ -444,8 +444,7 @@ ProcessErfDagRecords(ErfDagThreadVars *ewtn, uint8_t *top, uint32_t *pkts_read)
             break;
         case TYPE_ETH:
             if (dr->lctr) {
-                SCPerfCounterAddUI64(ewtn->drops, ewtn->tv->perf_private_ctx,
-                    ntohs(dr->lctr));
+                SCPerfCounterAddUI64(tv, ewtn->drops, ntohs(dr->lctr));
             }
             break;
         default:
@@ -538,7 +537,7 @@ ProcessErfDagRecord(ErfDagThreadVars *ewtn, char *prec)
         p->ts.tv_sec++;
     }
 
-    SCPerfCounterIncr(ewtn->packets, ewtn->tv->perf_private_ctx);
+    SCPerfCounterIncr(tv, ewtn->packets);
     ewtn->bytes += wlen;
 
     if (TmThreadsSlotProcessPkt(ewtn->tv, ewtn->slot, p) != TM_ECODE_OK) {
@@ -624,20 +623,18 @@ DecodeErfDag(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(dtv->counter_pkts, tv->perf_private_ctx);
-//    SCPerfCounterIncr(dtv->counter_pkts_per_sec, tv->perf_private_ctx);
+    SCPerfCounterIncr(tv, dtv->counter_pkts);
+//    SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
 
-    SCPerfCounterAddUI64(dtv->counter_bytes, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
 #if 0
     SCPerfCounterAddDouble(dtv->counter_bytes_per_sec, tv->perf_private_ctx, GET_PKT_LEN(p));
     SCPerfCounterAddDouble(dtv->counter_mbit_per_sec, tv->perf_private_ctx,
                            (GET_PKT_LEN(p) * 8)/1000000.0);
 #endif
 
-    SCPerfCounterAddUI64(dtv->counter_avg_pkt_size, tv->perf_private_ctx,
-        GET_PKT_LEN(p));
-    SCPerfCounterSetUI64(dtv->counter_max_pkt_size, tv->perf_private_ctx,
-        GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
+    SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
 
         /* call the decoder */
     switch(p->datalink) {

diff --git a/src/source-erf-file.c b/src/source-erf-file.c
index 3bd23cd8ab0bbdf4befcf3b04e5a4dee4a827e0b..ff39bedc2d2fe7a6475fb56e4a39429c903f6f35 100644 (file)
--- a/src/source-erf-file.c
+++ b/src/source-erf-file.c
@@ -284,18 +284,18 @@ DecodeErfFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueu
         return TM_ECODE_OK;
 
     /* Update counters. */
-    SCPerfCounterIncr(dtv->counter_pkts, tv->perf_private_ctx);
-//    SCPerfCounterIncr(dtv->counter_pkts_per_sec, tv->perf_private_ctx);
+    SCPerfCounterIncr(tv, dtv->counter_pkts);
+//    SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
 
-    SCPerfCounterAddUI64(dtv->counter_bytes, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
 #if 0
     SCPerfCounterAddDouble(dtv->counter_bytes_per_sec, tv->perf_private_ctx, GET_PKT_LEN(p));
     SCPerfCounterAddDouble(dtv->counter_mbit_per_sec, tv->perf_private_ctx,
                            (GET_PKT_LEN(p) * 8)/1000000.0 );
 #endif
 
-    SCPerfCounterAddUI64(dtv->counter_avg_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterSetUI64(dtv->counter_max_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
+    SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
 
     DecodeEthernet(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
 

diff --git a/src/source-ipfw.c b/src/source-ipfw.c
index e1cc7aaff2b9da706529cae688dadd0f0c43f77a..8163d8387d8b1d19644b1a1408e40d533cb2179c 100644 (file)
--- a/src/source-ipfw.c
+++ b/src/source-ipfw.c
@@ -452,10 +452,10 @@ TmEcode DecodeIPFW(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packe
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(dtv->counter_pkts, tv->perf_private_ctx);
-    SCPerfCounterAddUI64(dtv->counter_bytes, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterAddUI64(dtv->counter_avg_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterSetUI64(dtv->counter_max_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterIncr(tv, dtv->counter_pkts);
+    SCPerfCounterAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
+    SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
 
     /* Process IP packets */
     if (IPV4_GET_RAW_VER(ip4h) == 4) {

diff --git a/src/source-mpipe.c b/src/source-mpipe.c
index 3444d2cdec6a6c0eb26c74546fd4d381a0194041..f55f4218465942254641705c76cabf463b0a4c79 100644 (file)
--- a/src/source-mpipe.c
+++ b/src/source-mpipe.c
@@ -382,8 +382,7 @@ TmEcode ReceiveMpipeLoop(ThreadVars *tv, void *data, void *slot)
                 __insn_prefetch(&idesc[i]);
             }
             if (unlikely(n > max_queued)) {
-                SCPerfCounterSetUI64(ptv->max_mpipe_depth,
-                                     tv->perf_private_ctx,
+                SCPerfCounterSetUI64(tv, ptv->max_mpipe_depth,
                                      (uint64_t)n);
                 max_queued = n;
             }
@@ -399,11 +398,10 @@ TmEcode ReceiveMpipeLoop(ThreadVars *tv, void *data, void *slot)
                     if (idesc->be) {
                         /* Buffer Error - No buffer available, so mPipe
                          * dropped the packet. */
-                        SCPerfCounterIncr(XlateStack(ptv, idesc->stack_idx),
-                                          tv->perf_private_ctx);
+                        SCPerfCounterIncr(tv, XlateStack(ptv, idesc->stack_idx));
                     } else {
                         /* Bad packet. CRC error */
-                        SCPerfCounterIncr(ptv->mpipe_drop, tv->perf_private_ctx);
+                        SCPerfCounterIncr(tv, ptv->mpipe_drop);
                         gxio_mpipe_iqueue_drop(iqueue, idesc);
                     }
                     gxio_mpipe_iqueue_release(iqueue, idesc);
@@ -1063,13 +1061,13 @@ TmEcode DecodeMpipe(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(dtv->counter_pkts, tv->perf_private_ctx);
-//    SCPerfCounterIncr(dtv->counter_pkts_per_sec, tv->perf_private_ctx);
+    SCPerfCounterIncr(tv, dtv->counter_pkts);
+//    SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
 
-    SCPerfCounterAddUI64(dtv->counter_bytes, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
 
-    SCPerfCounterAddUI64(dtv->counter_avg_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterSetUI64(dtv->counter_max_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
+    SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
 
     /* call the decoder */
     DecodeEthernet(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);

diff --git a/src/source-napatech.c b/src/source-napatech.c
index eda65a5fa8015f613eaeccd3b32b967a0788f040..f3430d07920998e9a11806742b731af5943e3f63 100644 (file)
--- a/src/source-napatech.c
+++ b/src/source-napatech.c
@@ -357,11 +357,11 @@ TmEcode NapatechDecode(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(dtv->counter_pkts, tv->perf_private_ctx);
-//    SCPerfCounterIncr(dtv->counter_pkts_per_sec, tv->perf_private_ctx);
-    SCPerfCounterAddUI64(dtv->counter_bytes, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterAddUI64(dtv->counter_avg_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterSetUI64(dtv->counter_max_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterIncr(tv, dtv->counter_pkts);
+//    SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    SCPerfCounterAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
+    SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
 
     switch (p->datalink) {
         case LINKTYPE_ETHERNET:

diff --git a/src/source-netmap.c b/src/source-netmap.c
index 3c41f2a2cb84b2ea86b6ca5b7d9519080bdd0a27..1b6b3329888a4c04b94d80bbb5d4036f8adc8f82 100644 (file)
--- a/src/source-netmap.c
+++ b/src/source-netmap.c
@@ -483,8 +483,8 @@ static int NetmapClose(NetmapDevice *dev)
  */
 static inline void NetmapDumpCounters(NetmapThreadVars *ntv)
 {
-    SCPerfCounterAddUI64(ntv->capture_kernel_packets, ntv->tv->perf_private_ctx, ntv->pkts);
-    SCPerfCounterAddUI64(ntv->capture_kernel_drops, ntv->tv->perf_private_ctx, ntv->drops);
+    SCPerfCounterAddUI64(ntv->tv, ntv->capture_kernel_packets, ntv->pkts);
+    SCPerfCounterAddUI64(ntv->tv, ntv->capture_kernel_drops, ntv->drops);
     (void) SC_ATOMIC_ADD(ntv->livedev->drop, ntv->drops);
     (void) SC_ATOMIC_ADD(ntv->livedev->pkts, ntv->pkts);
     ntv->drops = 0;
@@ -934,10 +934,10 @@ static TmEcode DecodeNetmap(ThreadVars *tv, Packet *p, void *data, PacketQueue *
         SCReturnInt(TM_ECODE_OK);
 
     /* update counters */
-    SCPerfCounterIncr(dtv->counter_pkts, tv->perf_private_ctx);
-    SCPerfCounterAddUI64(dtv->counter_bytes, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterAddUI64(dtv->counter_avg_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterSetUI64(dtv->counter_max_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterIncr(tv, dtv->counter_pkts);
+    SCPerfCounterAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
+    SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
 
     DecodeEthernet(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
 

diff --git a/src/source-nflog.c b/src/source-nflog.c
index f04fb5abadd764dfa5c061c9aea7db95a82ba01c..d068acbb9dffa5631ee9abcfe655a9d863501b2d 100644 (file)
--- a/src/source-nflog.c
+++ b/src/source-nflog.c
@@ -503,10 +503,10 @@ TmEcode DecodeNFLOG(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Pack
     IPV6Hdr *ip6h = (IPV6Hdr *)GET_PKT_DATA(p);
     DecodeThreadVars *dtv = (DecodeThreadVars *)data;
 
-    SCPerfCounterIncr(dtv->counter_pkts, tv->perf_private_ctx);
-    SCPerfCounterAddUI64(dtv->counter_bytes, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterAddUI64(dtv->counter_avg_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterSetUI64(dtv->counter_max_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterIncr(tv, dtv->counter_pkts);
+    SCPerfCounterAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
+    SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
 
     if (IPV4_GET_RAW_VER(ip4h) == 4) {
         SCLogDebug("IPv4 packet");

diff --git a/src/source-nfq.c b/src/source-nfq.c
index b1c6852de1f2c621014f14f496d885c266d7c0ed..12123b7752a740ea51c57e09f1703a6d0279cce1 100644 (file)
--- a/src/source-nfq.c
+++ b/src/source-nfq.c
@@ -1223,10 +1223,10 @@ TmEcode DecodeNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packet
     if (p->flags & PKT_PSEUDO_STREAM_END)
         return TM_ECODE_OK;
 
-    SCPerfCounterIncr(dtv->counter_pkts, tv->perf_private_ctx);
-    SCPerfCounterAddUI64(dtv->counter_bytes, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterAddUI64(dtv->counter_avg_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterSetUI64(dtv->counter_max_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterIncr(tv, dtv->counter_pkts);
+    SCPerfCounterAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
+    SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
 #if 0
     SCPerfCounterAddDouble(dtv->counter_bytes_per_sec, tv->perf_private_ctx, GET_PKT_LEN(p));
     SCPerfCounterAddDouble(dtv->counter_mbit_per_sec, tv->perf_private_ctx,

diff --git a/src/source-pcap-file.c b/src/source-pcap-file.c
index 453d9cc07cb9cc34ae4319f38026b195ba4b0ab4..a1b1d04d4433388f0c07b87137aab486527108a2 100644 (file)
--- a/src/source-pcap-file.c
+++ b/src/source-pcap-file.c
@@ -401,17 +401,17 @@ TmEcode DecodePcapFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, P
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(dtv->counter_pkts, tv->perf_private_ctx);
-//    SCPerfCounterIncr(dtv->counter_pkts_per_sec, tv->perf_private_ctx);
+    SCPerfCounterIncr(tv, dtv->counter_pkts);
+//    SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
 
-    SCPerfCounterAddUI64(dtv->counter_bytes, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
 #if 0
     SCPerfCounterAddDouble(dtv->counter_bytes_per_sec, tv->perf_private_ctx, GET_PKT_LEN(p));
     SCPerfCounterAddDouble(dtv->counter_mbit_per_sec, tv->perf_private_ctx,
                            (GET_PKT_LEN(p) * 8)/1000000.0 );
 #endif
-    SCPerfCounterAddUI64(dtv->counter_avg_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterSetUI64(dtv->counter_max_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
+    SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
 
     double curr_ts = p->ts.tv_sec + p->ts.tv_usec / 1000.0;
     if (curr_ts < prev_signaled_ts || (curr_ts - prev_signaled_ts) > 60.0) {

diff --git a/src/source-pcap.c b/src/source-pcap.c
index 6e53b1b45d4a25cc563699e971699fc898ba2a90..138db8496fbc701266355a2e0d9a0784c361efe5 100644 (file)
--- a/src/source-pcap.c
+++ b/src/source-pcap.c
@@ -155,10 +155,10 @@ static inline void PcapDumpCounters(PcapThreadVars *ptv)
 {
     struct pcap_stat pcap_s;
     if (likely((pcap_stats(ptv->pcap_handle, &pcap_s) >= 0))) {
-        SCPerfCounterSetUI64(ptv->capture_kernel_packets, ptv->tv->perf_private_ctx, pcap_s.ps_recv);
-        SCPerfCounterSetUI64(ptv->capture_kernel_drops, ptv->tv->perf_private_ctx, pcap_s.ps_drop);
+        SCPerfCounterSetUI64(ptv->tv, ptv->capture_kernel_packets, pcap_s.ps_recv);
+        SCPerfCounterSetUI64(ptv->tv, ptv->capture_kernel_drops, pcap_s.ps_drop);
         (void) SC_ATOMIC_SET(ptv->livedev->drop, pcap_s.ps_drop);
-        SCPerfCounterSetUI64(ptv->capture_kernel_ifdrops, ptv->tv->perf_private_ctx, pcap_s.ps_ifdrop);
+        SCPerfCounterSetUI64(ptv->tv, ptv->capture_kernel_ifdrops, pcap_s.ps_ifdrop);
     }
 }
 
@@ -716,18 +716,18 @@ TmEcode DecodePcap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packe
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(dtv->counter_pkts, tv->perf_private_ctx);
-//    SCPerfCounterIncr(dtv->counter_pkts_per_sec, tv->perf_private_ctx);
+    SCPerfCounterIncr(tv, dtv->counter_pkts);
+//    SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
 
-    SCPerfCounterAddUI64(dtv->counter_bytes, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
 #if 0
     SCPerfCounterAddDouble(dtv->counter_bytes_per_sec, tv->perf_private_ctx, GET_PKT_LEN(p));
     SCPerfCounterAddDouble(dtv->counter_mbit_per_sec, tv->perf_private_ctx,
                            (GET_PKT_LEN(p) * 8)/1000000.0);
 #endif
 
-    SCPerfCounterAddUI64(dtv->counter_avg_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterSetUI64(dtv->counter_max_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
+    SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
 
     /* call the decoder */
     switch(p->datalink) {

diff --git a/src/source-pfring.c b/src/source-pfring.c
index eb4df877abe0c94ddf0f399e054266734d79eb39..5708ddd8dad71aeaf816219329080b5bfff48419 100644 (file)
--- a/src/source-pfring.c
+++ b/src/source-pfring.c
@@ -204,8 +204,8 @@ static inline void PfringDumpCounters(PfringThreadVars *ptv)
                                                        ptv->tv->perf_private_ctx);
         SC_ATOMIC_ADD(ptv->livedev->pkts, pfring_s.recv - th_pkts);
         SC_ATOMIC_ADD(ptv->livedev->drop, pfring_s.drop - th_drops);
-        SCPerfCounterSetUI64(ptv->capture_kernel_packets, ptv->tv->perf_private_ctx, pfring_s.recv);
-        SCPerfCounterSetUI64(ptv->capture_kernel_drops, ptv->tv->perf_private_ctx, pfring_s.drop);
+        SCPerfCounterSetUI64(ptv->tv, ptv->capture_kernel_packets, pfring_s.recv);
+        SCPerfCounterSetUI64(ptv->tv, ptv->capture_kernel_drops, pfring_s.drop);
     }
 }
 
@@ -608,22 +608,22 @@ TmEcode DecodePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Pac
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(dtv->counter_pkts, tv->perf_private_ctx);
-//    SCPerfCounterIncr(dtv->counter_pkts_per_sec, tv->perf_private_ctx);
+    SCPerfCounterIncr(tv, dtv->counter_pkts);
+//    SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
 
-    SCPerfCounterAddUI64(dtv->counter_bytes, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
 #if 0
     SCPerfCounterAddDouble(dtv->counter_bytes_per_sec, tv->perf_private_ctx, GET_PKT_LEN(p));
     SCPerfCounterAddDouble(dtv->counter_mbit_per_sec, tv->perf_private_ctx,
                            (GET_PKT_LEN(p) * 8)/1000000.0 );
 #endif
 
-    SCPerfCounterAddUI64(dtv->counter_avg_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
-    SCPerfCounterSetUI64(dtv->counter_max_pkt_size, tv->perf_private_ctx, GET_PKT_LEN(p));
+    SCPerfCounterAddUI64(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(dtv->counter_vlan, tv->perf_private_ctx);
+        SCPerfCounterIncr(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 9bbf331abe568c8f3e767f8afcee70c71b88857e..20074e6807c7cf5c52864d129ada1e48b09f2f96 100644 (file)
--- a/src/stream-tcp-reassemble.c
+++ b/src/stream-tcp-reassemble.c
@@ -139,7 +139,7 @@ void StreamTcpReassembleMemuseCounter(ThreadVars *tv, TcpReassemblyThreadCtx *rt
 {
     uint64_t smemuse = SC_ATOMIC_GET(ra_memuse);
     if (tv != NULL && rtv != NULL)
-        SCPerfCounterSetUI64(rtv->counter_tcp_reass_memuse, tv->perf_private_ctx, smemuse);
+        SCPerfCounterSetUI64(tv, rtv->counter_tcp_reass_memuse, smemuse);
     return;
 }
 
@@ -1905,7 +1905,7 @@ int StreamTcpReassembleHandleSegmentHandleData(ThreadVars *tv, TcpReassemblyThre
 
     if (stream->flags & STREAMTCP_STREAM_FLAG_DEPTH_REACHED) {
         /* increment stream depth counter */
-        SCPerfCounterIncr(ra_ctx->counter_tcp_stream_depth, tv->perf_private_ctx);
+        SCPerfCounterIncr(tv, ra_ctx->counter_tcp_stream_depth);
 
         stream->flags |= STREAMTCP_STREAM_FLAG_NOREASSEMBLY;
         SCLogDebug("ssn %p: reassembly depth reached, "
@@ -2606,7 +2606,7 @@ int DoHandleGap(ThreadVars *tv, TcpReassemblyThreadCtx *ra_ctx,
         stream->flags |= STREAMTCP_STREAM_FLAG_GAP;
 
         StreamTcpSetEvent(p, STREAM_REASSEMBLY_SEQ_GAP);
-        SCPerfCounterIncr(ra_ctx->counter_tcp_reass_gap, tv->perf_private_ctx);
+        SCPerfCounterIncr(tv, ra_ctx->counter_tcp_reass_gap);
 #ifdef DEBUG
         dbg_app_layer_gap++;
 #endif
@@ -2952,7 +2952,7 @@ int StreamTcpReassembleAppLayer (ThreadVars *tv, TcpReassemblyThreadCtx *ra_ctx,
             stream->flags |= STREAMTCP_STREAM_FLAG_GAP;
 
             StreamTcpSetEvent(p, STREAM_REASSEMBLY_SEQ_GAP);
-            SCPerfCounterIncr(ra_ctx->counter_tcp_reass_gap, tv->perf_private_ctx);
+            SCPerfCounterIncr(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(ra_ctx->counter_tcp_segment_memcap, tv->perf_private_ctx);
+        SCPerfCounterIncr(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 c48d856da7e1870c05a606b7f2889b3528066693..c7d1098ed12cc5420ea715733f672f87b6d77849 100644 (file)
--- a/src/stream-tcp.c
+++ b/src/stream-tcp.c
@@ -147,7 +147,7 @@ void StreamTcpDecrMemuse(uint64_t size)
 void StreamTcpMemuseCounter(ThreadVars *tv, StreamTcpThread *stt)
 {
     uint64_t memusecopy = SC_ATOMIC_GET(st_memuse);
-    SCPerfCounterSetUI64(stt->counter_tcp_memuse, tv->perf_private_ctx, memusecopy);
+    SCPerfCounterSetUI64(tv, stt->counter_tcp_memuse, memusecopy);
     return;
 }
 
@@ -843,10 +843,10 @@ static int StreamTcpPacketStateNone(ThreadVars *tv, Packet *p,
         if (ssn == NULL) {
             ssn = StreamTcpNewSession(p, stt->ssn_pool_id);
             if (ssn == NULL) {
-                SCPerfCounterIncr(stt->counter_tcp_ssn_memcap, tv->perf_private_ctx);
+                SCPerfCounterIncr(tv, stt->counter_tcp_ssn_memcap);
                 return -1;
             }
-            SCPerfCounterIncr(stt->counter_tcp_sessions, tv->perf_private_ctx);
+            SCPerfCounterIncr(tv, stt->counter_tcp_sessions);
         }
         /* set the state */
         StreamTcpPacketSetState(p, ssn, TCP_SYN_RECV);
@@ -924,11 +924,11 @@ static int StreamTcpPacketStateNone(ThreadVars *tv, Packet *p,
         if (ssn == NULL) {
             ssn = StreamTcpNewSession(p, stt->ssn_pool_id);
             if (ssn == NULL) {
-                SCPerfCounterIncr(stt->counter_tcp_ssn_memcap, tv->perf_private_ctx);
+                SCPerfCounterIncr(tv, stt->counter_tcp_ssn_memcap);
                 return -1;
             }
 
-            SCPerfCounterIncr(stt->counter_tcp_sessions, tv->perf_private_ctx);
+            SCPerfCounterIncr(tv, stt->counter_tcp_sessions);
         }
 
         /* set the state */
@@ -977,10 +977,10 @@ static int StreamTcpPacketStateNone(ThreadVars *tv, Packet *p,
         if (ssn == NULL) {
             ssn = StreamTcpNewSession(p, stt->ssn_pool_id);
             if (ssn == NULL) {
-                SCPerfCounterIncr(stt->counter_tcp_ssn_memcap, tv->perf_private_ctx);
+                SCPerfCounterIncr(tv, stt->counter_tcp_ssn_memcap);
                 return -1;
             }
-            SCPerfCounterIncr(stt->counter_tcp_sessions, tv->perf_private_ctx);
+            SCPerfCounterIncr(tv, stt->counter_tcp_sessions);
         }
         /* set the state */
         StreamTcpPacketSetState(p, ssn, TCP_ESTABLISHED);
@@ -4460,12 +4460,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(stt->counter_tcp_synack, tv->perf_private_ctx);
+        SCPerfCounterIncr(tv, stt->counter_tcp_synack);
     } else if (p->tcph->th_flags & (TH_SYN)) {
-        SCPerfCounterIncr(stt->counter_tcp_syn, tv->perf_private_ctx);
+        SCPerfCounterIncr(tv, stt->counter_tcp_syn);
     }
     if (p->tcph->th_flags & (TH_RST)) {
-        SCPerfCounterIncr(stt->counter_tcp_rst, tv->perf_private_ctx);
+        SCPerfCounterIncr(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 */
@@ -5019,13 +5019,13 @@ TmEcode StreamTcp (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packe
         return TM_ECODE_OK;
 
     if (p->flow == NULL) {
-        SCPerfCounterIncr(stt->counter_tcp_no_flow, tv->perf_private_ctx);
+        SCPerfCounterIncr(tv, stt->counter_tcp_no_flow);
         return TM_ECODE_OK;
     }
 
     if (stream_config.flags & STREAMTCP_INIT_FLAG_CHECKSUM_VALIDATION) {
         if (StreamTcpValidateChecksum(p) == 0) {
-            SCPerfCounterIncr(stt->counter_tcp_invalid_checksum, tv->perf_private_ctx);
+            SCPerfCounterIncr(tv, stt->counter_tcp_invalid_checksum);
             return TM_ECODE_OK;
         }
     } else {
@@ -5896,7 +5896,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(stt->counter_tcp_pseudo_failed, tv->perf_private_ctx);
+        SCPerfCounterIncr(tv, stt->counter_tcp_pseudo_failed);
         SCReturn;
     }
     PKT_SET_SRC(np, PKT_SRC_STREAM_TCP_STREAM_END_PSEUDO);
@@ -5931,7 +5931,7 @@ void StreamTcpPseudoPacketCreateStreamEndPacket(ThreadVars *tv, StreamTcpThread
 
     PacketEnqueue(pq, np);
 
-    SCPerfCounterIncr(stt->counter_tcp_pseudo, tv->perf_private_ctx);
+    SCPerfCounterIncr(tv, stt->counter_tcp_pseudo);
     SCReturn;
 }