suricata 源码分析之ringbuffer（环形缓冲区）

已于 2022-10-15 22:38:22 修改
阅读量1.5k 收藏 3
点赞数
分类专栏： suricata 文章标签： suricata 源码 并发 环形缓冲区 无锁
于 2017-03-19 16:07:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guoguangwu/article/details/63685390
版权

    环形缓冲区也就是ringbuffer,其性能相对于异步队列是非常高效的，原因 ： 1)无锁; 2)cpu cache 友好;3) 内存不会疯涨。

    当然ringbuffer也有其缺点(也是优点， 不会出现内存暴增)，就是其长度是固定的，如果满了无法再往里面放入数据，而异步队列没有这个限制，但是有可能因为并发不够，处理不过来，队列太长导致内存被大量占用，程序性能越来越差。

    suricata是多线程架构的，所以线程间的数据传递是必不可少的。因此在suricata-0.8中选用的数据结构是异步队列PacketQueue，

而在suricata-2.0.8中使用的是ringbuffer数据结构。在后期的所有版本中都淘汰了异步队列PacketQueue，使用ringbuffer或者

使用函数 pthread_key_create() 用来创建线程私有数据，其性能是高于异步队列的。

     为什么ringbuffer的性能高于异步队列？

     ringbuffer的锁粒度是单个节点，并且在生产者的情况下才会加锁（往ringbuffer中放节点），而异步队列是整个队列，并发远远大于异步队列。

     如果只有一个消费者生产者，则ringbuffer不需要加锁，性能更高。

    二者在suricata中的数据包使用

    2.0.8中

void TmqhPacketpoolRegister (void) {
    tmqh_table[TMQH_PACKETPOOL].name = "packetpool";
    tmqh_table[TMQH_PACKETPOOL].InHandler = TmqhInputPacketpool;
    tmqh_table[TMQH_PACKETPOOL].OutHandler = TmqhOutputPacketpool;

    ringbuffer = RingBufferInit();
    if (ringbuffer == NULL) {
        SCLogError(SC_ERR_FATAL, "Error registering Packet pool handler (at ring buffer init)");
        exit(EXIT_FAILURE);
    }
}


    0.8中

void TmqhPacketpoolRegister (void) {
    tmqh_table[TMQH_PACKETPOOL].name = "packetpool";
    tmqh_table[TMQH_PACKETPOOL].InHandler = TmqhInputPacketpool;
    tmqh_table[TMQH_PACKETPOOL].OutHandler = TmqhOutputPacketpool;
}

     suricata中关于ringbuffer的定义与实现在util-ringbuffer.h和util-ringbuffer.c中。

     以下就以一个生产者和一个消费者的代码实现 

  /* 该环形缓冲区的大小 256 （ unsigned char 的大小） */

#define RING_BUFFER_8_SIZE 256
typedef struct RingBuffer8_ {
    /* write 和 read 都是 unsigned char 类型，巧妙地利用其值溢出效果来循环, 使用的是原子变量，来实现无锁*/
    SC_ATOMIC_DECLARE(unsigned char, write);  /**< idx where we put data */
    SC_ATOMIC_DECLARE(unsigned char, read);   /**< idx where we read data */
    uint8_t shutdown;
#ifdef RINGBUFFER_MUTEX_WAIT
    SCCondT wait_cond;
    SCMutex wait_mutex;
#endif /* RINGBUFFER_MUTEX_WAIT */
    SCSpinlock spin; /**< lock protecting writes for multi writer mode*/
    /* 环形缓冲区里面存储实际的数据，可以是任何类型 */
    void *array[RING_BUFFER_8_SIZE];
} RingBuffer8;

其使用接口：

RingBuffer8Init：初始化，创建RingBuffer8，将读写计数清零，初始化自旋锁。

RingBufferSrSw8Put：生产者，先判断缓冲区是否已满，若满，循环等待直到有空间存储然后存储。

RingBufferSrMw8Get：消费者，先判断缓冲区是否为空，若空，循环等待直到有数据然后取走。

RingBuffer8Destroy：销毁缓冲区。

下面针对实际代码进行解释：

/* 生产者 */
int RingBufferSrSw8Put(RingBuffer8 *rb, void *ptr)
{
    /* buffer is full, wait... */
    /* 判断该缓冲区是否已满，如果是，循环等待。这里判断的依据就是 read write的值会不停的从0-255循环 */
    while ((unsigned char)(SC_ATOMIC_GET(rb->write) + 1) == SC_ATOMIC_GET(rb->read)) {
        /* break out if the engine wants to shutdown */
        if (rb->shutdown != 0)
            return -1;

        RingBuffer8DoWait(rb);
    }

    /* 预先将空间给生产者使用，无锁 */
    rb->array[SC_ATOMIC_GET(rb->write)] = ptr;
    (void) SC_ATOMIC_ADD(rb->write, 1);

#ifdef RINGBUFFER_MUTEX_WAIT
    SCCondSignal(&rb->wait_cond);
#endif
    return 0;
}

/* 消费者 */ 
void *RingBufferSrMw8Get(RingBuffer8 *rb)
{
    void *ptr = NULL;

    /* buffer is empty, wait... */
    /* 判断该缓冲区是否为空，如果是，循环等待。这里判断的依据就是 read write的值会不停的从0-255循环 */
    while (SC_ATOMIC_GET(rb->write) == SC_ATOMIC_GET(rb->read)) {
        /* break out if the engine wants to shutdown */
        if (rb->shutdown != 0)
            return NULL;

        RingBuffer8DoWait(rb);
    }

    /* 如果有数据可读， 直接读取，然后移动写指针 */
    ptr = rb->array[SC_ATOMIC_GET(rb->read)];
    (void) SC_ATOMIC_ADD(rb->read, 1);

#ifdef RINGBUFFER_MUTEX_WAIT
    SCCondSignal(&rb->wait_cond);
#endif
    return ptr;
}


以上代码是256大小的环形缓冲区，，没有加锁的地方，由此可见，其使用过程中，如果缓冲区未满，在多线程并发访问下（读写线程只有一个），不会发生阻塞，效率高


下面再介绍0.8版本的PacketQueue packet_q：

typedef struct PacketQueue_ {
    Packet *top;
    Packet *bot;
    uint16_t len;
    /* 队列锁*/
    SCMutex mutex_q;
    SCCondT cond_q;
#ifdef DBG_PERF
    uint16_t dbg_maxlen;
#endif /* DBG_PERF */
} PacketQueue;


初始化过程在main函数中，在程序启动的时候预先分配MAX_PENDING个数据包 

    int i = 0;
    for (i = 0; i < MAX_PENDING; i++) {
        /* XXX pkt alloc function */
        Packet *p = malloc(sizeof(Packet));
        if (p == NULL) {
            printf("ERROR: malloc failed: %s\n", strerror(errno));
            exit(EXIT_FAILURE);
        }
        memset(p, 0, sizeof(Packet));
        SCMutexInit(&p->mutex_rtv_cnt, NULL);

        PacketEnqueue(&packet_q,p);
    }


/* 从 packet_q队列中取出数据包*/
Packet *SetupPkt (void)
{
    Packet *p = NULL;
    int r = 0;

    /* 此处对packet_q整个队列加锁，其他地方不能访问*/
    r = SCMutexLock(&packet_q.mutex_q);
    p = PacketDequeue(&packet_q);
    r = SCMutexUnlock(&packet_q.mutex_q);

    if (p == NULL) {
        TmqDebugList();

        p = malloc(sizeof(Packet));
        if (p == NULL) {
            printf("ERROR: malloc failed: %s\n", strerror(errno));
            exit(EXIT_FAILURE);
        }

        memset(p, 0, sizeof(Packet));

        r = SCMutexInit(&p->mutex_rtv_cnt, NULL);

        SCLogDebug("allocated a new packet...");
    }

    /* reset the packet csum fields */
    RESET_PACKET_CSUMS(p);

    return p;
}

/*生产者 在调用SetupPkt 将对packet_q整个异步队列进行加锁*/

Packet *TmqhInputPacketpool(ThreadVars *t)
{
    /* XXX */
    Packet *p = SetupPkt();


    SCMutexLock(&mutex_pending);
    pending++;
    //printf("PcapFileCallback: pending %" PRIu32 "\n", pending);
#ifdef DBG_PERF
    if (pending > dbg_maxpending)
        dbg_maxpending = pending;
#endif /* DBG_PERF */
    SCMutexUnlock(&mutex_pending);


/*
 * Disabled because it can enter a 'wait' state, while
 * keeping the nfq queue locked thus making it impossble
 * to free packets, the exact condition we are waiting
 * for. VJ 09-01-16
 *
    SCMutexLock(&mutex_pending);
    if (pending > MAX_PENDING) {
        SCondWait(&cond_pending, &mutex_pending);
    }
    SCMutexUnlock(&mutex_pending);
*/
    return p;
}

/* 消费者 */

void TmqhOutputPacketpool(ThreadVars *t, Packet *p)
{
    PacketQueue *q = &packet_q;
    char proot = 0;

    if (p == NULL)
        return;

    if (IS_TUNNEL_PKT(p)) {
        //printf("TmqhOutputPacketpool: tunnel packet: %p %s\n", p,p->root ? "upper layer":"root");

        /* get a lock */
        SCMutex *m = p->root ? &p->root->mutex_rtv_cnt : &p->mutex_rtv_cnt;
        SCMutexLock(m);

        if (IS_TUNNEL_ROOT_PKT(p)) {
            //printf("TmqhOutputPacketpool: IS_TUNNEL_ROOT_PKT\n");
            if (TUNNEL_PKT_TPR(p) == 0) {
                //printf("TmqhOutputPacketpool: TUNNEL_PKT_TPR(p) == 0\n");
                /* if this packet is the root and there are no
                 * more tunnel packets, enqueue it */

                /* fall through */
            } else {
                //printf("TmqhOutputPacketpool: TUNNEL_PKT_TPR(p) > 0\n");
                /* if this is the root and there are more tunnel
                 * packets, don't add this. It's still referenced
                 * by the tunnel packets, and we will enqueue it
                 * when we handle them */
                p->tunnel_verdicted = 1;
                SCMutexUnlock(m);
                return;
            }
        } else {
            //printf("TmqhOutputPacketpool: NOT IS_TUNNEL_ROOT_PKT\n");
            if (p->root->tunnel_verdicted == 1 && TUNNEL_PKT_TPR(p) == 1) {
                //printf("TmqhOutputPacketpool: p->root->tunnel_verdicted == 1 && TUNNEL_PKT_TPR(p) == 1\n");
                /* the root is ready and we are the last tunnel packet,
                 * lets enqueue them both. */
                TUNNEL_DECR_PKT_TPR_NOLOCK(p);

                /* handle the root */
                //printf("TmqhOutputPacketpool: calling PacketEnqueue for root pkt, p->root %p (%p)\n", p->root, p);
                proot = 1;

                /* fall through */
            } else {
                //printf("TmqhOutputPacketpool: NOT p->root->tunnel_verdicted == 1 && TUNNEL_PKT_TPR(p) == 1 (%" PRIu32 ")\n", TUNNEL_PKT_TPR(p));
                TUNNEL_DECR_PKT_TPR_NOLOCK(p);

                 /* fall through */
            }
        }
        SCMutexUnlock(m);
        //printf("TmqhOutputPacketpool: tunnel stuff done, move on\n");
    }

    FlowDecrUsecnt(t,p);

    if (proot && p->root != NULL) {
        CLEAR_PACKET(p->root);

        SCMutexLock(&q->mutex_q);
        PacketEnqueue(q, p->root);
        SCMutexUnlock(&q->mutex_q);
    }

    CLEAR_PACKET(p);


    /* 对整个异步队列加锁 导致其他线程不能操作，并发下降*/
    SCMutexLock(&q->mutex_q);
    PacketEnqueue(q, p);
    SCMutexUnlock(&q->mutex_q);

    SCMutexLock(&mutex_pending);
    //printf("TmqhOutputPacketpool: pending %" PRIu32 "\n", pending);
    if (pending > 0) {
        pending--;
        if (proot) {
            if (pending > 0) {
                pending--;
            } else {
                printf("TmqhOutputPacketpool: warning, trying to subtract from 0 pending counter (tunnel root).\n");
            }
        }
    } else {
        printf("TmqhOutputPacketpool: warning, trying to subtract from 0 pending counter.\n");
    }
    if (pending <= MAX_PENDING)
        SCCondSignal(&cond_pending);
    SCMutexUnlock(&mutex_pending);
}

suricata 使用 unsigned char 和unsigned short 的大小来定义环形缓冲区的大小，非常巧妙。
以上就是本人对环形缓冲区与异步队列的理解、性能分析、对比，并未对环形缓冲区原理进行介绍。

其定义可以参考以下链接：点击打开链接

guoguangwu
关注
专栏目录
ringbuffer的经典代码
道亦无名
09-30 310
源代码如下： #ifdef HAVE_CONFIG_H #include "config.h" #endif #《ringbuffer.h> #include <stdlib.h> #include <string.h> #include <assert.h> #include <winpr/crt.h> #include <freerdp/log.h> #define TAG FREERDP_TAG("utils.ringbuf
开源IDS suricata源码分析（一、框架）
m0_50638175的博客
09-12 2642
Suricata框架 1. 分析框架设计原则 分析Suricata框架之前，我先假定了一些框架设计原则，属个人总结。Suricata定位高性能的网络IDS，IPS和网络安全监视引擎。其框架设计会要考虑到： 支持高速数据包捕获 支持链路层/网络层/传输层协议解码 维护网络层会话/传输层会话 支持网络层分片重组/传输层分段重组 支持常见应用层协议的识别和解析 支持对常见应用协议的敏感字段进行规则匹配 支持对外输出从流量中还原出的有价值的信息 支持网络流量落盘存储 支持流量过滤 支持条件转发 输入输出/协议识别
Surciata源码分析之IpsNFQ模式（2）
Firedb的专栏
05-19 3562
2. 各模块功能分析   Receive：从NFQUEUE中接收数据包，并将封装在Packet结构中，然后放入下一个缓冲区。   Decode：对数据包进行解码，主要是对数据包头部信息进行分析并保存在Packet结构中。   StreamTCP：对数据包进行TCP流重组。   Detect：检测数据包是否包含入侵行为。   Verdict：对检测后
Surciata源码分析之IpsNFQ模式（1）
Firedb的专栏
05-18 6924
最近看了一下suricata-1.2.1的源代码，加之之前在网上没有搜到关于suricata的分析资料，所以就把看源码时的一些笔记整理了一下，发到网上，供其他对suricata感兴趣的网友参考。由于是第一次在csdn上写技术博客，不足之处还望看到此文章的网友见谅！ 先还是进行简要的介绍一下，Suricata 是一个网络入侵检测和阻止引擎，由开放信息安全基金会以及它说支持的提供商说开发。该引擎是多
suricata源码解析
唐装鼠的主页
09-21 687
初始化suricata实例：程序名设置为程序文件名，其他变量复位。
一个RINGBUFFER的C代码实现
tugouxp的专栏
06-12 734
头文件Makefile测试:严蔚敏数据结构中的循环队列实现。
Suricata源码解析-开启从小白到小白必经之路
最新发布
qq_54078539的博客
05-27 264
Suricata源码分析
suricata:suricata原始码分析和读书笔记
03-23
苏里卡塔suricata原始码分析和读书笔记
入侵检测引擎之 Suricata 源码剖析
梦想专栏
07-06 4722
​ 从上一篇 “浅谈 Suricata”我们可以了解 Suricata 的安装部署大致框架、以及从配置方面谈及的性能优化。这篇文章则从代码角度带您剖析 Suricata。 通过本篇文章，您将了解以下知识点： 收包和解包线程。 Flow-Worker 线程角色。 队列负载均衡。 Detect 线程。 应用协议解析层。 Output 输出层。 代码框架优化。 ​
开源IDS suricata源码分析（协议解析添加流程）
m0_50638175的博客
09-28 6783
Suricata新增协议解析 个人总结，新增协议解析分3步进行 生成新协议的解析模板 修改协议解析器实现 修改输出模块实现 1. 创建协议解析模板 对于新增协议解析，Suricata有脚本可以自动生成框架代码patch，示例解析器，示例输出模块。一般在使用脚本生成模板后，仅需修改解析器实现和输出模块实现即可。 创建pop3协议的解析模板： python scripts/setup-app-layer.py Pop3 命令执后如下文件被修改或创建：（具体内容见附件） 框架代码文件 文件名 修改内
ringBufU:C语言中的Ring-Buffer库，包括对多线程的支持-开源
04-25
Ring-Buffer实例可与元素类型-char-long-long long-void *一起使用。 重点是通过缓冲区实例指针检查（不是很快速，但是更安全）来强化SW结构。 某些功能在编译时可以全局选择（例如，完全关闭多线程支持以更快地访问）。 注意：用户界面仅适用于测试和辅导员代码。
RingBuffer
12-20
能懂则懂的RingBuffer,Good luck!
ringbuffer
01-25
采用ringbuffer 的读写指针来控制读写
环形缓冲区实现类(RingBuffer)
09-01
环形缓冲区实现类(RingBuffer)
suricata的Decode协议解码流程源码分析
每天分享一个编程小知识
05-22 814
一般报文的解码流程比较简单，先确定报文的起始位置和总长度，这两个值在ReceiveDPDKLoop中PacketSetData函数，将DPDK mbuf的报文起始地址和报文总长度赋值给了suricata报文Pakcet结构体的ext_pkt和pktlen。DPDK解码流程的函数入口是DecodeDPDK，解码流程按照以太网层、网络层、传输层以及负载一层层找到报文中指定的位置，并且记录相关字段，最后在FlowSetupPacket函数中根据建流的需要打上相应的标记以及计算出流表的哈希值。
ring buffer简单原理及c代码实现
strengthen2324的博客
11-17 2499
环形存储（ring buffer）：一个头尾相连的buffer，根据head索引确定写入位置，根据tail索引确定读出位置，读写时head、tail索引各自递增，不够空间且有新数据要写入时，覆盖旧数据。 下图演示了创建/初始化长度12、写4bytes数据、读2bytes数据时，ring buffer的head、tail索引变化情况。 //因此使用ring buffer关键因素是数据缓冲区、数据缓冲区长度、head索引、tail索引 typedef struct { char *buff;
suricata 3.1 源码分析3
superbfly的专栏
08-30 2877
继续main函数下面的内容。/* By default use IDS mode, but if nfq or ipfw * are specified, IPS mode will overwrite this */EngineModeSetIDS(); 初始化引擎模式为IDS模式，字面上是这么理解。反正这个模式只有IPS和IDS两种，如果不清楚可以上网查。我这里就说一下主要区
suricata 3.1 源码分析21 （数据包处理1）
superbfly的专栏
09-26 2095
进一步的数据包处理是在TmThreadsSlotProcessPkt中完成，其原型为： static inline TmEcode TmThreadsSlotProcessPkt(ThreadVars *tv, TmSlot *s, Packet *p) 其中，s就是前面一路传下来的slot，而p为当前要处理的Packet。/** * \brief Process the r
suricata 3.1 源码分析36 （dns解析获取相关内容）
superbfly的专栏
03-02 1590
在app-layer-dns-udp.c文件的DNSUDPRequestParse函数中调用DNSStoreQueryInState函数，该函数在app-layer-dns-common.c文件中。DNSStoreQueryInState中会取dns信息，包括type, class, name(可以是要查询的host)fqdn指向dns中的name，fqdn_len为name的长度。附dns正文结...
suricata源码分析
08-12
2. 规则引擎：Suricata的规则引擎是其核心功能之一，对其源码进行分析需要了解规则引擎的设计思路和实现方式，包括规则的加载、匹配和执行等过程。 3. 异步处理：Suricata使用异步处理机制来提高性能，对其源码进行...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值