refactor(tcp reassembly): replace dep/list/list.h with sys/queue.h

2 files changed, 73 insertions, 76 deletions

diff --git a/infra/tcp_reassembly/tcp_reassembly.c b/infra/tcp_reassembly/tcp_reassembly.c
index 962a166..62fa1da 100644
--- a/infra/tcp_reassembly/tcp_reassembly.c
+++ b/infra/tcp_reassembly/tcp_reassembly.c
@@ -1,7 +1,7 @@
 #include <string.h>
 #include <stdbool.h>
+#include <sys/queue.h>
 
-#include "list.h"
 #include "log_private.h"
 #include "interval_tree.h"
 #include "tcp_reassembly.h"
@@ -14,12 +14,14 @@ struct tcp_segment_private
 {
     uint64_t ts;
     uint64_t id;
-    struct list_head lru;
     struct interval_tree_node node;
+    TAILQ_ENTRY(tcp_segment_private) lru;
     struct tcp_segment seg;
     void *data; // flexible array member
 };
 
+TAILQ_HEAD(tcp_segment_private_list, tcp_segment_private);
+
 struct tcp_reassembly
 {
     uint64_t max_timeout;
@@ -27,8 +29,8 @@ struct tcp_reassembly
     uint64_t cur_seg_num;
     uint64_t sum_seg_num;
 
-    struct list_head list;
-    struct rb_root_cached root;
+    struct rb_root_cached rb_root;
+    struct tcp_segment_private_list lru_list;
     uint32_t recv_next;
 };
 
@@ -66,38 +68,38 @@ void tcp_segment_free(struct tcp_segment *seg)
 
 struct tcp_reassembly *tcp_reassembly_new(uint64_t max_timeout, uint64_t max_seg_num)
 {
-    struct tcp_reassembly *assembler = (struct tcp_reassembly *)malloc(sizeof(struct tcp_reassembly));
-    if (!assembler)
+    struct tcp_reassembly *tcp_reass = (struct tcp_reassembly *)malloc(sizeof(struct tcp_reassembly));
+    if (!tcp_reass)
     {
         TCP_REASSEMBLY_LOG_ERROR("calloc failed");
         return NULL;
     }
 
-    assembler->max_timeout = max_timeout;
-    assembler->max_seg_num = max_seg_num;
-    assembler->cur_seg_num = 0;
-    assembler->sum_seg_num = 0;
-    INIT_LIST_HEAD(&assembler->list);
-    assembler->root = RB_ROOT_CACHED;
-    assembler->recv_next = 0;
+    tcp_reass->max_timeout = max_timeout;
+    tcp_reass->max_seg_num = max_seg_num;
+    tcp_reass->cur_seg_num = 0;
+    tcp_reass->sum_seg_num = 0;
+    tcp_reass->rb_root = RB_ROOT_CACHED;
+    tcp_reass->recv_next = 0;
+    TAILQ_INIT(&tcp_reass->lru_list);
 
-    return assembler;
+    return tcp_reass;
 }
 
-void tcp_reassembly_free(struct tcp_reassembly *assembler)
+void tcp_reassembly_free(struct tcp_reassembly *tcp_reass)
 {
-    if (assembler)
+    if (tcp_reass)
     {
-        while (!list_empty(&assembler->list))
+        struct tcp_segment_private *p = NULL;
+        while ((p = TAILQ_FIRST(&tcp_reass->lru_list)))
         {
-            struct tcp_segment_private *p = list_first_entry(&assembler->list, struct tcp_segment_private, lru);
-            assembler->cur_seg_num--;
-            list_del(&p->lru);
-            interval_tree_remove(&p->node, &assembler->root);
+            tcp_reass->cur_seg_num--;
+            TAILQ_REMOVE(&tcp_reass->lru_list, p, lru);
+            interval_tree_remove(&p->node, &tcp_reass->rb_root);
             free(p);
         }
 
-        free(assembler);
+        free(tcp_reass);
     }
 }
 
@@ -107,22 +109,22 @@ void tcp_reassembly_free(struct tcp_reassembly *assembler)
  * return: -1: push tcp segment failed (no space)
  * return: -2: push tcp segment failed (segment repeat)
  */
-int tcp_reassembly_push(struct tcp_reassembly *assembler, struct tcp_segment *seg, uint64_t now)
+int tcp_reassembly_push(struct tcp_reassembly *tcp_reass, struct tcp_segment *seg, uint64_t now)
 {
-    if (assembler == NULL)
+    if (tcp_reass == NULL)
     {
         return -1;
     }
 
-    if (assembler->cur_seg_num >= assembler->max_seg_num)
+    if (tcp_reass->cur_seg_num >= tcp_reass->max_seg_num)
     {
-        TCP_REASSEMBLY_LOG_ERROR("assembler %p is full", assembler);
+        TCP_REASSEMBLY_LOG_ERROR("tcp_reass %p is full", tcp_reass);
         return -1;
     }
 
     int ret = 0;
     struct tcp_segment_private *p = container_of(seg, struct tcp_segment_private, seg);
-    struct interval_tree_node *node = interval_tree_iter_first(&assembler->root, p->node.start, p->node.last);
+    struct interval_tree_node *node = interval_tree_iter_first(&tcp_reass->rb_root, p->node.start, p->node.last);
     if (node)
     {
         do
@@ -130,37 +132,37 @@ int tcp_reassembly_push(struct tcp_reassembly *assembler, struct tcp_segment *se
             struct tcp_segment_private *t = container_of(node, struct tcp_segment_private, node);
             if (t->node.start == p->node.start && t->node.last == p->node.last)
             {
-                TCP_REASSEMBLY_LOG_DEBUG("assembler %p push segment %p [%lu, %lu] failed, segment repeat", assembler, seg, p->node.start, p->node.last);
+                TCP_REASSEMBLY_LOG_DEBUG("tcp_reass %p push segment %p [%lu, %lu] failed, segment repeat", tcp_reass, seg, p->node.start, p->node.last);
                 return -2;
             }
         } while ((node = interval_tree_iter_next(node, p->node.start, p->node.last)));
 
-        TCP_REASSEMBLY_LOG_DEBUG("assembler %p push segment %p [%lu, %lu], but segment overlap", assembler, seg, p->node.start, p->node.last);
+        TCP_REASSEMBLY_LOG_DEBUG("tcp_reass %p push segment %p [%lu, %lu], but segment overlap", tcp_reass, seg, p->node.start, p->node.last);
         ret = 1;
     }
     else
     {
-        TCP_REASSEMBLY_LOG_DEBUG("assembler %p push segment %p [%lu, %lu]", assembler, seg, p->node.start, p->node.last);
+        TCP_REASSEMBLY_LOG_DEBUG("tcp_reass %p push segment %p [%lu, %lu]", tcp_reass, seg, p->node.start, p->node.last);
     }
 
     p->ts = now;
-    p->id = assembler->sum_seg_num++;
-    list_add_tail(&p->lru, &assembler->list);
-    interval_tree_insert(&p->node, &assembler->root);
+    p->id = tcp_reass->sum_seg_num++;
+    TAILQ_INSERT_TAIL(&tcp_reass->lru_list, p, lru);
+    interval_tree_insert(&p->node, &tcp_reass->rb_root);
 
-    assembler->cur_seg_num++;
+    tcp_reass->cur_seg_num++;
 
     return ret;
 }
 
-struct tcp_segment *tcp_reassembly_pop(struct tcp_reassembly *assembler)
+struct tcp_segment *tcp_reassembly_pop(struct tcp_reassembly *tcp_reass)
 {
-    if (assembler == NULL)
+    if (tcp_reass == NULL)
     {
         return NULL;
     }
 
-    struct interval_tree_node *node = interval_tree_iter_first(&assembler->root, assembler->recv_next, assembler->recv_next);
+    struct interval_tree_node *node = interval_tree_iter_first(&tcp_reass->rb_root, tcp_reass->recv_next, tcp_reass->recv_next);
     if (node == NULL)
     {
         return NULL;
@@ -177,49 +179,44 @@ struct tcp_segment *tcp_reassembly_pop(struct tcp_reassembly *assembler)
             min_id = p->id;
             oldest = p;
         }
-        node = interval_tree_iter_next(node, assembler->recv_next, assembler->recv_next);
+        node = interval_tree_iter_next(node, tcp_reass->recv_next, tcp_reass->recv_next);
     }
 
-    list_del(&oldest->lru);
-    interval_tree_remove(&oldest->node, &assembler->root);
+    TAILQ_REMOVE(&tcp_reass->lru_list, oldest, lru);
+    interval_tree_remove(&oldest->node, &tcp_reass->rb_root);
 
-    assembler->cur_seg_num--;
+    tcp_reass->cur_seg_num--;
 
-    if (oldest->node.start < assembler->recv_next)
+    if (oldest->node.start < tcp_reass->recv_next)
     {
         // trim overlap
-        overlap = assembler->recv_next - oldest->node.start;
+        overlap = tcp_reass->recv_next - oldest->node.start;
         oldest->seg.len -= overlap;
         oldest->seg.data = (char *)oldest->data + overlap;
     }
 
-    TCP_REASSEMBLY_LOG_DEBUG("assembler %p pop segment %p [%lu, %lu], trim overlap %lu", assembler, &oldest->seg, oldest->node.start, oldest->node.last, overlap);
+    TCP_REASSEMBLY_LOG_DEBUG("tcp_reass %p pop segment %p [%lu, %lu], trim overlap %lu", tcp_reass, &oldest->seg, oldest->node.start, oldest->node.last, overlap);
 
     // update recv_next
-    assembler->recv_next = uint32_add(assembler->recv_next, oldest->seg.len);
+    tcp_reass->recv_next = uint32_add(tcp_reass->recv_next, oldest->seg.len);
 
     return &oldest->seg;
 }
 
-struct tcp_segment *tcp_reassembly_expire(struct tcp_reassembly *assembler, uint64_t now)
+struct tcp_segment *tcp_reassembly_expire(struct tcp_reassembly *tcp_reass, uint64_t now)
 {
-    if (assembler == NULL)
-    {
-        return NULL;
-    }
-
-    if (list_empty(&assembler->list))
+    if (tcp_reass == NULL)
     {
         return NULL;
     }
 
-    struct tcp_segment_private *p = list_first_entry(&assembler->list, struct tcp_segment_private, lru);
-    if (now - p->ts >= assembler->max_timeout)
+    struct tcp_segment_private *p = TAILQ_FIRST(&tcp_reass->lru_list);
+    if (p && now - p->ts >= tcp_reass->max_timeout)
     {
-        assembler->cur_seg_num--;
-        list_del(&p->lru);
-        interval_tree_remove(&p->node, &assembler->root);
-        TCP_REASSEMBLY_LOG_DEBUG("assembler %p expire segment %p [%lu, %lu]", assembler, &p->seg, p->node.start, p->node.last);
+        tcp_reass->cur_seg_num--;
+        TAILQ_REMOVE(&tcp_reass->lru_list, p, lru);
+        interval_tree_remove(&p->node, &tcp_reass->rb_root);
+        TCP_REASSEMBLY_LOG_DEBUG("tcp_reass %p expire segment %p [%lu, %lu]", tcp_reass, &p->seg, p->node.start, p->node.last);
         return &p->seg;
     }
     else
@@ -228,36 +225,36 @@ struct tcp_segment *tcp_reassembly_expire(struct tcp_reassembly *assembler, uint
     }
 }
 
-void tcp_reassembly_inc_recv_next(struct tcp_reassembly *assembler, uint32_t offset)
+void tcp_reassembly_inc_recv_next(struct tcp_reassembly *tcp_reass, uint32_t offset)
 {
-    if (assembler == NULL)
+    if (tcp_reass == NULL)
     {
         return;
     }
 
-    assembler->recv_next = uint32_add(assembler->recv_next, offset);
-    TCP_REASSEMBLY_LOG_DEBUG("assembler %p inc recv_next %u to %lu", assembler, offset, assembler->recv_next);
+    tcp_reass->recv_next = uint32_add(tcp_reass->recv_next, offset);
+    TCP_REASSEMBLY_LOG_DEBUG("tcp_reass %p inc recv_next %u to %lu", tcp_reass, offset, tcp_reass->recv_next);
 }
 
-void tcp_reassembly_set_recv_next(struct tcp_reassembly *assembler, uint32_t seq)
+void tcp_reassembly_set_recv_next(struct tcp_reassembly *tcp_reass, uint32_t seq)
 {
-    if (assembler == NULL)
+    if (tcp_reass == NULL)
     {
         return;
     }
 
-    assembler->recv_next = seq;
-    TCP_REASSEMBLY_LOG_DEBUG("assembler %p set recv_next %u", assembler, seq);
+    tcp_reass->recv_next = seq;
+    TCP_REASSEMBLY_LOG_DEBUG("tcp_reass %p set recv_next %u", tcp_reass, seq);
 }
 
-uint32_t tcp_reassembly_get_recv_next(struct tcp_reassembly *assembler)
+uint32_t tcp_reassembly_get_recv_next(struct tcp_reassembly *tcp_reass)
 {
-    if (assembler == NULL)
+    if (tcp_reass == NULL)
     {
         return 0;
     }
 
-    return assembler->recv_next;
+    return tcp_reass->recv_next;
 }
 
 const char *tcp_segment_get_data(const struct tcp_segment *seg)
diff --git a/infra/tcp_reassembly/tcp_reassembly.h b/infra/tcp_reassembly/tcp_reassembly.h
index 75c9c5c..50e369b 100644
--- a/infra/tcp_reassembly/tcp_reassembly.h
+++ b/infra/tcp_reassembly/tcp_reassembly.h
@@ -18,7 +18,7 @@ struct tcp_segment *tcp_segment_new(uint32_t seq, const void *data, uint32_t len
 void tcp_segment_free(struct tcp_segment *seg);
 
 struct tcp_reassembly *tcp_reassembly_new(uint64_t max_timeout, uint64_t max_seg_num);
-void tcp_reassembly_free(struct tcp_reassembly *assembler);
+void tcp_reassembly_free(struct tcp_reassembly *tcp_reass);
 
 /*
  * return:  1: push tcp segment success (segment overlap)
@@ -26,13 +26,13 @@ void tcp_reassembly_free(struct tcp_reassembly *assembler);
  * return: -1: push tcp segment failed (no space)
  * return: -2: push tcp segment failed (segment repeat)
  */
-int tcp_reassembly_push(struct tcp_reassembly *assembler, struct tcp_segment *seg, uint64_t now);
-struct tcp_segment *tcp_reassembly_pop(struct tcp_reassembly *assembler);
-struct tcp_segment *tcp_reassembly_expire(struct tcp_reassembly *assembler, uint64_t now);
+int tcp_reassembly_push(struct tcp_reassembly *tcp_reass, struct tcp_segment *seg, uint64_t now);
+struct tcp_segment *tcp_reassembly_pop(struct tcp_reassembly *tcp_reass);
+struct tcp_segment *tcp_reassembly_expire(struct tcp_reassembly *tcp_reass, uint64_t now);
 
-void tcp_reassembly_inc_recv_next(struct tcp_reassembly *assembler, uint32_t offset);
-void tcp_reassembly_set_recv_next(struct tcp_reassembly *assembler, uint32_t seq);
-uint32_t tcp_reassembly_get_recv_next(struct tcp_reassembly *assembler);
+void tcp_reassembly_inc_recv_next(struct tcp_reassembly *tcp_reass, uint32_t offset);
+void tcp_reassembly_set_recv_next(struct tcp_reassembly *tcp_reass, uint32_t seq);
+uint32_t tcp_reassembly_get_recv_next(struct tcp_reassembly *tcp_reass);
 
 /*
  * The next routines deal with comparing 32 bit unsigned ints