stream-tcp-cache.c

Go to the documentation of this file.

/* Copyright (C) 2007-2022 Open Information Security Foundation
 *
 * You can copy, redistribute or modify this Program under the terms of
 * the GNU General Public License version 2 as published by the Free
 * Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * version 2 along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */
 
/**
 * \file
 *
 * \author Victor Julien <victor@inliniac.net>
 */
 
#include "suricata-common.h"
#include "suricata.h"
#include "stream-tcp-private.h"
#include "stream-tcp-cache.h"
#include "util-debug.h"
 
typedef struct TcpPoolCache {
    bool cache_enabled; /**< cache should only be enabled for worker threads */
    TcpSegment *segs_cache[64];
    uint32_t segs_cache_idx;
    uint32_t segs_returns_idx;
    TcpSegment *segs_returns[64];
 
    TcpSession *ssns_cache[64];
    uint32_t ssns_cache_idx;
    uint32_t ssns_returns_idx;
    TcpSession *ssns_returns[64];
} TcpPoolCache;
 
static thread_local TcpPoolCache tcp_pool_cache;
extern PoolThread *ssn_pool;
extern PoolThread *segment_thread_pool;
 
/** \brief enable segment cache. Should only be done for worker threads */
void StreamTcpThreadCacheEnable(void)
{
    tcp_pool_cache.cache_enabled = true;
}
 
void StreamTcpThreadCacheReturnSegment(TcpSegment *seg)
{
    SCEnter();
#ifdef UNITTESTS
    if (RunmodeIsUnittests()) {
        PoolThreadReturn(segment_thread_pool, seg);
        SCReturn;
    }
#endif
 
    /* cache can have segs from any pool id */
    if (tcp_pool_cache.cache_enabled && tcp_pool_cache.segs_cache_idx < 64) {
        tcp_pool_cache.segs_cache[tcp_pool_cache.segs_cache_idx++] = seg;
    } else {
        /* segs_returns should only have a single pool id. If ours is different,
         * flush it. */
        bool flush = false;
        if (tcp_pool_cache.segs_returns_idx &&
                tcp_pool_cache.segs_returns[0]->pool_id != seg->pool_id) {
            flush = true;
        }
        if (tcp_pool_cache.segs_returns_idx == 64) {
            flush = true;
        }
 
        if (flush) {
            PoolThreadId pool_id = tcp_pool_cache.segs_returns[0]->pool_id;
            PoolThreadLock(segment_thread_pool, pool_id);
            for (uint32_t i = 0; i < tcp_pool_cache.segs_returns_idx; i++) {
                TcpSegment *ret_seg = tcp_pool_cache.segs_returns[i];
                PoolThreadReturnRaw(segment_thread_pool, pool_id, ret_seg);
            }
            PoolThreadUnlock(segment_thread_pool, pool_id);
            tcp_pool_cache.segs_returns_idx = 0;
        }
 
        tcp_pool_cache.segs_returns[tcp_pool_cache.segs_returns_idx++] = seg;
    }
}
 
void StreamTcpThreadCacheReturnSession(TcpSession *ssn)
{
    SCEnter();
#ifdef UNITTESTS
    if (RunmodeIsUnittests()) {
        PoolThreadReturn(ssn_pool, ssn);
        SCReturn;
    }
#endif
 
    /* cache can have ssns from any pool id */
    if (tcp_pool_cache.cache_enabled && tcp_pool_cache.ssns_cache_idx < 64) {
        tcp_pool_cache.ssns_cache[tcp_pool_cache.ssns_cache_idx++] = ssn;
    } else {
        /* ssns_returns should only have a single pool id. If ours is different,
         * flush it. */
        bool flush = false;
        if (tcp_pool_cache.ssns_returns_idx &&
                tcp_pool_cache.ssns_returns[0]->pool_id != ssn->pool_id) {
            flush = true;
        }
        if (tcp_pool_cache.ssns_returns_idx == 64) {
            flush = true;
        }
 
        if (flush) {
            PoolThreadId pool_id = tcp_pool_cache.ssns_returns[0]->pool_id;
            PoolThreadLock(ssn_pool, pool_id);
            for (uint32_t i = 0; i < tcp_pool_cache.ssns_returns_idx; i++) {
                TcpSession *ret_ssn = tcp_pool_cache.ssns_returns[i];
                PoolThreadReturnRaw(ssn_pool, pool_id, ret_ssn);
            }
            PoolThreadUnlock(ssn_pool, pool_id);
            tcp_pool_cache.ssns_returns_idx = 0;
        }
 
        tcp_pool_cache.ssns_returns[tcp_pool_cache.ssns_returns_idx++] = ssn;
    }
    SCReturn;
}
 
void StreamTcpThreadCacheCleanup(void)
{
    SCEnter();
 
    /* segments */
    SCLogDebug("tcp_pool_cache.segs_cache_idx %u", tcp_pool_cache.segs_cache_idx);
    for (uint32_t i = 0; i < tcp_pool_cache.segs_cache_idx; i++) {
        PoolThreadReturn(segment_thread_pool, tcp_pool_cache.segs_cache[i]);
    }
    tcp_pool_cache.segs_cache_idx = 0;
 
    SCLogDebug("tcp_pool_cache.segs_returns_idx %u", tcp_pool_cache.segs_returns_idx);
    if (tcp_pool_cache.segs_returns_idx) {
        PoolThreadId pool_id = tcp_pool_cache.segs_returns[0]->pool_id;
        PoolThreadLock(segment_thread_pool, pool_id);
        for (uint32_t i = 0; i < tcp_pool_cache.segs_returns_idx; i++) {
            TcpSegment *ret_seg = tcp_pool_cache.segs_returns[i];
            PoolThreadReturnRaw(segment_thread_pool, pool_id, ret_seg);
        }
        PoolThreadUnlock(segment_thread_pool, pool_id);
        tcp_pool_cache.segs_returns_idx = 0;
    }
 
    /* sessions */
    SCLogDebug("tcp_pool_cache.ssns_cache_idx %u", tcp_pool_cache.ssns_cache_idx);
    for (uint32_t i = 0; i < tcp_pool_cache.ssns_cache_idx; i++) {
        PoolThreadReturn(ssn_pool, tcp_pool_cache.ssns_cache[i]);
    }
    tcp_pool_cache.ssns_cache_idx = 0;
 
    SCLogDebug("tcp_pool_cache.ssns_returns_idx %u", tcp_pool_cache.ssns_returns_idx);
    if (tcp_pool_cache.ssns_returns_idx) {
        PoolThreadId pool_id = tcp_pool_cache.ssns_returns[0]->pool_id;
        PoolThreadLock(ssn_pool, pool_id);
        for (uint32_t i = 0; i < tcp_pool_cache.ssns_returns_idx; i++) {
            TcpSession *ret_ssn = tcp_pool_cache.ssns_returns[i];
            PoolThreadReturnRaw(ssn_pool, pool_id, ret_ssn);
        }
        PoolThreadUnlock(ssn_pool, pool_id);
        tcp_pool_cache.ssns_returns_idx = 0;
    }
 
    SCReturn;
}
 
TcpSegment *StreamTcpThreadCacheGetSegment(void)
{
    if (tcp_pool_cache.segs_cache_idx) {
        TcpSegment *seg = tcp_pool_cache.segs_cache[tcp_pool_cache.segs_cache_idx - 1];
        tcp_pool_cache.segs_cache_idx--;
        memset(&seg->sbseg, 0, sizeof(seg->sbseg));
        return seg;
    }
    return NULL;
}
 
TcpSession *StreamTcpThreadCacheGetSession(void)
{
    if (tcp_pool_cache.ssns_cache_idx) {
        TcpSession *ssn = tcp_pool_cache.ssns_cache[tcp_pool_cache.ssns_cache_idx - 1];
        tcp_pool_cache.ssns_cache_idx--;
        return ssn;
    }
    return NULL;
}