aiden
/
suricata
mirror of https://github.com/OISF/suricata
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

threading: remove post_pq argument from 'SlotFunc'

Browse Source 
This was not in use anywhere.
pull/4531/head
Victor Julien 7 years ago
parent f5045af3e3
commit 44d7f636f2
23 changed files with 50 additions and 65 deletions
Show Stats Download Patch File Download Diff File

2
src/detect.c
Unescape Escape View File

@ -1599,7 +1599,7 @@ static void DetectNoFlow(ThreadVars *tv,
* \retval TM_ECODE_FAILED error
* \retval TM_ECODE_OK ok
*/
TmEcode Detect(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
TmEcode Detect(ThreadVars *tv, Packet *p, void *data)
{
DEBUG_VALIDATE_PACKET(p);

2
src/detect.h
Unescape Escape View File

@ -1450,7 +1450,7 @@ SigTableElmt sigmatch_table[DETECT_TBLSIZE];
/** Remember to add the options in SignatureIsIPOnly() at detect.c otherwise it wont be part of a signature group */
/* detection api */
TmEcode Detect(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq);
TmEcode Detect(ThreadVars *tv, Packet *p, void *data);
SigMatch *SigMatchAlloc(void);
Signature *SigFindSignatureBySidGid(DetectEngineCtx *, uint32_t, uint32_t);

12
src/flow-worker.c
Unescape Escape View File

@ -35,6 +35,7 @@
#include "suricata.h"
#include "decode.h"
#include "detect.h"
#include "stream-tcp.h"
#include "app-layer.h"
#include "detect-engine.h"
@ -176,9 +177,6 @@ static TmEcode FlowWorkerThreadDeinit(ThreadVars *tv, void *data)
return TM_ECODE_OK;
}
TmEcode Detect(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq);
TmEcode StreamTcp (ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
static void FlowPruneFiles(Packet *p)
{
if (p->flow && p->flow->alstate) {
@ -191,7 +189,7 @@ static void FlowPruneFiles(Packet *p)
}
}
static TmEcode FlowWorker(ThreadVars *tv, Packet *p, void *data, PacketQueue *preq, PacketQueue *unused)
static TmEcode FlowWorker(ThreadVars *tv, Packet *p, void *data, PacketQueue *preq)
{
FlowWorkerThreadData *fw = data;
void *detect_thread = SC_ATOMIC_GET(fw->detect_thread);
@ -242,7 +240,7 @@ static TmEcode FlowWorker(ThreadVars *tv, Packet *p, void *data, PacketQueue *pr
}
FLOWWORKER_PROFILING_START(p, PROFILE_FLOWWORKER_STREAM);
StreamTcp(tv, p, fw->stream_thread, &fw->pq, NULL);
StreamTcp(tv, p, fw->stream_thread, &fw->pq);
FLOWWORKER_PROFILING_END(p, PROFILE_FLOWWORKER_STREAM);
if (FlowChangeProto(p->flow)) {
@ -259,7 +257,7 @@ static TmEcode FlowWorker(ThreadVars *tv, Packet *p, void *data, PacketQueue *pr
//StreamTcp(tv, x, fw->stream_thread, &fw->pq, NULL);
if (detect_thread != NULL) {
FLOWWORKER_PROFILING_START(x, PROFILE_FLOWWORKER_DETECT);
Detect(tv, x, detect_thread, NULL, NULL);
Detect(tv, x, detect_thread);
FLOWWORKER_PROFILING_END(x, PROFILE_FLOWWORKER_DETECT);
}
@ -286,7 +284,7 @@ static TmEcode FlowWorker(ThreadVars *tv, Packet *p, void *data, PacketQueue *pr
if (detect_thread != NULL) {
FLOWWORKER_PROFILING_START(p, PROFILE_FLOWWORKER_DETECT);
Detect(tv, p, detect_thread, NULL, NULL);
Detect(tv, p, detect_thread);
FLOWWORKER_PROFILING_END(p, PROFILE_FLOWWORKER_DETECT);
}

2
src/respond-reject.c
Unescape Escape View File

@ -56,7 +56,7 @@ void TmModuleRespondRejectRegister (void)
tmm_modules[TMM_RESPONDREJECT].cap_flags = 0; /* libnet is not compat with caps */
}
TmEcode RespondRejectFunc(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
TmEcode RespondRejectFunc(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
int ret = 0;

2
src/respond-reject.h
Unescape Escape View File

@ -30,6 +30,6 @@
#define REJECT_DIR_DST 1
void TmModuleRespondRejectRegister (void);
TmEcode RespondRejectFunc(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
TmEcode RespondRejectFunc(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq);
#endif /* __RESPOND_REJECT_H__ */

4
src/source-af-packet.c
Unescape Escape View File

@ -311,7 +311,7 @@ TmEcode ReceiveAFPLoop(ThreadVars *tv, void *data, void *slot);
TmEcode DecodeAFPThreadInit(ThreadVars *, const void *, void **);
TmEcode DecodeAFPThreadDeinit(ThreadVars *tv, void *data);
TmEcode DecodeAFP(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
TmEcode DecodeAFP(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AFPSetBPFFilter(AFPThreadVars *ptv);
static int AFPGetIfnumByDev(int fd, const char *ifname, int verbose);
@ -2887,7 +2887,7 @@ TmEcode ReceiveAFPThreadDeinit(ThreadVars *tv, void *data)
* \param data pointer that gets cast into AFPThreadVars for ptv
* \param pq pointer to the current PacketQueue
*/
TmEcode DecodeAFP(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
TmEcode DecodeAFP(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
SCEnter();
DecodeThreadVars *dtv = (DecodeThreadVars *)data;

3
src/source-erf-dag.c
Unescape Escape View File

@ -610,8 +610,7 @@ ReceiveErfDagCloseStream(int dagfd, int stream)
* \param pq pointer to the current PacketQueue
*/
TmEcode
DecodeErfDag(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
PacketQueue *postpq)
DecodeErfDag(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
SCEnter();
DecodeThreadVars *dtv = (DecodeThreadVars *)data;

8
src/source-erf-file.c
Unescape Escape View File

@ -68,9 +68,9 @@ TmEcode ReceiveErfFileThreadInit(ThreadVars *, const void *, void **);
void ReceiveErfFileThreadExitStats(ThreadVars *, void *);
TmEcode ReceiveErfFileThreadDeinit(ThreadVars *, void *);
TmEcode DecodeErfFileThreadInit(ThreadVars *, const void *, void **);
TmEcode DecodeErfFileThreadDeinit(ThreadVars *tv, void *data);
TmEcode DecodeErfFile(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
static TmEcode DecodeErfFileThreadInit(ThreadVars *, const void *, void **);
static TmEcode DecodeErfFileThreadDeinit(ThreadVars *tv, void *data);
static TmEcode DecodeErfFile(ThreadVars *, Packet *, void *, PacketQueue *);
/**
* \brief Register the ERF file receiver (reader) module.
@ -275,7 +275,7 @@ TmEcode DecodeErfFileThreadDeinit(ThreadVars *tv, void *data)
* off to the ethernet decoder.
*/
TmEcode
DecodeErfFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
DecodeErfFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
SCEnter();
DecodeThreadVars *dtv = (DecodeThreadVars *)data;

10
src/source-ipfw.c
Unescape Escape View File

@ -131,20 +131,20 @@ static SCMutex ipfw_init_lock;
/* IPFW Prototypes */
void *IPFWGetQueue(int number);
TmEcode ReceiveIPFWThreadInit(ThreadVars *, const void *, void **);
TmEcode ReceiveIPFW(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
TmEcode ReceiveIPFW(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode ReceiveIPFWLoop(ThreadVars *tv, void *data, void *slot);
void ReceiveIPFWThreadExitStats(ThreadVars *, void *);
TmEcode ReceiveIPFWThreadDeinit(ThreadVars *, void *);
TmEcode IPFWSetVerdict(ThreadVars *, IPFWThreadVars *, Packet *);
TmEcode VerdictIPFW(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
TmEcode VerdictIPFW(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode VerdictIPFWThreadInit(ThreadVars *, const void *, void **);
void VerdictIPFWThreadExitStats(ThreadVars *, void *);
TmEcode VerdictIPFWThreadDeinit(ThreadVars *, void *);
TmEcode DecodeIPFWThreadInit(ThreadVars *, const void *, void **);
TmEcode DecodeIPFWThreadDeinit(ThreadVars *tv, void *data);
TmEcode DecodeIPFW(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
TmEcode DecodeIPFW(ThreadVars *, Packet *, void *, PacketQueue *);
/**
* \brief Registration Function for RecieveIPFW.
@ -439,7 +439,7 @@ TmEcode ReceiveIPFWThreadDeinit(ThreadVars *tv, void *data)
* \param data pointer that gets cast into IPFWThreadVars for ptv
* \param pq pointer to the PacketQueue
*/
TmEcode DecodeIPFW(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
TmEcode DecodeIPFW(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
IPV4Hdr *ip4h = (IPV4Hdr *)GET_PKT_DATA(p);
IPV6Hdr *ip6h = (IPV6Hdr *)GET_PKT_DATA(p);
@ -613,7 +613,7 @@ TmEcode IPFWSetVerdict(ThreadVars *tv, IPFWThreadVars *ptv, Packet *p)
* \param data pointer that gets cast into IPFWThreadVars for ptv
* \param pq pointer for the Packet Queue access (Not used)
*/
TmEcode VerdictIPFW(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
TmEcode VerdictIPFW(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
IPFWThreadVars *ptv = (IPFWThreadVars *)data;
TmEcode retval = TM_ECODE_OK;

3
src/source-napatech.c
Unescape Escape View File

@ -542,8 +542,7 @@ TmEcode NapatechStreamThreadDeinit(ThreadVars *tv, void *data)
* \param data pointer that gets cast into PcapThreadVars for ptv
* \param pq pointer to the current PacketQueue
*/
TmEcode NapatechDecode(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
PacketQueue *postpq)
TmEcode NapatechDecode(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
SCEnter();

3
src/source-netmap.c
Unescape Escape View File

@ -746,9 +746,8 @@ static TmEcode DecodeNetmapThreadInit(ThreadVars *tv, const void *initdata, void
* \param p pointer to the current packet
* \param data pointer that gets cast into NetmapThreadVars for ntv
* \param pq pointer to the current PacketQueue
* \param postpq
*/
static TmEcode DecodeNetmap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
static TmEcode DecodeNetmap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
SCEnter();

4
src/source-nflog.c
Unescape Escape View File

@ -75,7 +75,7 @@ void ReceiveNFLOGThreadExitStats(ThreadVars *, void *);
TmEcode DecodeNFLOGThreadInit(ThreadVars *, const void *, void **);
TmEcode DecodeNFLOGThreadDeinit(ThreadVars *tv, void *data);
TmEcode DecodeNFLOG(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
TmEcode DecodeNFLOG(ThreadVars *, Packet *, void *, PacketQueue *);
static int runmode_workers;
@ -501,7 +501,7 @@ void ReceiveNFLOGThreadExitStats(ThreadVars *tv, void *data)
*
* \retval TM_ECODE_OK is always returned
*/
TmEcode DecodeNFLOG(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
TmEcode DecodeNFLOG(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
SCEnter();
IPV4Hdr *ip4h = (IPV4Hdr *)GET_PKT_DATA(p);

8
src/source-nfq.c
Unescape Escape View File

@ -137,11 +137,11 @@ TmEcode ReceiveNFQThreadInit(ThreadVars *, const void *, void **);
TmEcode ReceiveNFQThreadDeinit(ThreadVars *, void *);
void ReceiveNFQThreadExitStats(ThreadVars *, void *);
TmEcode VerdictNFQ(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
TmEcode VerdictNFQ(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode VerdictNFQThreadInit(ThreadVars *, const void *, void **);
TmEcode VerdictNFQThreadDeinit(ThreadVars *, void *);
TmEcode DecodeNFQ(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
TmEcode DecodeNFQ(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode DecodeNFQThreadInit(ThreadVars *, const void *, void **);
TmEcode DecodeNFQThreadDeinit(ThreadVars *tv, void *data);
@ -1199,7 +1199,7 @@ TmEcode NFQSetVerdict(Packet *p)
/**
* \brief NFQ verdict module packet entry function
*/
TmEcode VerdictNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
TmEcode VerdictNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
NFQThreadVars *ntv = (NFQThreadVars *)data;
/* update counters */
@ -1230,7 +1230,7 @@ TmEcode VerdictNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packe
/**
* \brief Decode a packet coming from NFQ
*/
TmEcode DecodeNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
TmEcode DecodeNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
IPV4Hdr *ip4h = (IPV4Hdr *)GET_PKT_DATA(p);

5
src/source-pcap-file.c
Unescape Escape View File

@ -58,8 +58,7 @@ static TmEcode ReceivePcapFileThreadInit(ThreadVars *, const void *, void **);
static void ReceivePcapFileThreadExitStats(ThreadVars *, void *);
static TmEcode ReceivePcapFileThreadDeinit(ThreadVars *, void *);
static TmEcode DecodePcapFile(ThreadVars *, Packet *, void *, PacketQueue *,
PacketQueue *);
static TmEcode DecodePcapFile(ThreadVars *, Packet *, void *, PacketQueue *);
static TmEcode DecodePcapFileThreadInit(ThreadVars *, const void *, void **);
static TmEcode DecodePcapFileThreadDeinit(ThreadVars *tv, void *data);
@ -390,7 +389,7 @@ TmEcode ReceivePcapFileThreadDeinit(ThreadVars *tv, void *data)
static double prev_signaled_ts = 0;
TmEcode DecodePcapFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
static TmEcode DecodePcapFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
SCEnter();
DecodeThreadVars *dtv = (DecodeThreadVars *)data;

4
src/source-pcap.c
Unescape Escape View File

@ -98,7 +98,7 @@ TmEcode ReceivePcapBreakLoop(ThreadVars *tv, void *data);
TmEcode DecodePcapThreadInit(ThreadVars *, const void *, void **);
TmEcode DecodePcapThreadDeinit(ThreadVars *tv, void *data);
TmEcode DecodePcap(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
TmEcode DecodePcap(ThreadVars *, Packet *, void *, PacketQueue *);
/** protect pcap_compile and pcap_setfilter, as they are not thread safe:
* http://seclists.org/tcpdump/2009/q1/62 */
@ -555,7 +555,7 @@ TmEcode ReceivePcapThreadDeinit(ThreadVars *tv, void *data)
* \param data pointer that gets cast into PcapThreadVars for ptv
* \param pq pointer to the current PacketQueue
*/
TmEcode DecodePcap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
TmEcode DecodePcap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
SCEnter();
DecodeThreadVars *dtv = (DecodeThreadVars *)data;

4
src/source-pfring.c
Unescape Escape View File

@ -53,7 +53,7 @@ void ReceivePfringThreadExitStats(ThreadVars *, void *);
TmEcode ReceivePfringThreadDeinit(ThreadVars *, void *);
TmEcode DecodePfringThreadInit(ThreadVars *, const void *, void **);
TmEcode DecodePfring(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
TmEcode DecodePfring(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode DecodePfringThreadDeinit(ThreadVars *tv, void *data);
extern int max_pending_packets;
@ -720,7 +720,7 @@ TmEcode ReceivePfringThreadDeinit(ThreadVars *tv, void *data)
*
* \retval TM_ECODE_OK is always returned
*/
TmEcode DecodePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
TmEcode DecodePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
DecodeThreadVars *dtv = (DecodeThreadVars *)data;

14
src/source-windivert.c
Unescape Escape View File

@ -347,14 +347,12 @@ TmEcode ReceiveWinDivertThreadDeinit(ThreadVars *, void *);
void ReceiveWinDivertThreadExitStats(ThreadVars *, void *);
/* Verdict functions */
TmEcode VerdictWinDivert(ThreadVars *, Packet *, void *, PacketQueue *,
PacketQueue *);
TmEcode VerdictWinDivert(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode VerdictWinDivertThreadInit(ThreadVars *, const void *, void **);
TmEcode VerdictWinDivertThreadDeinit(ThreadVars *, void *);
/* Decode functions */
TmEcode DecodeWinDivert(ThreadVars *, Packet *, void *, PacketQueue *,
PacketQueue *);
TmEcode DecodeWinDivert(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode DecodeWinDivertThreadInit(ThreadVars *, const void *, void **);
TmEcode DecodeWinDivertThreadDeinit(ThreadVars *, void *);
@ -734,8 +732,7 @@ void ReceiveWinDivertThreadExitStats(ThreadVars *tv, void *data)
/**
* \brief WinDivert verdict module packet entry function
*/
TmEcode VerdictWinDivert(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
PacketQueue *postpq)
TmEcode VerdictWinDivert(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq);
{
SCEnter();
@ -859,8 +856,7 @@ TmEcode VerdictWinDivertThreadDeinit(ThreadVars *tv, void *data)
* to differentiate the two, so instead we must check the version and go
* from there.
*/
TmEcode DecodeWinDivert(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
PacketQueue *postpq)
TmEcode DecodeWinDivert(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
SCEnter();
@ -1018,4 +1014,4 @@ void SourceWinDivertRegisterTests()
#endif
}
#endif /* WINDIVERT */
#endif /* WINDIVERT */

2
src/stream-tcp.c
Unescape Escape View File

@ -5177,7 +5177,7 @@ int TcpSessionPacketSsnReuse(const Packet *p, const Flow *f, const void *tcp_ssn
return 0;
}
TmEcode StreamTcp (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
TmEcode StreamTcp (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
StreamTcpThread *stt = (StreamTcpThread *)data;

2
src/stream-tcp.h
Unescape Escape View File

@ -172,7 +172,7 @@ enum {
STREAM_HAS_UNPROCESSED_SEGMENTS_NEED_ONLY_DETECTION = 1,
};
TmEcode StreamTcp (ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
TmEcode StreamTcp (ThreadVars *, Packet *, void *, PacketQueue *);
int StreamNeedsReassembly(const TcpSession *ssn, uint8_t direction);
TmEcode StreamTcpThreadInit(ThreadVars *, void *, void **);
TmEcode StreamTcpThreadDeinit(ThreadVars *tv, void *data);

10
src/tests/detect.c
Unescape Escape View File

@ -3661,7 +3661,7 @@ static int SigTest40NoPacketInspection01(void)
DetectEngineThreadCtxInit(&th_v, (void *)de_ctx,(void *)&det_ctx);
det_ctx->de_ctx = de_ctx;
Detect(&th_v, p, det_ctx, &pq, NULL);
Detect(&th_v, p, det_ctx);
if (PacketAlertCheck(p, 2))
result = 0;
else
@ -4432,20 +4432,20 @@ static int SigTestDetectAlertCounter(void)
StatsSetupPrivate(&tv);
p = UTHBuildPacket((uint8_t *)"boo", strlen("boo"), IPPROTO_TCP);
Detect(&tv, p, det_ctx, NULL, NULL);
Detect(&tv, p, det_ctx);
FAIL_IF_NOT(StatsGetLocalCounterValue(&tv, det_ctx->counter_alerts) == 1);
Detect(&tv, p, det_ctx, NULL, NULL);
Detect(&tv, p, det_ctx);
FAIL_IF_NOT(StatsGetLocalCounterValue(&tv, det_ctx->counter_alerts) == 2);
UTHFreePackets(&p, 1);
p = UTHBuildPacket((uint8_t *)"roo", strlen("roo"), IPPROTO_TCP);
Detect(&tv, p, det_ctx, NULL, NULL);
Detect(&tv, p, det_ctx);
FAIL_IF_NOT(StatsGetLocalCounterValue(&tv, det_ctx->counter_alerts) == 2);
UTHFreePackets(&p, 1);
p = UTHBuildPacket((uint8_t *)"laboosa", strlen("laboosa"), IPPROTO_TCP);
Detect(&tv, p, det_ctx, NULL, NULL);
Detect(&tv, p, det_ctx);
FAIL_IF_NOT(StatsGetLocalCounterValue(&tv, det_ctx->counter_alerts) == 3);
UTHFreePackets(&p, 1);

2
src/tm-modules.h
Unescape Escape View File

@ -49,7 +49,7 @@ typedef struct TmModule_ {
TmEcode (*ThreadDeinit)(ThreadVars *, void *);
/** the packet processing function */
TmEcode (*Func)(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
TmEcode (*Func)(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode (*PktAcqLoop)(ThreadVars *, void *, void *);

6
src/tm-threads.c
Unescape Escape View File

@ -116,12 +116,8 @@ TmEcode TmThreadsSlotVarRun(ThreadVars *tv, Packet *p, TmSlot *slot)
{
for (TmSlot *s = slot; s != NULL; s = s->slot_next) {
PACKET_PROFILING_TMM_START(p, s->tm_id);
PacketQueue *post_pq = &s->slot_post_pq;
if (s->id > 0) {
post_pq = NULL;
}
TmEcode r = s->SlotFunc(tv, p, SC_ATOMIC_GET(s->slot_data),
&s->slot_pre_pq, post_pq);
&s->slot_pre_pq);
PACKET_PROFILING_TMM_END(p, s->tm_id);
/* handle error */

3
src/tm-threads.h
Unescape Escape View File

@ -47,8 +47,7 @@ static inline void SleepUsec(uint64_t usec)
#define TM_QUEUE_NAME_MAX 16
#define TM_THREAD_NAME_MAX 16
typedef TmEcode (*TmSlotFunc)(ThreadVars *, Packet *, void *, PacketQueue *,
PacketQueue *);
typedef TmEcode (*TmSlotFunc)(ThreadVars *, Packet *, void *, PacketQueue *);
typedef struct TmSlot_ {
/* the TV holding this slot */

Write Preview
Loading…
Cancel
Save