Go to the documentation of this file.
50 #ifdef PROFILE_LOCKING
70 #include <sys/param.h>
71 #include <sys/resource.h>
72 #include <sys/cpuset.h>
74 #define cpu_set_t cpuset_t
78 static int SetCPUAffinity(uint16_t cpu);
117 while (decode_pq->
top != NULL) {
123 if (TmThreadsSlotProcessPkt(
tv, slot, extra_p) !=
TM_ECODE_OK) {
144 TmThreadsSlotProcessPktFail(
tv, NULL);
188 r = TmThreadsSlotProcessPkt(
tv, fw_slot, p);
220 if (slot->SlotThreadInit != NULL) {
221 void *slot_data = NULL;
222 TmEcode r = slot->SlotThreadInit(
tv, slot->slot_initdata, &slot_data);
291 if (slot->SlotThreadExitPrintStats != NULL) {
295 if (slot->SlotThreadDeinit != NULL) {
310 static void *TmThreadsSlotPktAcqLoop(
void *td)
318 SCLogError(
"TmSlot or ThreadVars badly setup: s=%p,"
319 " PktAcqLoop=%p, tmqh_in=%p,"
327 if (!TmThreadsSlotPktAcqLoopInit(td)) {
352 pthread_exit((
void *) 0);
381 static void *TmThreadsLib(
void *td)
388 SCLogError(
"TmSlot or ThreadVars badly setup: s=%p, tmqh_in=%p,"
395 if (!TmThreadsSlotPktAcqLoopInit(
tv)) {
410 static void *TmThreadsSlotVar(
void *td)
437 void *slot_data = NULL;
517 TmThreadsHandleInjectedPackets(
tv);
538 static void *TmThreadsManagement(
void *td)
557 void *slot_data = NULL;
598 pthread_exit((
void *) 0);
616 printf(
"Both slot name and function pointer can't be NULL inside "
617 "TmThreadSetSlots\n");
624 if (strcmp(
name,
"varslot") == 0) {
626 }
else if (strcmp(
name,
"pktacqloop") == 0) {
628 }
else if (strcmp(
name,
"management") == 0) {
630 }
else if (strcmp(
name,
"command") == 0) {
632 }
else if (strcmp(
name,
"lib") == 0) {
634 }
else if (strcmp(
name,
"custom") == 0) {
639 printf(
"Error: Slot \"%s\" not supported\n",
name);
702 #if !defined __CYGWIN__ && !defined OS_WIN32 && !defined __OpenBSD__ && !defined sun
703 static int SetCPUAffinitySet(cpu_set_t *cs)
705 #if defined OS_FREEBSD
706 int r = cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID,
709 int r = thread_policy_set(mach_thread_self(), THREAD_AFFINITY_POLICY,
710 (
void*)cs, THREAD_AFFINITY_POLICY_COUNT);
712 pid_t tid = (pid_t)syscall(SYS_gettid);
713 int r = sched_setaffinity(tid,
sizeof(cpu_set_t), cs);
717 printf(
"Warning: sched_setaffinity failed (%" PRId32
"): %s\n", r,
734 static int SetCPUAffinity(uint16_t cpuid)
736 #if defined __OpenBSD__ || defined sun
739 int cpu = (int)cpuid;
741 #if defined OS_WIN32 || defined __CYGWIN__
744 int r = (0 == SetThreadAffinityMask(GetCurrentThread(), cs));
746 printf(
"Warning: sched_setaffinity failed (%" PRId32
"): %s\n", r,
750 SCLogDebug(
"CPU Affinity for thread %lu set to CPU %" PRId32,
757 memset(&cs, 0,
sizeof(cs));
761 return SetCPUAffinitySet(&cs);
793 tv->
name, strerror(errno));
795 SCLogDebug(
"Priority set to %"PRId32
" for thread %s",
805 SCLogDebug(
"Nice value set to %"PRId32
" for thread %s",
866 SCLogPerf(
"Setting affinity for thread \"%s\"to cpu/core "
872 #if !defined __CYGWIN__ && !defined OS_WIN32 && !defined __OpenBSD__ && !defined sun
885 }
else if (CPU_ISSET(cpu, &taf->
hiprio_cpu)) {
890 SCLogPerf(
"Setting prio %d for thread \"%s\" to cpu/core "
894 SetCPUAffinitySet(&taf->
cpu_set);
896 SCLogPerf(
"Setting prio %d for thread \"%s\", "
923 const char *outq_name,
const char *outqh_name,
const char *slots,
924 void * (*fn_p)(
void *),
int mucond)
946 if (inq_name != NULL && strcmp(inq_name,
"packetpool") != 0) {
961 if (inqh_name != NULL) {
978 if (outqh_name != NULL) {
993 if (outq_name != NULL && strcmp(outq_name,
"packetpool") != 0) {
1053 const char *inqh_name,
const char *outq_name,
1054 const char *outqh_name,
const char *slots)
1184 if (t->
next == NULL) {
1254 if (
tv->
inq != NULL) {
1284 pthread_join(
tv->
t, NULL);
1308 static void TmThreadDrainPacketThreads(
void)
1311 struct timeval start_ts;
1312 struct timeval cur_ts;
1313 gettimeofday(&start_ts, NULL);
1316 gettimeofday(&cur_ts, NULL);
1317 if ((cur_ts.tv_sec - start_ts.tv_sec) > 60) {
1319 "to process their packets in time");
1328 if (ThreadStillHasPackets(
tv)) {
1338 if (ThreadBusy(
tv)) {
1372 struct timeval start_ts;
1373 struct timeval cur_ts;
1374 gettimeofday(&start_ts, NULL);
1377 gettimeofday(&cur_ts, NULL);
1378 if ((cur_ts.tv_sec - start_ts.tv_sec) > 60) {
1379 FatalError(
"Engine unable to disable detect "
1380 "thread - \"%s\". Killing engine",
1398 while (slots != NULL) {
1411 if (ThreadStillHasPackets(
tv)) {
1421 if (ThreadBusy(
tv)) {
1446 if (
tv->
inq != NULL) {
1473 TmThreadDrainPacketThreads();
1476 #ifdef DEBUG_VALIDATION
1477 static void TmThreadDumpThreads(
void);
1480 static void TmThreadDebugValidateNoMorePackets(
void)
1482 #ifdef DEBUG_VALIDATION
1485 if (ThreadStillHasPackets(
tv)) {
1487 TmThreadDumpThreads();
1509 struct timeval start_ts;
1510 struct timeval cur_ts;
1513 TmThreadDrainPacketThreads();
1518 TmThreadDebugValidateNoMorePackets();
1520 gettimeofday(&start_ts, NULL);
1522 gettimeofday(&cur_ts, NULL);
1523 if ((cur_ts.tv_sec - start_ts.tv_sec) > 60) {
1524 FatalError(
"Engine unable to disable packet "
1525 "threads. Killing engine");
1536 if (
tv->
inq != NULL) {
1556 #define MIN_WAIT_TIME 100
1557 #define MAX_WAIT_TIME 999999
1570 int r = TmThreadKillThread(
tv);
1584 #undef MIN_WAIT_TIME
1585 #undef MAX_WAIT_TIME
1591 for (i = 0; i <
TVT_MAX; i++) {
1614 TmThreadDeinitMC(
tv);
1643 char *thread_group_name = NULL;
1652 if (
unlikely(thread_group_name == NULL)) {
1664 if ((family < 0) || (family >=
TVT_MAX))
1686 pthread_attr_t attr;
1692 pthread_attr_init(&attr);
1694 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
1700 FatalError(
"Unable to increase stack size to %" PRIu64
" in thread attributes",
1707 FatalError(
"Unable to create thread %s with pthread_create(): retval %d: %s",
tv->
name, rc,
1711 #if DEBUG && HAVE_PTHREAD_GETATTR_NP
1713 if (pthread_getattr_np(
tv->
t, &attr) == 0) {
1716 pthread_attr_getstack(&attr, &stack_addr, &stack_size);
1717 SCLogDebug(
"stack: %p; size %" PRIu64, stack_addr, (uintmax_t)stack_size);
1719 SCLogDebug(
"Unable to retrieve current stack-size for display; return code from "
1720 "pthread_getattr_np() is %" PRId32,
1740 printf(
"ERROR: no thread function set\n");
1764 FatalError(
"Fatal error encountered in TmThreadInitMC. "
1769 printf(
"Error initializing the tv->m mutex\n");
1774 FatalError(
"Fatal error encountered in TmThreadInitMC. "
1779 FatalError(
"Error initializing the tv->cond condition "
1819 static TmEcode WaitOnThreadsRunningByType(
const int t)
1821 struct timeval start_ts;
1822 struct timeval cur_ts;
1823 uint32_t thread_cnt = 0;
1834 uint32_t time_budget = 60 + thread_cnt;
1836 gettimeofday(&start_ts, NULL);
1840 while (
tv != NULL) {
1845 "start: flags %04x",
1855 gettimeofday(&cur_ts, NULL);
1856 if (((uint32_t)cur_ts.tv_sec - (uint32_t)start_ts.tv_sec) > time_budget) {
1858 "start in time: flags %04x. Total threads: %u. Time budget %us",
1883 uint16_t RX_num = 0;
1885 uint16_t FM_num = 0;
1886 uint16_t FR_num = 0;
1887 uint16_t TX_num = 0;
1889 for (
int i = 0; i <
TVT_MAX; i++) {
1895 for (
int i = 0; i <
TVT_MAX; i++) {
1913 uint16_t app_len = 32;
1914 uint16_t buf_len = 256;
1916 char append_str[app_len];
1917 char thread_counts[buf_len];
1919 strlcpy(thread_counts,
"Threads created -> ", strlen(
"Threads created -> ") + 1);
1921 snprintf(append_str, app_len,
"RX: %u ", RX_num);
1922 strlcat(thread_counts, append_str, buf_len);
1925 snprintf(append_str, app_len,
"W: %u ", W_num);
1926 strlcat(thread_counts, append_str, buf_len);
1929 snprintf(append_str, app_len,
"TX: %u ", TX_num);
1930 strlcat(thread_counts, append_str, buf_len);
1933 snprintf(append_str, app_len,
"FM: %u ", FM_num);
1934 strlcat(thread_counts, append_str, buf_len);
1937 snprintf(append_str, app_len,
"FR: %u ", FR_num);
1938 strlcat(thread_counts, append_str, buf_len);
1940 snprintf(append_str, app_len,
" Engine started.");
1941 strlcat(thread_counts, append_str, buf_len);
1953 for (
int i = 0; i <
TVT_MAX; i++) {
1955 while (
tv != NULL) {
1969 for (
int i = 0; i <
TVT_MAX; i++) {
1991 struct timeval start_ts;
1992 struct timeval cur_ts;
1993 gettimeofday(&start_ts, NULL);
1997 for (
int i = 0; i <
TVT_MAX; i++) {
1999 while (
tv != NULL) {
2004 "initialize: flags %04x",
2012 gettimeofday(&cur_ts, NULL);
2013 if ((cur_ts.tv_sec - start_ts.tv_sec) > 120) {
2015 "initialize in time: flags %04x",
2056 for (
int i = 0; i <
TVT_MAX; i++) {
2058 while (
tv != NULL) {
2069 #ifdef DEBUG_VALIDATION
2079 static void TmThreadDumpThreads(
void)
2082 for (
int i = 0; i <
TVT_MAX; i++) {
2084 while (
tv != NULL) {
2086 SCLogNotice(
"tv %p: type %u name %s tmm_flags %02X flags %X stream_pq %p",
2092 SCLogNotice(
"tv %p: ==> stream_pq_local: pq.len %u packet src %s",
2097 SCLogNotice(
"tv %p: ==> decode_pq: decode_pq.len %u packet src %s",
2100 TmThreadDoDumpSlots(
tv);
2123 typedef struct Threads_ {
2125 size_t threads_size;
2129 static bool thread_store_sealed =
false;
2130 static Threads thread_store = { NULL, 0, 0 };
2137 thread_store_sealed =
true;
2145 thread_store_sealed =
false;
2152 for (
size_t s = 0; s < thread_store.threads_size; s++) {
2153 Thread *t = &thread_store.threads[s];
2154 if (t == NULL || t->in_use == 0)
2157 SCLogNotice(
"Thread %"PRIuMAX
", %s type %d, tv %p in_use %d",
2158 (uintmax_t)s+1, t->name, t->type, t->tv, t->in_use);
2162 SCLogNotice(
"tv %p type %u name %s tmm_flags %02X flags %X",
2177 if (thread_store.threads == NULL) {
2179 BUG_ON(thread_store.threads == NULL);
2180 thread_store.threads_size =
STEP;
2184 for (s = 0; s < thread_store.threads_size; s++) {
2185 if (thread_store.threads[s].in_use == 0) {
2186 Thread *t = &thread_store.threads[s];
2201 void *newmem =
SCRealloc(thread_store.threads, ((thread_store.threads_size +
STEP) *
sizeof(Thread)));
2203 thread_store.threads = newmem;
2204 memset((uint8_t *)thread_store.threads + (thread_store.threads_size *
sizeof(Thread)), 0x00,
STEP *
sizeof(Thread));
2206 Thread *t = &thread_store.threads[thread_store.threads_size];
2215 s = thread_store.threads_size;
2216 thread_store.threads_size +=
STEP;
2227 if (id <= 0 || id > (
int)thread_store.threads_size) {
2236 thread_store.threads[idx].in_use = 0;
2240 for (s = 0; s < thread_store.threads_size; s++) {
2241 Thread *t = &thread_store.threads[s];
2242 if (t->in_use == 1) {
2248 SCFree(thread_store.threads);
2249 thread_store.threads = NULL;
2250 thread_store.threads_size = 0;
2251 thread_store.threads_cnt = 0;
2261 Thread *t = &thread_store.threads[idx];
2266 if (t->sys_sec_stamp.secs != 0) {
2269 SCLogDebug(
"%s: thread slept for %u secs", t->name, (uint32_t)(now.
secs - tmpts.
secs));
2274 t->sys_sec_stamp = now;
2282 for (
size_t s = 0; s < thread_store.threads_size; s++) {
2283 Thread *t = &thread_store.threads[s];
2305 for (
size_t s = 0; s < thread_store.threads_size; s++) {
2306 Thread *t = &thread_store.threads[s];
2316 t->sys_sec_stamp = now;
2324 const int i = idx - 1;
2325 Thread *t = &thread_store.threads[i];
2331 struct timeval local = { 0 };
2336 for (
size_t s = 0; s < thread_store.threads_size; s++) {
2337 Thread *t = &thread_store.threads[s];
2338 if (t->in_use == 0) {
2367 SCLogDebug(
"ts->tv_sec %"PRIuMAX, (uintmax_t)
ts->tv_sec);
2375 if (thread_max == 0)
2379 if (thread_max > 1024) {
2380 SCLogWarning(
"limited number of 'worker' threads to 1024. Wanted %d", thread_max);
2383 return (uint16_t)thread_max;
2390 if (
id > 0 &&
id <= (
int)thread_store.threads_size) {
2392 Thread *t = &thread_store.threads[idx];
2398 if (
tv->
inq != NULL) {
2403 TmThreadsCaptureBreakLoop(
tv);
const char * thread_name_workers
TmEcode TmThreadSetCPUAffinity(ThreadVars *tv, uint16_t cpu)
Set the thread options (cpu affinity).
bool SCTmThreadsSlotPacketLoopFinish(ThreadVars *tv)
struct FlowQueue_ * flow_queue
bool TmThreadsTimeSubsysIsReady(void)
void TmThreadInitMC(ThreadVars *tv)
Initializes the mutex and condition variables for this TV.
void TmThreadsSealThreads(void)
thread_local uint64_t spin_lock_cnt
TmEcode TmThreadLibSpawn(ThreadVars *tv)
Spawns a "fake" lib thread associated with the ThreadVars instance tv.
TmEcode TmThreadsSlotVarRun(ThreadVars *tv, Packet *p, TmSlot *slot)
Separate run function so we can call it recursively.
TmEcode TmThreadSpawn(ThreadVars *tv)
Spawns a thread associated with the ThreadVars instance tv.
ThreadVars * TmThreadCreateMgmtThreadByName(const char *name, const char *module, int mucond)
Creates and returns the TV instance for a Management thread(MGMT). This function supports only custom...
int TmqhNameToID(const char *name)
bool threading_set_cpu_affinity
TmEcode TmThreadSetupOptions(ThreadVars *tv)
Set the thread options (cpu affinitythread). Priority should be already set by pthread_create.
#define SCTIME_CMP_NEQ(a, b)
const char * thread_name_flow_mgr
SC_ATOMIC_DECLARE(SCTime_t, pktts)
#define SC_ATOMIC_INIT(name)
wrapper for initializing an atomic variable.
void TmThreadContinueThreads(void)
Unpauses all threads present in tv_root.
ThreadVars * TmThreadCreatePacketHandler(const char *name, const char *inq_name, const char *inqh_name, const char *outq_name, const char *outqh_name, const char *slots)
Creates and returns a TV instance for a Packet Processing Thread. This function doesn't support custo...
#define SC_ATOMIC_SET(name, val)
Set the value for the atomic variable.
#define SCCtrlMutexDestroy
void TmThreadSetGroupName(ThreadVars *tv, const char *name)
void CaptureStatsSetup(ThreadVars *tv)
thread_local uint64_t rwr_lock_cnt
void TmThreadsSetFlag(ThreadVars *tv, uint32_t flag)
Set a thread flag.
void TmThreadWaitForFlag(ThreadVars *tv, uint32_t flags)
Waits till the specified flag(s) is(are) set. We don't bother if the kill flag has been set or not on...
void PacketEnqueue(PacketQueue *q, Packet *p)
simple fifo queue for packets with mutex and cond Calling the mutex or triggering the cond is respons...
@ PKT_SRC_CAPTURE_TIMEOUT
void TmThreadsUnsealThreads(void)
#define SCSetThreadName(n)
const char * thread_name_flow_rec
void(* OutHandler)(ThreadVars *, Packet *)
uint32_t TmThreadCountThreadsByTmmFlags(uint8_t flags)
returns a count of all the threads that match the flag
const char * thread_name_autofp
int StatsSetupPrivate(ThreadVars *tv)
struct PacketQueue_ * stream_pq_local
ThreadVars * tv_root[TVT_MAX]
void TmThreadDisableReceiveThreads(void)
Disable all threads having the specified TMs.
#define SCCtrlCondDestroy
#define SCMUTEX_INITIALIZER
TmEcode TmThreadSetThreadPriority(ThreadVars *tv, int prio)
Set the thread options (thread priority).
#define SCTIME_CMP_EQ(a, b)
bool(* ThreadBusy)(ThreadVars *tv, void *thread_data)
#define THREAD_SET_PRIORITY
void TmqhOutputPacketpool(ThreadVars *t, Packet *p)
thread_local uint64_t rww_lock_contention
simple fifo queue for packets
void FlowEnqueue(FlowQueue *q, Flow *f)
add a flow to a queue
SCTime_t TmThreadsGetThreadTime(const int idx)
TmEcode(* PktAcqLoop)(ThreadVars *, void *, void *)
void PacketPoolInit(void)
Packet *(* InHandler)(ThreadVars *)
void TmThreadsInjectFlowById(Flow *f, const int id)
inject a flow into a threads flow queue
thread_local uint64_t rwr_lock_contention
void TmThreadsGetMinimalTimestamp(struct timeval *ts)
size_t strlcpy(char *dst, const char *src, size_t siz)
TmEcode TmThreadsProcessDecodePseudoPackets(ThreadVars *tv, PacketQueueNoLock *decode_pq, TmSlot *slot)
TmEcode(* ThreadDeinit)(ThreadVars *, void *)
TmModule * TmModuleGetByName(const char *name)
get a tm module ptr by name
thread_local uint64_t spin_lock_wait_ticks
#define PKT_SET_SRC(p, src_val)
void TmThreadsUnsetFlag(ThreadVars *tv, uint32_t flag)
Unset a thread flag.
void(* InShutdownHandler)(ThreadVars *)
void TmThreadSetPrio(ThreadVars *tv)
Adjusting nice value for threads.
void TmThreadContinue(ThreadVars *tv)
Unpauses a thread.
uint16_t AffinityGetNextCPU(ThreadsAffinityType *taf)
Return next cpu to use for a given thread family.
TmEcode(* PktAcqLoop)(ThreadVars *, void *, void *)
TmEcode TmThreadWaitOnThreadInit(void)
Used to check if all threads have finished their initialization. On finding an un-initialized thread,...
TmEcode(* PktAcqBreakLoop)(ThreadVars *, void *)
size_t strlcat(char *, const char *src, size_t siz)
struct TmSlot_ * tm_slots
Packet * PacketDequeueNoLock(PacketQueueNoLock *qnl)
TmEcode(* Management)(ThreadVars *, void *)
#define SCMutexUnlock(mut)
uint64_t threading_set_stack_size
StatsPublicThreadContext perf_public_ctx
#define PKT_PSEUDO_STREAM_END
void TmThreadsSetThreadTimestamp(const int id, const SCTime_t ts)
thread_local uint64_t rww_lock_cnt
Per thread variable structure.
thread_local uint64_t mutex_lock_contention
#define SCTIME_FROM_TIMEVAL(tv)
Tmq * TmqGetQueueByName(const char *name)
TmEcode(* Management)(ThreadVars *, void *)
thread_local uint64_t spin_lock_contention
TmEcode(* Func)(ThreadVars *, Packet *, void *)
void TmThreadClearThreadsFamily(int family)
#define THV_REQ_FLOW_LOOP
ThreadVars * TmThreadCreate(const char *name, const char *inq_name, const char *inqh_name, const char *outq_name, const char *outqh_name, const char *slots, void *(*fn_p)(void *), int mucond)
Creates and returns the TV instance for a new thread.
FlowQueue * FlowQueueNew(void)
const char * PktSrcToString(enum PktSrcEnum pkt_src)
void TmThreadsUnregisterThread(const int id)
int TmThreadsRegisterThread(ThreadVars *tv, const int type)
#define SCLogWarning(...)
Macro used to log WARNING messages.
void(* OutHandlerCtxFree)(void *)
struct Thread_ __attribute__((aligned(CLS)))
struct ThreadVars_ * next
#define SCTIME_TO_TIMEVAL(tv, t)
int TmThreadTimeoutLoop(ThreadVars *tv, TmSlot *s)
int TmModuleGetIDForTM(TmModule *tm)
Given a TM Module, returns its id.
#define SCCtrlMutexLock(mut)
void TmThreadKillThreads(void)
#define PACKET_PROFILING_TMM_END(p, id)
#define TM_FLAG_DECODE_TM
TmModule * TmModuleGetById(int id)
Returns a TM Module by its id.
uint8_t thread_setup_flags
thread_local uint64_t rww_lock_wait_ticks
ThreadVars * TmThreadCreateMgmtThread(const char *name, void *(fn_p)(void *), int mucond)
Creates and returns the TV instance for a Management thread(MGMT). This function supports only custom...
thread_local uint64_t rwr_lock_wait_ticks
#define SCMutexInit(mut, mutattrs)
#define TM_FLAG_RECEIVE_TM
void TmThreadDisablePacketThreads(const uint16_t set, const uint16_t check)
Disable all packet threads.
#define SCGetThreadIdLong(...)
#define SCRealloc(ptr, sz)
void TmThreadsInitThreadsTimestamp(const SCTime_t ts)
struct PacketQueue_ * stream_pq
#define SCTIME_CMP_LT(a, b)
void TmSlotSetFuncAppend(ThreadVars *tv, TmModule *tm, const void *data)
Appends a new entry to the slots.
#define SCCtrlMutexUnlock(mut)
void TmThreadKillThreadsFamily(int family)
void TmThreadAppend(ThreadVars *tv, int type)
Appends this TV to tv_root based on its type.
TmEcode TmThreadSetCPU(ThreadVars *tv, uint8_t type)
ThreadsAffinityType thread_affinity[MAX_CPU_SET]
void(* tmqh_out)(struct ThreadVars_ *, struct Packet_ *)
bool TmThreadsWaitForUnpause(ThreadVars *tv)
Wait for a thread to become unpaused.
struct TmSlot_ * tm_flowworker
int TmThreadGetNbThreads(uint8_t type)
TmEcode(* SlotThreadInit)(ThreadVars *, const void *, void **)
TmEcode(* ThreadInit)(ThreadVars *, const void *, void **)
const void * slot_initdata
uint16_t TmThreadsGetWorkerThreadMax(void)
ThreadVars * TmThreadCreateCmdThreadByName(const char *name, const char *module, int mucond)
Creates and returns the TV instance for a Command thread (CMD). This function supports only custom sl...
void StatsSyncCounters(ThreadVars *tv)
unsigned int ThreadStorageSize(void)
#define THREAD_SET_AFFTYPE
void(* ThreadExitPrintStats)(ThreadVars *, void *)
Packet * PacketDequeue(PacketQueue *q)
Packet * PacketGetFromAlloc(void)
Get a malloced packet.
void SCThreadRunInitCallbacks(ThreadVars *tv)
thread_local uint64_t mutex_lock_wait_ticks
#define PACKET_PROFILING_TMM_START(p, id)
struct Packet_ *(* tmqh_in)(struct ThreadVars_ *)
void *(* OutHandlerCtxSetup)(const char *)
#define SCLogError(...)
Macro used to log ERROR messages.
Tmq * TmqCreateQueue(const char *name)
TmEcode(* SlotThreadDeinit)(ThreadVars *, void *)
const char * thread_name_verdict
void(* SlotThreadExitPrintStats)(ThreadVars *, void *)
Tmqh * TmqhGetQueueHandlerByID(const int id)
#define SC_ATOMIC_INITPTR(name)
PacketQueueNoLock decode_pq
#define SCCtrlMutexInit(mut, mutattr)
void EngineDone(void)
Used to indicate that the current task is done.
#define THREAD_SET_AFFINITY
TmEcode TmThreadWaitOnThreadRunning(void)
Waits for all threads to be in a running state.
void TmThreadsListThreads(void)
struct TmSlot_ * slot_next
void TmThreadCheckThreadState(void)
Used to check the thread for certain conditions of failure.
void ThreadFreeStorage(ThreadVars *tv)
#define SC_ATOMIC_GET(name)
Get the value from the atomic variable.
uint16_t UtilCpuGetNumProcessorsOnline(void)
Get the number of cpus online in the system.
void PacketPoolDestroy(void)
thread_local uint64_t mutex_lock_cnt
int TmThreadsCheckFlag(ThreadVars *tv, uint32_t flag)
Check if a thread flag is set.
#define SCTIME_INITIALIZER
#define SCLogNotice(...)
Macro used to log NOTICE messages.
#define SCTIME_ADD_SECS(ts, s)
Tmqh * TmqhGetQueueHandlerByName(const char *name)
void StatsThreadCleanup(ThreadVars *tv)
void *(* tm_func)(void *)
Packet * PacketGetFromQueueOrAlloc(void)
Get a packet. We try to get a packet from the packetpool first, but if that is empty we alloc a packe...
#define DEBUG_VALIDATE_BUG_ON(exp)
float threading_detect_ratio
#define SC_ATOMIC_AND(name, val)
Bitwise AND a value to our atomic variable.
volatile uint8_t suricata_ctl_flags
#define SC_ATOMIC_OR(name, val)
Bitwise OR a value to our atomic variable.