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

stream-tcp: get/set memcap value

Browse Source 
This adds new functions that will be called
through unix-socket and permit to update
and show memcap value.

The memcap value needs to be handled in a
thread safe way, so for this reason it is
declared as atomic var.
pull/3104/head
Giuseppe Longo 8 years ago committed by Victor Julien
parent 4a75eaf405
commit 80bf728bfe
4 changed files with 84 additions and 13 deletions
Show Stats Download Patch File Download Diff File

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

@ -145,12 +145,39 @@ uint64_t StreamTcpReassembleMemuseGlobalCounter(void)
*/
int StreamTcpReassembleCheckMemcap(uint64_t size)
{
if (stream_config.reassembly_memcap == 0 ||
(uint64_t)((uint64_t)size + SC_ATOMIC_GET(ra_memuse)) <= stream_config.reassembly_memcap)
uint64_t memcapcopy = SC_ATOMIC_GET(stream_config.reassembly_memcap);
if (memcapcopy == 0 ||
(uint64_t)((uint64_t)size + SC_ATOMIC_GET(ra_memuse)) <= memcapcopy)
return 1;
return 0;
}
/**
* \brief Update memcap value
*
* \param size new memcap value
*/
int StreamTcpReassembleSetMemcap(uint64_t size)
{
if (size == 0 || (uint64_t)SC_ATOMIC_GET(ra_memuse) < size) {
SC_ATOMIC_SET(stream_config.reassembly_memcap, size);
return 1;
}
return 0;
}
/**
* \brief Return memcap value
*
* \return memcap memcap value
*/
uint64_t StreamTcpReassembleGetMemcap()
{
uint64_t memcapcopy = SC_ATOMIC_GET(stream_config.reassembly_memcap);
return memcapcopy;
}
/* memory functions for the streaming buffer API */
/*
@ -2885,7 +2912,7 @@ static int StreamTcpReassembleTest44(void)
StreamTcpReassembleDecrMemuse(500);
FAIL_IF(SC_ATOMIC_GET(ra_memuse) != memuse);
FAIL_IF(StreamTcpReassembleCheckMemcap(500) != 1);
FAIL_IF(StreamTcpReassembleCheckMemcap((1 + memuse + stream_config.reassembly_memcap)) != 0);
FAIL_IF(StreamTcpReassembleCheckMemcap((1 + memuse + SC_ATOMIC_GET(stream_config.reassembly_memcap))) != 0);
StreamTcpFreeConfig(TRUE);
FAIL_IF(SC_ATOMIC_GET(ra_memuse) != 0);
PASS;

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

@ -114,6 +114,8 @@ int StreamTcpReassembleDepthReached(Packet *p);
void StreamTcpReassembleIncrMemuse(uint64_t size);
void StreamTcpReassembleDecrMemuse(uint64_t size);
int StreamTcpReassembleSetMemcap(uint64_t size);
uint64_t StreamTcpReassembleGetMemcap(void);
int StreamTcpReassembleCheckMemcap(uint64_t size);
uint64_t StreamTcpReassembleMemuseGlobalCounter(void);

56
src/stream-tcp.c
Unescape Escape View File

@ -164,11 +164,38 @@ uint64_t StreamTcpMemuseCounter(void)
*/
int StreamTcpCheckMemcap(uint64_t size)
{
if (stream_config.memcap == 0 || size + SC_ATOMIC_GET(st_memuse) <= stream_config.memcap)
uint64_t memcapcopy = SC_ATOMIC_GET(stream_config.memcap);
if (memcapcopy == 0 || size + SC_ATOMIC_GET(st_memuse) <= memcapcopy)
return 1;
return 0;
}
/**
* \brief Update memcap value
*
* \param size new memcap value
*/
int StreamTcpSetMemcap(uint64_t size)
{
if (size == 0 || (uint64_t)SC_ATOMIC_GET(st_memuse) < size) {
SC_ATOMIC_SET(stream_config.memcap, size);
return 1;
}
return 0;
}
/**
* \brief Return memcap value
*
* \param memcap memcap value
*/
uint64_t StreamTcpGetMemcap(void)
{
uint64_t memcapcopy = SC_ATOMIC_GET(stream_config.memcap);
return memcapcopy;
}
void StreamTcpStreamCleanup(TcpStream *stream)
{
if (stream != NULL) {
@ -337,6 +364,9 @@ void StreamTcpInitConfig(char quiet)
memset(&stream_config, 0, sizeof(stream_config));
SC_ATOMIC_INIT(stream_config.memcap);
SC_ATOMIC_INIT(stream_config.reassembly_memcap);
if ((ConfGetInt("stream.max-sessions", &value)) == 1) {
SCLogWarning(SC_WARN_OPTION_OBSOLETE, "max-sessions is obsolete. "
"Number of concurrent sessions is now only limited by Flow and "
@ -364,18 +394,21 @@ void StreamTcpInitConfig(char quiet)
const char *temp_stream_memcap_str;
if (ConfGetValue("stream.memcap", &temp_stream_memcap_str) == 1) {
if (ParseSizeStringU64(temp_stream_memcap_str, &stream_config.memcap) < 0) {
uint64_t stream_memcap_copy;
if (ParseSizeStringU64(temp_stream_memcap_str, &stream_memcap_copy) < 0) {
SCLogError(SC_ERR_SIZE_PARSE, "Error parsing stream.memcap "
"from conf file - %s. Killing engine",
temp_stream_memcap_str);
exit(EXIT_FAILURE);
} else {
SC_ATOMIC_SET(stream_config.memcap, stream_memcap_copy);
}
} else {
stream_config.memcap = STREAMTCP_DEFAULT_MEMCAP;
SC_ATOMIC_SET(stream_config.memcap, STREAMTCP_DEFAULT_MEMCAP);
}
if (!quiet) {
SCLogConfig("stream \"memcap\": %"PRIu64, stream_config.memcap);
SCLogConfig("stream \"memcap\": %"PRIu64, SC_ATOMIC_GET(stream_config.memcap));
}
ConfGetBool("stream.midstream", &stream_config.midstream);
@ -472,20 +505,24 @@ void StreamTcpInitConfig(char quiet)
const char *temp_stream_reassembly_memcap_str;
if (ConfGetValue("stream.reassembly.memcap", &temp_stream_reassembly_memcap_str) == 1) {
uint64_t stream_reassembly_memcap_copy;
if (ParseSizeStringU64(temp_stream_reassembly_memcap_str,
&stream_config.reassembly_memcap) < 0) {
&stream_reassembly_memcap_copy) < 0) {
SCLogError(SC_ERR_SIZE_PARSE, "Error parsing "
"stream.reassembly.memcap "
"from conf file - %s. Killing engine",
temp_stream_reassembly_memcap_str);
exit(EXIT_FAILURE);
} else {
SC_ATOMIC_SET(stream_config.reassembly_memcap, stream_reassembly_memcap_copy);
}
} else {
stream_config.reassembly_memcap = STREAMTCP_DEFAULT_REASSEMBLY_MEMCAP;
SC_ATOMIC_SET(stream_config.reassembly_memcap , STREAMTCP_DEFAULT_REASSEMBLY_MEMCAP);
}
if (!quiet) {
SCLogConfig("stream.reassembly \"memcap\": %"PRIu64"", stream_config.reassembly_memcap);
SCLogConfig("stream.reassembly \"memcap\": %"PRIu64"",
SC_ATOMIC_GET(stream_config.reassembly_memcap));
}
const char *temp_stream_reassembly_depth_str;
@ -624,6 +661,9 @@ void StreamTcpInitConfig(char quiet)
void StreamTcpFreeConfig(char quiet)
{
SC_ATOMIC_DESTROY(stream_config.memcap);
SC_ATOMIC_DESTROY(stream_config.reassembly_memcap);
StreamTcpReassembleFree(quiet);
SCMutexLock(&ssn_pool_mutex);
@ -8657,7 +8697,7 @@ static int StreamTcpTest28(void)
FAIL_IF(StreamTcpCheckMemcap(500) != 1);
FAIL_IF(StreamTcpCheckMemcap((memuse + stream_config.memcap)) != 0);
FAIL_IF(StreamTcpCheckMemcap((memuse + SC_ATOMIC_GET(stream_config.memcap))) != 0);
StreamTcpUTDeinit(stt.ra_ctx);

6
src/stream-tcp.h
Unescape Escape View File

@ -44,8 +44,8 @@ typedef struct TcpStreamCnf_ {
*
* max stream mem usage
*/
uint64_t memcap;
uint64_t reassembly_memcap; /**< max memory usage for stream reassembly */
SC_ATOMIC_DECLARE(uint64_t, memcap);
SC_ATOMIC_DECLARE(uint64_t, reassembly_memcap); /**< max memory usage for stream reassembly */
uint16_t stream_init_flags; /**< new stream flags will be initialized to this */
@ -109,6 +109,8 @@ void StreamTcpSessionPktFree (Packet *);
void StreamTcpInitMemuse(void);
void StreamTcpIncrMemuse(uint64_t);
void StreamTcpDecrMemuse(uint64_t);
int StreamTcpSetMemcap(uint64_t);
uint64_t StreamTcpGetMemcap(void);
int StreamTcpCheckMemcap(uint64_t);
uint64_t StreamTcpMemuseCounter(void);
uint64_t StreamTcpReassembleMemuseGlobalCounter(void);

Write Preview
Loading…
Cancel
Save