Go to the documentation of this file.
48 #ifdef PROFILE_LOCKING
68 #include <sys/param.h>
69 #include <sys/resource.h>
70 #include <sys/cpuset.h>
72 #define cpu_set_t cpuset_t
76 static int SetCPUAffinity(uint16_t cpu);
115 while (decode_pq->
top != NULL) {
121 if (TmThreadsSlotProcessPkt(
tv, slot, extra_p) !=
TM_ECODE_OK) {
142 TmThreadsSlotProcessPktFail(
tv, s, NULL);
186 r = TmThreadsSlotProcessPkt(
tv, fw_slot, p);
232 static void *TmThreadsSlotPktAcqLoop(
void *td)
252 SCLogError(
"TmSlot or ThreadVars badly setup: s=%p,"
253 " PktAcqLoop=%p, tmqh_in=%p,"
257 pthread_exit((
void *) -1);
261 for (slot = s; slot != NULL; slot = slot->
slot_next) {
263 void *slot_data = NULL;
286 pthread_exit((
void *) -1);
301 pthread_exit((
void *) -1);
336 TmThreadTimeoutLoop(
tv, s);
343 for (slot = s; slot != NULL; slot = slot->
slot_next) {
360 pthread_exit((
void *) 0);
365 pthread_exit((
void *) -1);
369 static void *TmThreadsSlotVar(
void *td)
391 pthread_exit((
void *) -1);
397 void *slot_data = NULL;
417 pthread_exit((
void *) -1);
432 pthread_exit((
void *) -1);
482 TmThreadsHandleInjectedPackets(
tv);
515 pthread_exit((
void *) 0);
520 pthread_exit((
void *) -1);
524 static void *TmThreadsManagement(
void *td)
543 void *slot_data = NULL;
547 pthread_exit((
void *) -1);
578 pthread_exit((
void *) -1);
584 pthread_exit((
void *) 0);
602 printf(
"Both slot name and function pointer can't be NULL inside "
603 "TmThreadSetSlots\n");
610 if (strcmp(name,
"varslot") == 0) {
612 }
else if (strcmp(name,
"pktacqloop") == 0) {
614 }
else if (strcmp(name,
"management") == 0) {
616 }
else if (strcmp(name,
"command") == 0) {
618 }
else if (strcmp(name,
"custom") == 0) {
623 printf(
"Error: Slot \"%s\" not supported\n", name);
687 #if !defined __CYGWIN__ && !defined OS_WIN32 && !defined __OpenBSD__ && !defined sun
688 static int SetCPUAffinitySet(cpu_set_t *cs)
690 #if defined OS_FREEBSD
691 int r = cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID,
694 int r = thread_policy_set(mach_thread_self(), THREAD_AFFINITY_POLICY,
695 (
void*)cs, THREAD_AFFINITY_POLICY_COUNT);
697 pid_t tid = syscall(SYS_gettid);
698 int r = sched_setaffinity(tid,
sizeof(cpu_set_t), cs);
702 printf(
"Warning: sched_setaffinity failed (%" PRId32
"): %s\n", r,
719 static int SetCPUAffinity(uint16_t cpuid)
721 #if defined __OpenBSD__ || defined sun
724 int cpu = (int)cpuid;
726 #if defined OS_WIN32 || defined __CYGWIN__
729 int r = (0 == SetThreadAffinityMask(GetCurrentThread(), cs));
731 printf(
"Warning: sched_setaffinity failed (%" PRId32
"): %s\n", r,
735 SCLogDebug(
"CPU Affinity for thread %lu set to CPU %" PRId32,
742 memset(&cs, 0,
sizeof(cs));
746 return SetCPUAffinitySet(&cs);
778 tv->
name, strerror(errno));
780 SCLogDebug(
"Priority set to %"PRId32
" for thread %s",
790 SCLogDebug(
"Nice value set to %"PRId32
" for thread %s",
851 SCLogPerf(
"Setting affinity for thread \"%s\"to cpu/core "
857 #if !defined __CYGWIN__ && !defined OS_WIN32 && !defined __OpenBSD__ && !defined sun
870 }
else if (CPU_ISSET(cpu, &taf->
hiprio_cpu)) {
875 SCLogPerf(
"Setting prio %d for thread \"%s\" to cpu/core "
879 SetCPUAffinitySet(&taf->
cpu_set);
881 SCLogPerf(
"Setting prio %d for thread \"%s\", "
908 const char *outq_name,
const char *outqh_name,
const char *slots,
909 void * (*fn_p)(
void *),
int mucond)
915 SCLogDebug(
"creating thread \"%s\"...", name);
932 if (inq_name != NULL && strcmp(inq_name,
"packetpool") != 0) {
947 if (inqh_name != NULL) {
964 if (outqh_name != NULL) {
979 if (outq_name != NULL && strcmp(outq_name,
"packetpool") != 0) {
1037 const char *inqh_name,
const char *outq_name,
1038 const char *outqh_name,
const char *slots)
1098 tv =
TmThreadCreate(name, NULL, NULL, NULL, NULL,
"management", NULL, mucond);
1131 tv =
TmThreadCreate(name, NULL, NULL, NULL, NULL,
"command", NULL, mucond);
1168 if (t->
next == NULL) {
1240 if (
tv->
inq != NULL) {
1268 pthread_join(
tv->
t, NULL);
1291 static void TmThreadDrainPacketThreads(
void)
1294 struct timeval start_ts;
1295 struct timeval cur_ts;
1296 gettimeofday(&start_ts, NULL);
1299 gettimeofday(&cur_ts, NULL);
1300 if ((cur_ts.tv_sec - start_ts.tv_sec) > 60) {
1302 "to process their packets in time");
1311 if (ThreadStillHasPackets(
tv)) {
1321 if (ThreadBusy(
tv)) {
1356 struct timeval start_ts;
1357 struct timeval cur_ts;
1358 gettimeofday(&start_ts, NULL);
1361 gettimeofday(&cur_ts, NULL);
1362 if ((cur_ts.tv_sec - start_ts.tv_sec) > 60) {
1363 FatalError(
"Engine unable to disable detect "
1364 "thread - \"%s\". Killing engine",
1382 while (slots != NULL) {
1395 if (ThreadStillHasPackets(
tv)) {
1405 if (ThreadBusy(
tv)) {
1430 if (
tv->
inq != NULL) {
1457 TmThreadDrainPacketThreads();
1461 #ifdef DEBUG_VALIDATION
1462 static void TmThreadDumpThreads(
void);
1465 static void TmThreadDebugValidateNoMorePackets(
void)
1467 #ifdef DEBUG_VALIDATION
1470 if (ThreadStillHasPackets(
tv)) {
1472 TmThreadDumpThreads();
1485 struct timeval start_ts;
1486 struct timeval cur_ts;
1489 TmThreadDrainPacketThreads();
1494 TmThreadDebugValidateNoMorePackets();
1496 gettimeofday(&start_ts, NULL);
1498 gettimeofday(&cur_ts, NULL);
1499 if ((cur_ts.tv_sec - start_ts.tv_sec) > 60) {
1500 FatalError(
"Engine unable to disable packet "
1501 "threads. Killing engine");
1512 if (
tv->
inq != NULL) {
1532 #define MIN_WAIT_TIME 100
1533 #define MAX_WAIT_TIME 999999
1546 int r = TmThreadKillThread(
tv);
1560 #undef MIN_WAIT_TIME
1561 #undef MAX_WAIT_TIME
1567 for (i = 0; i <
TVT_MAX; i++) {
1590 TmThreadDeinitMC(
tv);
1619 char *thread_group_name = NULL;
1627 thread_group_name =
SCStrdup(name);
1628 if (
unlikely(thread_group_name == NULL)) {
1640 if ((family < 0) || (family >=
TVT_MAX))
1662 pthread_attr_t attr;
1668 pthread_attr_init(&attr);
1670 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
1676 FatalError(
"Unable to increase stack size to %" PRIu64
" in thread attributes",
1683 FatalError(
"Unable to create thread with pthread_create(): retval %d: %s", rc,
1687 #if DEBUG && HAVE_PTHREAD_GETATTR_NP
1689 if (pthread_getattr_np(
tv->
t, &attr) == 0) {
1692 pthread_attr_getstack(&attr, &stack_addr, &stack_size);
1693 SCLogDebug(
"stack: %p; size %" PRIu64, stack_addr, (uintmax_t)stack_size);
1695 SCLogDebug(
"Unable to retrieve current stack-size for display; return code from "
1696 "pthread_getattr_np() is %" PRId32,
1719 FatalError(
"Fatal error encountered in TmThreadInitMC. "
1724 printf(
"Error initializing the tv->m mutex\n");
1729 FatalError(
"Fatal error encountered in TmThreadInitMC. "
1734 FatalError(
"Error initializing the tv->cond condition "
1807 uint16_t RX_num = 0;
1809 uint16_t FM_num = 0;
1810 uint16_t FR_num = 0;
1811 uint16_t TX_num = 0;
1813 struct timeval start_ts;
1814 struct timeval cur_ts;
1815 gettimeofday(&start_ts, NULL);
1819 for (
int i = 0; i <
TVT_MAX; i++) {
1821 while (
tv != NULL) {
1826 "start: flags %04x",
1836 gettimeofday(&cur_ts, NULL);
1837 if ((cur_ts.tv_sec - start_ts.tv_sec) > 60) {
1839 "start in time: flags %04x",
1852 for (
int i = 0; i <
TVT_MAX; i++) {
1870 uint16_t app_len = 32;
1871 uint16_t buf_len = 256;
1873 char append_str[app_len];
1874 char thread_counts[buf_len];
1876 strlcpy(thread_counts,
"Threads created -> ", strlen(
"Threads created -> ") + 1);
1878 snprintf(append_str, app_len,
"RX: %u ", RX_num);
1879 strlcat(thread_counts, append_str, buf_len);
1882 snprintf(append_str, app_len,
"W: %u ", W_num);
1883 strlcat(thread_counts, append_str, buf_len);
1886 snprintf(append_str, app_len,
"TX: %u ", TX_num);
1887 strlcat(thread_counts, append_str, buf_len);
1890 snprintf(append_str, app_len,
"FM: %u ", FM_num);
1891 strlcat(thread_counts, append_str, buf_len);
1894 snprintf(append_str, app_len,
"FR: %u ", FR_num);
1895 strlcat(thread_counts, append_str, buf_len);
1897 snprintf(append_str, app_len,
" Engine started.");
1898 strlcat(thread_counts, append_str, buf_len);
1910 for (
int i = 0; i <
TVT_MAX; i++) {
1912 while (
tv != NULL) {
1927 for (
int i = 0; i <
TVT_MAX; i++) {
1950 struct timeval start_ts;
1951 struct timeval cur_ts;
1952 gettimeofday(&start_ts, NULL);
1956 for (
int i = 0; i <
TVT_MAX; i++) {
1958 while (
tv != NULL) {
1963 "initialize: flags %04x",
1971 gettimeofday(&cur_ts, NULL);
1972 if ((cur_ts.tv_sec - start_ts.tv_sec) > 120) {
1974 "initialize in time: flags %04x",
2015 for (
int i = 0; i <
TVT_MAX; i++) {
2017 while (
tv != NULL) {
2028 #ifdef DEBUG_VALIDATION
2038 static void TmThreadDumpThreads(
void)
2041 for (
int i = 0; i <
TVT_MAX; i++) {
2043 while (
tv != NULL) {
2045 SCLogNotice(
"tv %p: type %u name %s tmm_flags %02X flags %X stream_pq %p",
2051 SCLogNotice(
"tv %p: ==> stream_pq_local: pq.len %u packet src %s",
2056 SCLogNotice(
"tv %p: ==> decode_pq: decode_pq.len %u packet src %s",
2059 TmThreadDoDumpSlots(
tv);
2086 static Threads thread_store = { NULL, 0, 0 };
2092 for (
size_t s = 0; s < thread_store.
threads_size; s++) {
2094 if (t == NULL || t->
in_use == 0)
2097 SCLogNotice(
"Thread %"PRIuMAX
", %s type %d, tv %p in_use %d",
2102 SCLogNotice(
"tv %p type %u name %s tmm_flags %02X flags %X",
2116 if (thread_store.
threads == NULL) {
2139 thread_store.
threads = newmem;
2200 struct timeval systs;
2201 gettimeofday(&systs, NULL);
2210 for (
size_t s = 0; s < thread_store.
threads_size; s++) {
2225 struct timeval systs;
2226 gettimeofday(&systs, NULL);
2228 for (
size_t s = 0; s < thread_store.
threads_size; s++) {
2240 struct timeval local = { 0 };
2241 static struct timeval nullts;
2244 struct timeval systs;
2245 gettimeofday(&systs, NULL);
2254 if (!(timercmp(&pkttv, &nullts, ==))) {
2271 SCLogDebug(
"ts->tv_sec %"PRIuMAX, (uintmax_t)
ts->tv_sec);
2279 if (thread_max == 0)
2283 if (thread_max > 1024) {
2284 SCLogWarning(
"limited number of 'worker' threads to 1024. Wanted %d", thread_max);
2287 return (uint16_t)thread_max;
2306 if (
tv->
inq != NULL) {
2311 TmThreadsCaptureBreakLoop(
tv);
const char * thread_name_workers
TmEcode TmThreadSetCPUAffinity(ThreadVars *tv, uint16_t cpu)
Set the thread options (cpu affinity).
struct FlowQueue_ * flow_queue
bool TmThreadsTimeSubsysIsReady(void)
void TmThreadInitMC(ThreadVars *tv)
Initializes the mutex and condition variables for this TV.
thread_local uint64_t spin_lock_cnt
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.
const char * thread_name_flow_mgr
#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
#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).
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
void TmThreadDisablePacketThreads(void)
Disable all packet threads.
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)
void TmThreadTestThreadUnPaused(ThreadVars *tv)
Tests if the thread represented in the arg has been unpaused or not.
TmEcode(* Management)(ThreadVars *, void *)
thread_local uint64_t spin_lock_contention
TmEcode(* Func)(ThreadVars *, Packet *, void *)
void TmThreadClearThreadsFamily(int family)
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 ThreadVars_ * next
#define SCTIME_TO_TIMEVAL(tv, t)
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
#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_ *)
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)
#define THREAD_SET_AFFTYPE
void(* ThreadExitPrintStats)(ThreadVars *, void *)
Packet * PacketDequeue(PacketQueue *q)
Packet * PacketGetFromAlloc(void)
Get a malloced packet.
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.
#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 SCLogNotice(...)
Macro used to log NOTICE messages.
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.