const char* msg;
};
+class ReloadMemcapManager
+{
+public:
+ virtual ~ReloadMemcapManager() = default;
+
+ virtual bool tune_memcap() = 0;
+ virtual bool tune_memcap_idle() = 0;
+protected:
+ ReloadMemcapManager() = default;
+};
+
class SO_PUBLIC Module
{
public:
void enable_trace();
+ const ReloadMemcapManager* get_reload_mcm() const
+ { return reload_mcm; }
+
protected:
Module(const char* name, const char* help);
Module(const char* name, const char* help, const Parameter*,
int table_level = 0;
Trace* trace;
+ ReloadMemcapManager* reload_mcm = nullptr;
void set_peg_count(int index, PegCount value)
{
static MainHook_f main_hook = snort_ignore;
THREAD_LOCAL ProfileStats daqPerfStats;
+THREAD_LOCAL std::list<snort::ReloadMemcapManager *> *rel_managers;
static THREAD_LOCAL Analyzer* local_analyzer = nullptr;
{
InspectorManager::thread_reinit(sc);
ActionManager::thread_reinit(sc);
+ rel_managers = new std::list<snort::ReloadMemcapManager *>(sc->get_reload_memcap_managers());
}
void Analyzer::term()
Active::thread_term();
delete switcher;
+ delete rel_managers;
+
sfthreshold_free();
RateFilter_Cleanup();
}
ac->execute(*this);
- completed_work_queue_mutex.lock();
- completed_work_queue.push(ac);
- completed_work_queue_mutex.unlock();
+ add_command_to_completed_queue(ac);
return true;
}
+void Analyzer::add_command_to_completed_queue(AnalyzerCommand *ac)
+{
+ if (ac->is_complete())
+ {
+ completed_work_queue_mutex.lock();
+ completed_work_queue.push(ac);
+ completed_work_queue_mutex.unlock();
+ } else
+ cache_analyzer_command(ac);
+}
+
void Analyzer::handle_commands()
{
while (handle_command())
process_daq_msg(msg, false);
DetectionEngine::onload();
process_retry_queue();
+
+ if (rel_managers and rel_managers->size())
+ {
+ auto manager = rel_managers->front();
+ if (manager->tune_memcap())
+ {
+ rel_managers->pop_front();
+ }
+ }
+ else
+ {
+ if(ac)
+ add_command_to_completed_queue(ac);
+ }
+
}
if (exit_after_cnt && (exit_after_cnt -= num_recv) == 0)
#include <mutex>
#include <queue>
#include <string>
+#include <list>
#include "thread.h"
struct Packet;
struct SnortConfig;
struct ProfileStats;
+class ReloadMemcapManager;
}
typedef bool (* MainHook_f)(snort::Packet*);
void init_unprivileged();
void term();
void show_source();
-
+ void cache_analyzer_command(AnalyzerCommand* aci) { ac = aci; }
+ void add_command_to_completed_queue(AnalyzerCommand *ac);
+ AnalyzerCommand* get_analyzer_command() { return ac; }
public:
std::queue<AnalyzerCommand*> completed_work_queue;
std::mutex completed_work_queue_mutex;
RetryQueue* retry_queue = nullptr;
OopsHandler* oops_handler = nullptr;
ContextSwitcher* switcher = nullptr;
+ AnalyzerCommand* ac = nullptr;
std::mutex pending_work_queue_mutex;
};
virtual const char* stringify() = 0;
unsigned get() { return ++ref_count; }
unsigned put() { return --ref_count; }
+ bool is_complete() { return completion_status; }
+ void set_completion_status(bool status) { completion_status = status; }
private:
unsigned ref_count = 0;
+ bool completion_status = true;
};
class ACGetStats : public AnalyzerCommand
delete daq_config;
delete proto_ref;
+ reload_managers.clear();
+
trim_heap();
}
}
}
+SO_PUBLIC bool SnortConfig::register_reload_memcap_manager(ReloadMemcapManager *memcap_manager)
+{
+ reload_managers.push_back(memcap_manager);
+ return true;
+}
+
+std::list<ReloadMemcapManager *> SnortConfig::get_reload_memcap_managers()
+{
+ return reload_managers;
+}
#include "main/thread.h"
#include "sfip/sf_cidr.h"
+#include <list>
+
#define DEFAULT_LOG_DIR "."
enum RunFlag
struct GHash;
struct XHash;
+class ReloadMemcapManager;
+
struct SnortConfig;
typedef void (* ScScratchFunc)(SnortConfig* sc);
struct SnortConfig
{
private:
+ std::list<ReloadMemcapManager *> reload_managers;
+
void init(const SnortConfig* const, ProtocolReference*);
bool verify_stream_inspectors();
SnortConfig(const SnortConfig&) = delete;
+ SO_PUBLIC bool register_reload_memcap_manager(ReloadMemcapManager *);
+ std::list<ReloadMemcapManager *> get_reload_memcap_managers();
+
void setup();
void post_setup();
bool verify();
add_subdirectory(test)
set (STREAM_INCLUDES
+ flush_bucket.h
paf.h
stream.h
stream_splitter.h