defrag: turn queue into stack

Only used by the spare tracker logic, which works better as a stack.

src/Makefile.am

@@ -86,7 +86,7 @@ noinst_HEADERS = \
 	defrag-config.h \
 	defrag.h \
 	defrag-hash.h \
-	defrag-queue.h \
+	defrag-stack.h \
 	defrag-timeout.h \
 	detect-app-layer-event.h \
 	detect-app-layer-protocol.h \
@@ -698,7 +698,7 @@ libsuricata_c_a_SOURCES = \
 	defrag.c \
 	defrag-config.c \
 	defrag-hash.c \
-	defrag-queue.c \
+	defrag-stack.c \
 	defrag-timeout.c \
 	detect-app-layer-event.c \
 	detect-app-layer-protocol.c \

src/defrag-hash.c

@@ -18,7 +18,7 @@
 #include "suricata-common.h"
 #include "conf.h"
 #include "defrag-hash.h"
-#include "defrag-queue.h"
+#include "defrag-stack.h"
 #include "defrag-config.h"
 #include "util-random.h"
 #include "util-byte.h"
@@ -36,7 +36,7 @@ SC_ATOMIC_DECLARE(unsigned int,defragtracker_prune_idx);
 static DefragTracker *DefragTrackerGetUsedDefragTracker(void);
 
 /** queue with spare tracker */
-static DefragTrackerQueue defragtracker_spare_q;
+static DefragTrackerStack defragtracker_spare_q;
 
 /**
  *  \brief Update memcap value
@@ -173,7 +173,7 @@ void DefragInitConfig(bool quiet)
     SC_ATOMIC_INIT(defrag_memuse);
     SC_ATOMIC_INIT(defragtracker_prune_idx);
     SC_ATOMIC_INIT(defrag_config.memcap);
-    DefragTrackerQueueInit(&defragtracker_spare_q);
+    DefragTrackerStackInit(&defragtracker_spare_q);
 
     /* set defaults */
     defrag_config.hash_rand   = (uint32_t)RandomGet();
@@ -318,7 +318,7 @@ void DefragHashShutdown(void)
         defragtracker_hash = NULL;
     }
     (void) SC_ATOMIC_SUB(defrag_memuse, defrag_config.hash_size * sizeof(DefragTrackerHashRow));
-    DefragTrackerQueueDestroy(&defragtracker_spare_q);
+    DefragTrackerStackDestroy(&defragtracker_spare_q);
 }
 
 /** \brief compare two raw ipv6 addrs

src/defrag-stack.c

@@ -24,15 +24,15 @@
  */
 
 #include "suricata-common.h"
-#include "defrag-queue.h"
+#include "defrag-stack.h"
 #include "util-error.h"
 #include "util-debug.h"
 #include "util-print.h"
 
-DefragTrackerQueue *DefragTrackerQueueInit (DefragTrackerQueue *q)
+DefragTrackerStack *DefragTrackerStackInit(DefragTrackerStack *q)
 {
     if (q != NULL) {
-        memset(q, 0, sizeof(DefragTrackerQueue));
+        memset(q, 0, sizeof(DefragTrackerStack));
         DQLOCK_INIT(q);
     }
     return q;
@@ -43,7 +43,7 @@ DefragTrackerQueue *DefragTrackerQueueInit (DefragTrackerQueue *q)
  *
  *  \param q the tracker queue to destroy
  */
-void DefragTrackerQueueDestroy (DefragTrackerQueue *q)
+void DefragTrackerStackDestroy(DefragTrackerStack *q)
 {
     DQLOCK_DESTROY(q);
 }
@@ -54,24 +54,15 @@ void DefragTrackerQueueDestroy (DefragTrackerQueue *q)
  *  \param q queue
  *  \param dt tracker
  */
-void DefragTrackerEnqueue (DefragTrackerQueue *q, DefragTracker *dt)
+void DefragTrackerEnqueue(DefragTrackerStack *q, DefragTracker *dt)
 {
 #ifdef DEBUG
     BUG_ON(q == NULL || dt == NULL);
 #endif
 
     DQLOCK_LOCK(q);
-
-    /* more trackers in queue */
-    if (q->top != NULL) {
-        dt->lnext = q->top;
-        q->top->lprev = dt;
-        q->top = dt;
-    /* only tracker */
-    } else {
-        q->top = dt;
-        q->bot = dt;
-    }
+    dt->lnext = q->s;
+    q->s = dt;
     q->len++;
 #ifdef DBG_PERF
     if (q->len > q->dbg_maxlen)
@@ -87,35 +78,23 @@ void DefragTrackerEnqueue (DefragTrackerQueue *q, DefragTracker *dt)
  *
  *  \retval dt tracker or NULL if empty list.
  */
-DefragTracker *DefragTrackerDequeue (DefragTrackerQueue *q)
+DefragTracker *DefragTrackerDequeue(DefragTrackerStack *q)
 {
     DQLOCK_LOCK(q);
 
-    DefragTracker *dt = q->bot;
+    DefragTracker *dt = q->s;
     if (dt == NULL) {
         DQLOCK_UNLOCK(q);
         return NULL;
     }
-
-    /* more packets in queue */
-    if (q->bot->lprev != NULL) {
-        q->bot = q->bot->lprev;
-        q->bot->lnext = NULL;
-    /* just the one we remove, so now empty */
-    } else {
-        q->top = NULL;
-        q->bot = NULL;
-    }
+    q->s = dt->lnext;
+    dt->lnext = NULL;
 
 #ifdef DEBUG
     BUG_ON(q->len == 0);
 #endif
     if (q->len > 0)
         q->len--;
-
-    dt->lnext = NULL;
-    dt->lprev = NULL;
-
     DQLOCK_UNLOCK(q);
     return dt;
 }

src/defrag-stack.h

@@ -38,10 +38,8 @@
 #endif
 
 /* Define a queue for storing defrag trackers */
-typedef struct DefragTrackerQueue_
-{
-    DefragTracker *top;
-    DefragTracker *bot;
+typedef struct DefragTrackerStack_ {
+    DefragTracker *s;
     uint32_t len;
 #ifdef DBG_PERF
     uint32_t dbg_maxlen;
@@ -53,7 +51,7 @@ typedef struct DefragTrackerQueue_
 #else
 #error Enable DQLOCK_SPIN or DQLOCK_MUTEX
 #endif
-} DefragTrackerQueue;
+} DefragTrackerStack;
 
 #ifdef DQLOCK_SPIN
 #define DQLOCK_INIT(q)    SCSpinInit(&(q)->s, 0)
@@ -72,10 +70,10 @@ typedef struct DefragTrackerQueue_
 #endif
 
 /* prototypes */
-DefragTrackerQueue *DefragTrackerQueueInit(DefragTrackerQueue *);
-void DefragTrackerQueueDestroy (DefragTrackerQueue *);
+DefragTrackerStack *DefragTrackerStackInit(DefragTrackerStack *);
+void DefragTrackerStackDestroy(DefragTrackerStack *);
 
-void DefragTrackerEnqueue (DefragTrackerQueue *, DefragTracker *);
-DefragTracker *DefragTrackerDequeue(DefragTrackerQueue *);
+void DefragTrackerEnqueue(DefragTrackerStack *, DefragTracker *);
+DefragTracker *DefragTrackerDequeue(DefragTrackerStack *);
 
 #endif /* SURICATA_DEFRAG_QUEUE_H */

src/defrag.c

@@ -53,7 +53,6 @@
 
 #include "defrag.h"
 #include "defrag-hash.h"
-#include "defrag-queue.h"
 #include "defrag-config.h"
 
 #include "tmqh-packetpool.h"

src/defrag.h

@@ -118,9 +118,8 @@ typedef struct DefragTracker_ {
     /** hash pointer, protected by hash row mutex/spin */
     struct DefragTracker_ *hnext;
 
-    /** list pointers, protected by tracker-queue mutex/spin */
+    /** stack pointer, protected by tracker-queue mutex/spin */
     struct DefragTracker_ *lnext;
-    struct DefragTracker_ *lprev;
 } DefragTracker;
 
 void DefragInit(void);