defrag: get/set memcap value

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.

Another function is added to gets
the memuse value since it will be shown
through unix-socket.

src/defrag-hash.c

@@ -30,6 +30,43 @@ static DefragTracker *DefragTrackerGetUsedDefragTracker(void);
 /** queue with spare tracker */
 static DefragTrackerQueue defragtracker_spare_q;
 
+/**
+ *  \brief Update memcap value
+ *
+ *  \param size new memcap value
+ */
+int DefragTrackerSetMemcap(uint64_t size)
+{
+    if ((uint64_t)SC_ATOMIC_GET(defrag_memuse) < size) {
+        SC_ATOMIC_SET(defrag_config.memcap, size);
+        return 1;
+    }
+
+    return 0;
+}
+
+/**
+ *  \brief Return memcap value
+ *
+ *  \retval memcap value
+ */
+uint64_t DefragTrackerGetMemcap(void)
+{
+    uint64_t memcapcopy = SC_ATOMIC_GET(defrag_config.memcap);
+    return memcapcopy;
+}
+
+/**
+ *  \brief Return memuse value
+ *
+ *  \retval memuse value
+ */
+uint64_t DefragTrackerGetMemuse(void)
+{
+    uint64_t memusecopy = (uint64_t)SC_ATOMIC_GET(defrag_memuse);
+    return memusecopy;
+}
+
 uint32_t DefragTrackerSpareQueueGetSize(void)
 {
     return DefragTrackerQueueLen(&defragtracker_spare_q);
@@ -131,26 +168,30 @@ void DefragInitConfig(char quiet)
     SC_ATOMIC_INIT(defragtracker_counter);
     SC_ATOMIC_INIT(defrag_memuse);
     SC_ATOMIC_INIT(defragtracker_prune_idx);
+    SC_ATOMIC_INIT(defrag_config.memcap);
     DefragTrackerQueueInit(&defragtracker_spare_q);
 
     /* set defaults */
     defrag_config.hash_rand   = (uint32_t)RandomGet();
     defrag_config.hash_size   = DEFRAG_DEFAULT_HASHSIZE;
-    defrag_config.memcap      = DEFRAG_DEFAULT_MEMCAP;
     defrag_config.prealloc    = DEFRAG_DEFAULT_PREALLOC;
+    SC_ATOMIC_SET(defrag_config.memcap, DEFRAG_DEFAULT_MEMCAP);
 
     /* Check if we have memcap and hash_size defined at config */
     const char *conf_val;
     uint32_t configval = 0;
 
+    uint64_t defrag_memcap;
     /** set config values for memcap, prealloc and hash_size */
     if ((ConfGet("defrag.memcap", &conf_val)) == 1)
     {
-        if (ParseSizeStringU64(conf_val, &defrag_config.memcap) < 0) {
+        if (ParseSizeStringU64(conf_val, &defrag_memcap) < 0) {
             SCLogError(SC_ERR_SIZE_PARSE, "Error parsing defrag.memcap "
                        "from conf file - %s.  Killing engine",
                        conf_val);
             exit(EXIT_FAILURE);
+        } else {
+            SC_ATOMIC_SET(defrag_config.memcap, defrag_memcap);
         }
     }
     if ((ConfGet("defrag.hash-size", &conf_val)) == 1)
@@ -174,7 +215,7 @@ void DefragInitConfig(char quiet)
         }
     }
     SCLogDebug("DefragTracker config from suricata.yaml: memcap: %"PRIu64", hash-size: "
-               "%"PRIu32", prealloc: %"PRIu32, defrag_config.memcap,
+               "%"PRIu32", prealloc: %"PRIu32, SC_ATOMIC_GET(defrag_config.memcap),
                defrag_config.hash_size, defrag_config.prealloc);
 
     /* alloc hash memory */
@@ -184,7 +225,7 @@ void DefragInitConfig(char quiet)
                 "max defrag memcap is smaller than projected hash size. "
                 "Memcap: %"PRIu64", Hash table size %"PRIu64". Calculate "
                 "total hash size by multiplying \"defrag.hash-size\" with %"PRIuMAX", "
-                "which is the hash bucket size.", defrag_config.memcap, hash_size,
+                "which is the hash bucket size.", SC_ATOMIC_GET(defrag_config.memcap), hash_size,
                 (uintmax_t)sizeof(DefragTrackerHashRow));
         exit(EXIT_FAILURE);
     }
@@ -216,7 +257,7 @@ void DefragInitConfig(char quiet)
                 if (!(DEFRAG_CHECK_MEMCAP(sizeof(DefragTracker)))) {
                     SCLogError(SC_ERR_DEFRAG_INIT, "preallocating defrag trackers failed: "
                             "max defrag memcap reached. Memcap %"PRIu64", "
-                            "Memuse %"PRIu64".", defrag_config.memcap,
+                            "Memuse %"PRIu64".", SC_ATOMIC_GET(defrag_config.memcap),
                             ((uint64_t)SC_ATOMIC_GET(defrag_memuse) + (uint64_t)sizeof(DefragTracker)));
                     exit(EXIT_FAILURE);
                 }
@@ -237,7 +278,7 @@ void DefragInitConfig(char quiet)
 
     if (quiet == FALSE) {
         SCLogConfig("defrag memory usage: %"PRIu64" bytes, maximum: %"PRIu64,
-                SC_ATOMIC_GET(defrag_memuse), defrag_config.memcap);
+                SC_ATOMIC_GET(defrag_memuse), SC_ATOMIC_GET(defrag_config.memcap));
     }
 
     return;
@@ -286,6 +327,7 @@ void DefragHashShutdown(void)
     SC_ATOMIC_DESTROY(defragtracker_prune_idx);
     SC_ATOMIC_DESTROY(defrag_memuse);
     SC_ATOMIC_DESTROY(defragtracker_counter);
+    SC_ATOMIC_DESTROY(defrag_config.memcap);
     //SC_ATOMIC_DESTROY(flow_flags);
     return;
 }

src/defrag-hash.h

@@ -68,7 +68,7 @@ DefragTrackerHashRow *defragtracker_hash;
 #define DEFRAG_QUIET      1
 
 typedef struct DefragConfig_ {
-    uint64_t memcap;
+    SC_ATOMIC_DECLARE(uint64_t, memcap);
     uint32_t hash_rand;
     uint32_t hash_size;
     uint32_t prealloc;
@@ -82,7 +82,7 @@ typedef struct DefragConfig_ {
  *  \retval 0 no fit
  */
 #define DEFRAG_CHECK_MEMCAP(size) \
-    ((((uint64_t)SC_ATOMIC_GET(defrag_memuse) + (uint64_t)(size)) <= defrag_config.memcap))
+    ((((uint64_t)SC_ATOMIC_GET(defrag_memuse) + (uint64_t)(size)) <= SC_ATOMIC_GET(defrag_config.memcap)))
 
 DefragConfig defrag_config;
 SC_ATOMIC_DECLARE(uint64_t,defrag_memuse);
@@ -99,5 +99,9 @@ void DefragTrackerClearMemory(DefragTracker *);
 void DefragTrackerMoveToSpare(DefragTracker *);
 uint32_t DefragTrackerSpareQueueGetSize(void);
 
+int DefragTrackerSetMemcap(uint64_t);
+uint64_t DefragTrackerGetMemcap(void);
+uint64_t DefragTrackerGetMemuse(void);
+
 #endif /* __DEFRAG_HASH_H__ */