Add stream engine counters

Added stream counters:
- tcp.reassembly_memuse -- current memory use by reassembly in bytes
- tcp.memuse -- current memory use by stream tracking in bytes
- tcp.reused_ssn -- ssn reused by new session with identical tuple
- tcp.no_flow -- TCP packets with no flow - indicating flow engine memory at its limits

src/stream-tcp-reassemble.c

@@ -147,6 +147,11 @@ void StreamTcpReassembleDecrMemuse(uint64_t size) {
     SCSpinUnlock(&stream_reassembly_memuse_spinlock);
 }
 
+void StreamTcpReassembleMemuseCounter(ThreadVars *tv, TcpReassemblyThreadCtx *rtv) {
+    SCSpinLock(&stream_reassembly_memuse_spinlock);
+    SCPerfCounterSetUI64(rtv->counter_tcp_reass_memuse, tv->sc_perf_pca, stream_reassembly_memuse);
+    SCSpinUnlock(&stream_reassembly_memuse_spinlock);
+}
 
 /**
  * \brief  Function to Check the reassembly memory usage counter against the
@@ -3526,6 +3531,7 @@ int StreamTcpReassembleHandleSegment(ThreadVars *tv, TcpReassemblyThreadCtx *ra_
         }
     }
 
+    StreamTcpReassembleMemuseCounter(tv, ra_ctx);
     SCReturnInt(0);
 }
 

src/stream-tcp-reassemble.h

@@ -58,6 +58,8 @@ typedef struct TcpReassemblyThreadCtx_ {
     uint16_t counter_tcp_segment_memcap;
     /** number of streams that stop reassembly because their depth is reached */
     uint16_t counter_tcp_stream_depth;
+    /** ams that stop reassembly because their depth is reached */
+    uint16_t counter_tcp_reass_memuse;
 } TcpReassemblyThreadCtx;
 
 #define OS_POLICY_DEFAULT   OS_POLICY_BSD

src/stream-tcp.c

@@ -143,6 +143,12 @@ void StreamTcpDecrMemuse(uint64_t size) {
     SCSpinUnlock(&stream_memuse_spinlock);
 }
 
+void StreamTcpMemuseCounter(ThreadVars *tv, StreamTcpThread *stt) {
+    SCSpinLock(&stream_memuse_spinlock);
+    SCPerfCounterSetUI64(stt->counter_tcp_memuse, tv->sc_perf_pca, stream_memuse);
+    SCSpinUnlock(&stream_memuse_spinlock);
+}
+
 /**
  *  \brief Check if alloc'ing "size" would mean we're over memcap
  *
@@ -3604,6 +3610,8 @@ static int StreamTcpPacket (ThreadVars *tv, Packet *p, StreamTcpThread *stt,
                     if (StreamTcpPacketStateNone(tv,p,stt,ssn, &stt->pseudo_queue)) {
                         goto error;
                     }
+
+                    SCPerfCounterIncr(stt->counter_tcp_reused_ssn, tv->sc_perf_pca);
                 } else {
                     SCLogDebug("packet received on closed state");
                 }
@@ -3674,6 +3682,7 @@ static int StreamTcpPacket (ThreadVars *tv, Packet *p, StreamTcpThread *stt,
         }
     }
 
+    StreamTcpMemuseCounter(tv, stt);
     SCReturnInt(0);
 
 error:
@@ -3738,8 +3747,10 @@ TmEcode StreamTcp (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packe
     if (!(PKT_IS_TCP(p)))
         return TM_ECODE_OK;
 
-    if (p->flow == NULL)
+    if (p->flow == NULL) {
+        SCPerfCounterIncr(stt->counter_tcp_no_flow, tv->sc_perf_pca);
         return TM_ECODE_OK;
+    }
 
     if ((stream_config.flags & STREAMTCP_INIT_FLAG_CHECKSUM_VALIDATION) &&
             (StreamTcpValidateChecksum(p) == 0))
@@ -3783,6 +3794,15 @@ TmEcode StreamTcpThreadInit(ThreadVars *tv, void *initdata, void **data)
     stt->counter_tcp_invalid_checksum = SCPerfTVRegisterCounter("tcp.invalid_checksum", tv,
                                                         SC_PERF_TYPE_UINT64,
                                                         "NULL");
+    stt->counter_tcp_no_flow = SCPerfTVRegisterCounter("tcp.no_flow", tv,
+                                                        SC_PERF_TYPE_UINT64,
+                                                        "NULL");
+    stt->counter_tcp_reused_ssn = SCPerfTVRegisterCounter("tcp.reused_ssn", tv,
+                                                        SC_PERF_TYPE_UINT64,
+                                                        "NULL");
+    stt->counter_tcp_memuse = SCPerfTVRegisterCounter("tcp.memuse", tv,
+                                                        SC_PERF_TYPE_Q_NORMAL,
+                                                        "NULL");
 
     /* init reassembly ctx */
     stt->ra_ctx = StreamTcpReassembleInitThreadCtx();
@@ -3795,6 +3815,9 @@ TmEcode StreamTcpThreadInit(ThreadVars *tv, void *initdata, void **data)
     stt->ra_ctx->counter_tcp_stream_depth = SCPerfTVRegisterCounter("tcp.stream_depth_reached", tv,
                                                         SC_PERF_TYPE_UINT64,
                                                         "NULL");
+    stt->ra_ctx->counter_tcp_reass_memuse = SCPerfTVRegisterCounter("tcp.reassembly_memuse", tv,
+                                                        SC_PERF_TYPE_Q_NORMAL,
+                                                        "NULL");
 
     tv->sc_perf_pca = SCPerfGetAllCountersArray(&tv->sc_perf_pctx);
     SCPerfAddToClubbedTMTable(tv->name, &tv->sc_perf_pctx);

src/stream-tcp.h

@@ -80,6 +80,12 @@ typedef struct StreamTcpThread_ {
     uint16_t counter_tcp_pseudo;
     /** packets rejected because their csum is invalid */
     uint16_t counter_tcp_invalid_checksum;
+    /** TCP packets with no associated flow */
+    uint16_t counter_tcp_no_flow;
+    /** sessions reused */
+    uint16_t counter_tcp_reused_ssn;
+    /** sessions reused */
+    uint16_t counter_tcp_memuse;
 
     /** tcp reassembly thread data */
     TcpReassemblyThreadCtx *ra_ctx;