gfwleak/stellar-stellar
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
luwenpeng
2024-09-13 15:34:26 +08:00
parent fb32deec1d
commit 244cc88ace
2 changed files with 73 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
infra/tcp_reassembly/tcp_reassembly.c
View File

@@ -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)
if (tcp_reass == NULL)
{
return NULL;
}
if (list_empty(&assembler->list))
struct tcp_segment_private *p = TAILQ_FIRST(&tcp_reass->lru_list);
if (p && now - p->ts >= tcp_reass->max_timeout)
{
return NULL;
}
struct tcp_segment_private *p = list_first_entry(&assembler->list, struct tcp_segment_private, lru);
if (now - p->ts >= assembler->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)

14
infra/tcp_reassembly/tcp_reassembly.h
View File

@@ -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