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

Merge 996996b544 into 9a37bb659b

Browse Source
pull/16041/merge
Eliska Cervinkova 1 day ago committed by GitHub
parent 9a37bb659b 996996b544
commit 1221638b07
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
10 changed files with 83 additions and 16 deletions
Show Stats Download Patch File Download Diff File

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

@ -1176,8 +1176,10 @@ void AppLayerRegisterGlobalCounters(void)
StatsRegisterGlobalCounter("http.byterange.memcap", HTPByteRangeMemcapGlobalCounter);
StatsRegisterGlobalCounter("ippair.memuse", IPPairGetMemuse);
StatsRegisterGlobalCounter("ippair.memcap", IPPairGetMemcap);
StatsRegisterGlobalCounter("ippair.active", IPPairGetActive);
StatsRegisterGlobalCounter("host.memuse", HostGetMemuse);
StatsRegisterGlobalCounter("host.memcap", HostGetMemcap);
StatsRegisterGlobalCounter("host.active", HostGetActive);
}
static bool IsAppLayerErrorExceptionPolicyStatsValid(enum ExceptionPolicy policy)

27
src/defrag-hash.c
Unescape Escape View File

@ -31,7 +31,8 @@
DefragTrackerHashRow *defragtracker_hash;
DefragConfig defrag_config;
SC_ATOMIC_DECLARE(uint64_t,defrag_memuse);
SC_ATOMIC_DECLARE(unsigned int,defragtracker_counter);
SC_ATOMIC_DECLARE(uint64_t, defrag_tracker_active);
SC_ATOMIC_DECLARE(uint64_t, defrag_max_fragments);
SC_ATOMIC_DECLARE(unsigned int,defragtracker_prune_idx);
static DefragTracker *DefragTrackerGetUsedDefragTracker(
@ -77,6 +78,18 @@ uint64_t DefragTrackerGetMemuse(void)
return memusecopy;
}
uint64_t DefragTrackerGetActive(void)
{
uint64_t defragtracker_activecopy = SC_ATOMIC_GET(defrag_tracker_active);
return defragtracker_activecopy;
}
uint64_t DefragTrackerGetMaxFragments(void)
{
uint64_t defrag_max_fragmentscopy = SC_ATOMIC_GET(defrag_max_fragments);
return defrag_max_fragmentscopy;
}
enum ExceptionPolicy DefragGetMemcapExceptionPolicy(void)
{
return defrag_config.memcap_policy;
@ -85,7 +98,7 @@ enum ExceptionPolicy DefragGetMemcapExceptionPolicy(void)
void DefragTrackerMoveToSpare(DefragTracker *h)
{
DefragTrackerEnqueue(&defragtracker_spare_q, h);
(void) SC_ATOMIC_SUB(defragtracker_counter, 1);
(void)SC_ATOMIC_SUB(defrag_tracker_active, 1);
}
static DefragTracker *DefragTrackerAlloc(void)
@ -169,7 +182,10 @@ void DefragInitConfig(bool quiet)
SCLogDebug("initializing defrag engine...");
memset(&defrag_config, 0, sizeof(defrag_config));
SC_ATOMIC_INIT(defragtracker_counter);
SC_ATOMIC_INIT(defrag_tracker_active);
SC_ATOMIC_SET(defrag_tracker_active, 0);
SC_ATOMIC_INIT(defrag_max_fragments);
SC_ATOMIC_SET(defrag_max_fragments, 0);
SC_ATOMIC_INIT(defrag_memuse);
SC_ATOMIC_INIT(defragtracker_prune_idx);
SC_ATOMIC_INIT(defrag_config.memcap);
@ -283,6 +299,9 @@ void DefragInitConfig(bool quiet)
SCLogConfig("defrag memory usage: %"PRIu64" bytes, maximum: %"PRIu64,
SC_ATOMIC_GET(defrag_memuse), SC_ATOMIC_GET(defrag_config.memcap));
}
StatsRegisterGlobalCounter("defrag.tracker_active", DefragTrackerGetActive);
StatsRegisterGlobalCounter("defrag.max_fragments", DefragTrackerGetMaxFragments);
}
/** \brief shutdown the flow engine
@ -511,7 +530,7 @@ static DefragTracker *DefragTrackerGetNew(ThreadVars *tv, DecodeThreadVars *dtv,
/* tracker is initialized (recycled) but *unlocked* */
}
(void) SC_ATOMIC_ADD(defragtracker_counter, 1);
(void)SC_ATOMIC_ADD(defrag_tracker_active, 1);
SCMutexLock(&dt->lock);
return dt;
}

5
src/defrag-hash.h
Unescape Escape View File

@ -85,7 +85,8 @@ typedef struct DefragConfig_ {
extern DefragConfig defrag_config;
SC_ATOMIC_EXTERN(uint64_t,defrag_memuse);
SC_ATOMIC_EXTERN(unsigned int,defragtracker_counter);
SC_ATOMIC_EXTERN(uint64_t, defrag_tracker_active);
SC_ATOMIC_EXTERN(uint64_t, defrag_max_fragments);
SC_ATOMIC_EXTERN(unsigned int,defragtracker_prune_idx);
void DefragInitConfig(bool quiet);
@ -100,6 +101,8 @@ void DefragTrackerMoveToSpare(DefragTracker *);
int DefragTrackerSetMemcap(uint64_t);
uint64_t DefragTrackerGetMemcap(void);
uint64_t DefragTrackerGetMemuse(void);
uint64_t DefragTrackerGetActive(void);
uint64_t DefragTrackerGetMaxFragments(void);
enum ExceptionPolicy DefragGetMemcapExceptionPolicy(void);
#endif /* SURICATA_DEFRAG_HASH_H */

7
src/defrag.c
Unescape Escape View File

@ -118,7 +118,7 @@ void
DefragTrackerFreeFrags(DefragTracker *tracker)
{
Frag *frag, *tmp;
uint64_t frag_count = 0;
/* Lock the frag pool as we'll be return items to it. */
SCMutexLock(&defrag_context->frag_pool_lock);
@ -126,6 +126,11 @@ DefragTrackerFreeFrags(DefragTracker *tracker)
RB_REMOVE(IP_FRAGMENTS, &tracker->fragment_tree, frag);
DefragFragReset(frag);
PoolReturn(defrag_context->frag_pool, frag);
frag_count++;
}
if (frag_count > (uint64_t)SC_ATOMIC_GET(defrag_max_fragments)) {
SC_ATOMIC_SET(defrag_max_fragments, frag_count);
}
SCMutexUnlock(&defrag_context->frag_pool_lock);

15
src/host.c
Unescape Escape View File

@ -53,7 +53,7 @@ static HostQueue host_spare_q;
HostConfig host_config;
SC_ATOMIC_DECLARE(uint64_t,host_memuse);
SC_ATOMIC_DECLARE(uint32_t,host_counter);
SC_ATOMIC_DECLARE(uint64_t, host_active);
SC_ATOMIC_DECLARE(uint32_t,host_prune_idx);
/** size of the host object. Maybe updated in HostInitConfig to include
@ -97,10 +97,16 @@ uint64_t HostGetMemuse(void)
return memuse;
}
uint64_t HostGetActive(void)
{
uint64_t host_activecopy = SC_ATOMIC_GET(host_active);
return host_activecopy;
}
void HostMoveToSpare(Host *h)
{
HostEnqueue(&host_spare_q, h);
(void) SC_ATOMIC_SUB(host_counter, 1);
(void)SC_ATOMIC_SUB(host_active, 1);
}
Host *HostAlloc(void)
@ -175,7 +181,8 @@ void HostInitConfig(bool quiet)
memset(&host_config, 0, sizeof(host_config));
//SC_ATOMIC_INIT(flow_flags);
SC_ATOMIC_INIT(host_counter);
SC_ATOMIC_INIT(host_active);
SC_ATOMIC_SET(host_active, 0);
SC_ATOMIC_INIT(host_memuse);
SC_ATOMIC_INIT(host_prune_idx);
SC_ATOMIC_INIT(host_config.memcap);
@ -447,7 +454,7 @@ static Host *HostGetNew(Address *a)
/* host is initialized (recycled) but *unlocked* */
}
(void) SC_ATOMIC_ADD(host_counter, 1);
(void)SC_ATOMIC_ADD(host_active, 1);
SCMutexLock(&h->m);
return h;
}

3
src/host.h
Unescape Escape View File

@ -130,7 +130,7 @@ typedef struct HostConfig_ {
extern HostConfig host_config;
SC_ATOMIC_EXTERN(uint64_t,host_memuse);
SC_ATOMIC_EXTERN(uint32_t,host_counter);
SC_ATOMIC_EXTERN(uint64_t, host_active);
SC_ATOMIC_EXTERN(uint32_t,host_prune_idx);
void HostInitConfig(bool quiet);
@ -155,5 +155,6 @@ void HostUnlock(Host *h);
int HostSetMemcap(uint64_t);
uint64_t HostGetMemcap(void);
uint64_t HostGetMemuse(void);
uint64_t HostGetActive(void);
#endif /* SURICATA_HOST_H */

15
src/ippair.c
Unescape Escape View File

@ -51,7 +51,7 @@ IPPairHashRow *ippair_hash;
static IPPairQueue ippair_spare_q;
IPPairConfig ippair_config;
SC_ATOMIC_DECLARE(uint64_t,ippair_memuse);
SC_ATOMIC_DECLARE(uint32_t,ippair_counter);
SC_ATOMIC_DECLARE(uint64_t, ippair_active);
SC_ATOMIC_DECLARE(uint32_t,ippair_prune_idx);
/** size of the ippair object. Maybe updated in IPPairInitConfig to include
@ -95,10 +95,16 @@ uint64_t IPPairGetMemuse(void)
return memusecopy;
}
uint64_t IPPairGetActive(void)
{
uint64_t ippair_activecopy = SC_ATOMIC_GET(ippair_active);
return ippair_activecopy;
}
void IPPairMoveToSpare(IPPair *h)
{
IPPairEnqueue(&ippair_spare_q, h);
(void) SC_ATOMIC_SUB(ippair_counter, 1);
(void)SC_ATOMIC_SUB(ippair_active, 1);
}
IPPair *IPPairAlloc(void)
@ -169,7 +175,8 @@ void IPPairInitConfig(bool quiet)
memset(&ippair_config, 0, sizeof(ippair_config));
//SC_ATOMIC_INIT(flow_flags);
SC_ATOMIC_INIT(ippair_counter);
SC_ATOMIC_INIT(ippair_active);
SC_ATOMIC_SET(ippair_active, 0);
SC_ATOMIC_INIT(ippair_memuse);
SC_ATOMIC_INIT(ippair_prune_idx);
SC_ATOMIC_INIT(ippair_config.memcap);
@ -490,7 +497,7 @@ static IPPair *IPPairGetNew(Address *a, Address *b)
/* ippair is initialized (recycled) but *unlocked* */
}
(void) SC_ATOMIC_ADD(ippair_counter, 1);
(void)SC_ATOMIC_ADD(ippair_active, 1);
SCMutexLock(&h->m);
return h;
}

3
src/ippair.h
Unescape Escape View File

@ -112,7 +112,7 @@ typedef struct IPPairConfig_ {
extern IPPairConfig ippair_config;
SC_ATOMIC_EXTERN(uint64_t,ippair_memuse);
SC_ATOMIC_EXTERN(uint32_t,ippair_counter);
SC_ATOMIC_EXTERN(uint64_t, ippair_active);
SC_ATOMIC_EXTERN(uint32_t,ippair_prune_idx);
void IPPairInitConfig(bool quiet);
@ -136,5 +136,6 @@ void IPPairUnlock(IPPair *);
int IPPairSetMemcap(uint64_t size);
uint64_t IPPairGetMemcap(void);
uint64_t IPPairGetMemuse(void);
uint64_t IPPairGetActive(void);
#endif /* SURICATA_IPPAIR_H */

20
src/stream-tcp-reassemble.c
Unescape Escape View File

@ -85,6 +85,7 @@ static SCMutex segment_thread_pool_mutex = SCMUTEX_INITIALIZER;
/* Memory use counter */
SC_ATOMIC_DECLARE(uint64_t, ra_memuse);
SC_ATOMIC_DECLARE(uint64_t, ra_active_segments);
static int g_tcp_session_dump_enabled = 0;
@ -107,6 +108,12 @@ void StreamTcpReassembleInitMemuse(void)
SC_ATOMIC_INIT(ra_memuse);
}
void StreamTcpReassembleInitActive(void)
{
SC_ATOMIC_INIT(ra_active_segments);
SC_ATOMIC_SET(ra_active_segments, 0);
}
/**
* \brief Function to Increment the memory usage counter for the TCP reassembly
* segments
@ -153,6 +160,12 @@ uint64_t StreamTcpReassembleMemuseGlobalCounter(void)
return smemuse;
}
uint64_t StreamTcpReassembleGetActive(void)
{
uint64_t ra_active_segmentscopy = SC_ATOMIC_GET(ra_active_segments);
return ra_active_segmentscopy;
}
/**
* \brief Function to Check the reassembly memory usage counter against the
* allowed max memory usage for TCP segments.
@ -380,6 +393,8 @@ void StreamTcpSegmentReturntoPool(TcpSegment *seg)
if (seg == NULL)
return;
SC_ATOMIC_SUB(ra_active_segments, 1);
if (seg->pcap_hdr_storage && seg->pcap_hdr_storage->pktlen) {
seg->pcap_hdr_storage->pktlen = 0;
}
@ -540,6 +555,9 @@ int StreamTcpReassembleInit(bool quiet)
#endif
StatsRegisterGlobalCounter("tcp.reassembly_memuse",
StreamTcpReassembleMemuseGlobalCounter);
StatsRegisterGlobalCounter("tcp.reassembly_active_segments", StreamTcpReassembleGetActive);
return 0;
}
@ -2130,6 +2148,7 @@ TcpSegment *StreamTcpGetSegment(ThreadVars *tv, TcpReassemblyThreadCtx *ra_ctx)
TcpSegment *seg = StreamTcpThreadCacheGetSegment();
if (seg) {
StatsCounterIncr(&tv->stats, ra_ctx->counter_tcp_segment_from_cache);
SC_ATOMIC_ADD(ra_active_segments, 1);
return seg;
}
@ -2143,6 +2162,7 @@ TcpSegment *StreamTcpGetSegment(ThreadVars *tv, TcpReassemblyThreadCtx *ra_ctx)
} else {
memset(&seg->sbseg, 0, sizeof(seg->sbseg));
StatsCounterIncr(&tv->stats, ra_ctx->counter_tcp_segment_from_pool);
SC_ATOMIC_ADD(ra_active_segments, 1);
}
return seg;

2
src/stream-tcp-reassemble.h
Unescape Escape View File

@ -91,6 +91,7 @@ typedef struct TcpReassemblyThreadCtx_ {
#define OS_POLICY_DEFAULT OS_POLICY_BSD
void StreamTcpReassembleInitMemuse(void);
void StreamTcpReassembleInitActive(void);
int StreamTcpReassembleHandleSegment(
ThreadVars *, TcpReassemblyThreadCtx *, TcpSession *, TcpStream *, Packet *);
int StreamTcpReassembleInit(bool);
@ -129,6 +130,7 @@ int StreamTcpReassembleSetMemcap(uint64_t size);
uint64_t StreamTcpReassembleGetMemcap(void);
int StreamTcpReassembleCheckMemcap(uint64_t size);
uint64_t StreamTcpReassembleMemuseGlobalCounter(void);
uint64_t StreamTcpReassembleGetActive(void);
void StreamTcpDisableAppLayer(Flow *f);
int StreamTcpAppLayerIsDisabled(Flow *f);

Write Preview
Loading…
Cancel
Save