static __init void cd_cmd_init(void)
{
register_command(&cmd_cd);
}
static __init void xsync_cmd_init(void)
{
register_command(&cmd_xsync);
}
static __init void fileram_cmd_init(void)
{
register_command(&cmd_fileram);
}
void
register_commands (void)
{
register_command("connect", command_connect);
}
static __init void echo_cmd_init(void)
{
register_command(&cmd_echo);
}
static __init void write_cmd_init(void)
{
register_command(&cmd_write);
}
int main(int argc, char *argv[]) {
pthread_t t_cleanup; // thread for cleaning up dead sessions.
pthread_t t_healthagent; // thread for health agent.
pthread_t t_cli; // thread for cli.
pthread_t t_counters; // thread for performance counters.
pthread_t t_memorymanager; // thread for the memory manager.
struct ifaddrs *ifaddr;//, *ifa;
__u32 tempIP;
// int s;
int i;
char message[LOGSZ];
char strIP[20];
// char host[NI_MAXHOST];
char path[100] = "/etc/opennop/opennop.conf";
int tmp;
__u32 packet_size = PACKET_SIZE, packet_number = PACKET_NUMBER, thr_num = DEF_THR_NUM;
__u32 fpPerPkt = DEF_FP_PER_PKT, fpsFactor = DEF_FPS_FACTOR;
#if defined(DEBUG)
int daemonize = false;
#else
int daemonize = true;
#endif
/* Setup signal handling */
signal(SIGHUP, signal_handler);
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
signal(SIGPIPE,SIG_IGN);
int c;
while ((c = getopt(argc, argv, "nh|help")) != -1) {
switch (c) {
case 'h':
PrintUsage(argc, argv);
exit(0);
break;
case 'n':
daemonize = 0;
isdaemon = false;
break;
default:
PrintUsage(argc, argv);
break;
}
}
sprintf(message, "Initialization: %s daemon starting up.\n", DAEMON_NAME);
logger(LOG_INFO, message);
/*
* Configuration: read the configuration file
*/
sprintf(message, "Configuring: reading file %s.\n", path);
logger(LOG_INFO, message);
tmp = configure(path, &localID, &packet_number, &packet_size, &thr_num, &fpPerPkt, &fpsFactor);
if(tmp == 1){
sprintf(message, "Configuring error. EXIT\n");
logger(LOG_INFO, message);
exit(EXIT_FAILURE);
}
sprintf(message, "Initialization: Version %s.\n", VERSION);
logger(LOG_INFO, message);
/*
* Get the numerically highest local IP address.
* This will be used as the acceleratorID.
*/
if (getifaddrs(&ifaddr) == -1) {
sprintf(message, "Initialization: Error opening interfaces.\n");
logger(LOG_INFO, message);
exit(EXIT_FAILURE);
}
// for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) { // loop through all interfaces.
//
// if (ifa->ifa_addr != NULL) {
//
// if (ifa->ifa_addr->sa_family == AF_INET) { // get all IPv4 addresses.
// s = getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in),
// host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
//
// if (s != 0) {
// exit(EXIT_FAILURE);
// }
//
// inet_pton(AF_INET, (char *) &host, &tempIP); // convert string to decimal.
//
// /*
// * Lets fine the largest local IP, and use that as accelleratorID
// * Lets also exclude 127.0.0.1 as a valid ID.
// */
// if ((tempIP > localID) && (tempIP != LOOPBACKIP)) {
// localID = tempIP;
// }
// } // end get all IPv4 addresses.
// } // end ifa->ifa_addr NULL test.
// } // end loop through all interfaces.
if (localID == 0) { // fail if no usable IP found.
inet_ntop(AF_INET, &tempIP, strIP, INET_ADDRSTRLEN);
sprintf(message, "Initialization: No usable IP Address. %s\n", strIP);
logger(LOG_INFO, message);
exit(EXIT_FAILURE);
}
#if defined(DEBUG)
setlogmask(LOG_UPTO(LOG_DEBUG));
openlog(DAEMON_NAME, LOG_CONS | LOG_NDELAY | LOG_PERROR | LOG_PID, LOG_USER);
#else
setlogmask(LOG_UPTO(LOG_INFO));
openlog(DAEMON_NAME, LOG_CONS, LOG_USER);
#endif
/* Our process ID and Session ID */
pid_t pid, sid;
if (daemonize) {
sprintf(message, "Initialization: Daemonizing the %s process.\n",
DAEMON_NAME);
logger(LOG_INFO, message);
/* Fork off the parent process */
pid = fork();
if (pid < 0) {
exit(EXIT_FAILURE);
}
/* If we got a good PID, then
we can exit the parent process. */
if (pid > 0) {
exit(EXIT_SUCCESS);
}
/* Change the file mode mask */
umask(0);
/* Create a new SID for the child process */
sid = setsid();
if (sid < 0) {
/* Log the failure */
exit(EXIT_FAILURE);
}
/* Change the current working directory */
if ((chdir("/")) < 0) {
/* Log the failure */
exit(EXIT_FAILURE);
}
/* Close out the standard file descriptors */
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
}
/*
* Starting up the daemon.
*/
initialize_sessiontable();
if (get_workers() == 0) {
set_workers(thr_num);
//set_workers(sysconf(_SC_NPROCESSORS_ONLN) * 2);
}
#ifdef ROLLING
init_common(packet_number,packet_size, fpPerPkt, fpsFactor, shareddict);
init_debugd() ;
#endif
for (i = 0; i < get_workers(); i++) {
create_worker(i);
}
#ifdef BASIC
create_hashmap(&ht); // Create hash table
#endif
// Only one type of optimization can be active
// assert(deduplication != compression);
/*
* Create the fetcher thread that retrieves
* IP packets from the Netfilter Queue.
*/
create_fetcher();
pthread_create(&t_cleanup, NULL, cleanup_function, (void *) NULL);
pthread_create(&t_healthagent, NULL, healthagent_function, (void *) NULL);
pthread_create(&t_cli, NULL, cli_manager_init, (void *) NULL);
pthread_create(&t_counters, NULL, counters_function, (void *) NULL);
pthread_create(&t_memorymanager, NULL, memorymanager_function, (void *) NULL);
sprintf(message, "[OpenNOP]: Started all threads.\n");
logger(LOG_INFO, message);
/*
* All the threads have been created now commands should be registered.
*/
register_command("show traces mask", cli_show_traces_mask, false, false);
register_command("traces mask orr", cli_traces_mask_orr, true, false);
register_command("traces mask and", cli_traces_mask_and, true, false);
register_command("traces mask nand", cli_traces_mask_nand, true, false);
register_command("reset stats in_dedup", cli_reset_stats_in_dedup, false, false);
register_command("reset stats in_dedup_thread", cli_reset_stats_in_dedup, false, false);
register_command("show stats in_dedup", cli_show_stats_in_dedup, false, false);
register_command("show stats in_dedup_thread", cli_show_stats_in_dedup_thread, false, false);
register_command("reset stats out_dedup", cli_reset_stats_out_dedup, false, false);
register_command("reset stats out_dedup_thread", cli_reset_stats_out_dedup, false, false);
register_command("show stats out_dedup", cli_show_stats_out_dedup, false, false);
register_command("show stats out_dedup_thread", cli_show_stats_out_dedup_thread, false, false);
register_command("traces enable", cli_traces_enable, true, false);
register_command("traces disable", cli_traces_disable, true, false);
register_command("show version", cli_show_version, false, false);
register_command("show compression", cli_show_compression, false, false);
register_command("show workers", cli_show_workers, false, false);
register_command("show fetcher", cli_show_fetcher, false, false);
register_command("show sessions", cli_show_sessionss, false, false);
register_command("show deduplication", cli_show_deduplication, false, false);
register_command("compression enable", cli_compression_enable, false, false);
register_command("compression disable", cli_compression_disable, false, false);
register_command("deduplication enable", cli_deduplication_enable, false, false);
register_command("deduplication disable", cli_deduplication_disable, false, false);
/*
* Rejoin all threads before we exit!
*/
rejoin_fetcher();
sprintf(message, "[OpenNOP] Fetcher joined\n");
logger(LOG_INFO, message);
pthread_join(t_cleanup, NULL);
sprintf(message, "joined cleanup\n");
logger(LOG_INFO, message);
pthread_join(t_healthagent, NULL);
sprintf(message, "joined health\n");
logger(LOG_INFO, message);
pthread_join(t_cli, NULL);
sprintf(message, "joined cli\n");
logger(LOG_INFO, message);
pthread_join(t_counters, NULL);
sprintf(message, "joined counters\n");
logger(LOG_INFO, message);
pthread_join(t_memorymanager, NULL);
for (i = 0; i < get_workers(); i++) {
rejoin_worker(i);
}
#ifdef BASIC
remove_hashmap(ht);
#endif
clear_sessiontable();
sprintf(message, "Exiting: %s daemon exiting", DAEMON_NAME);
logger(LOG_INFO, message);
exit(EXIT_SUCCESS);
}
/** Service **/
bool CallbackService::on_load(){
if(!Super::on_load()) return false;
ASSIGN_POINTER(m_command_desc_table, SafeNew<Hash>());
register_command();
return true;
}
static __init void go_cmd_init(void)
{
register_command(&cmd_go);
}
int str9xpec_register_commands(struct command_context_s *cmd_ctx)
{
command_t *str9xpec_cmd = register_command(cmd_ctx, NULL, "str9xpec", NULL, COMMAND_ANY, "str9xpec flash specific commands");
register_command(cmd_ctx, str9xpec_cmd, "enable_turbo", str9xpec_handle_flash_enable_turbo_command, COMMAND_EXEC,
"enable str9xpec turbo mode");
register_command(cmd_ctx, str9xpec_cmd, "disable_turbo", str9xpec_handle_flash_disable_turbo_command, COMMAND_EXEC,
"disable str9xpec turbo mode");
register_command(cmd_ctx, str9xpec_cmd, "options_cmap", str9xpec_handle_flash_options_cmap_command, COMMAND_EXEC,
"configure str9xpec boot sector");
register_command(cmd_ctx, str9xpec_cmd, "options_lvdthd", str9xpec_handle_flash_options_lvdthd_command, COMMAND_EXEC,
"configure str9xpec lvd threshold");
register_command(cmd_ctx, str9xpec_cmd, "options_lvdsel", str9xpec_handle_flash_options_lvdsel_command, COMMAND_EXEC,
"configure str9xpec lvd selection");
register_command(cmd_ctx, str9xpec_cmd, "options_lvdwarn", str9xpec_handle_flash_options_lvdwarn_command, COMMAND_EXEC,
"configure str9xpec lvd warning");
register_command(cmd_ctx, str9xpec_cmd, "options_read", str9xpec_handle_flash_options_read_command, COMMAND_EXEC,
"read str9xpec options");
register_command(cmd_ctx, str9xpec_cmd, "options_write", str9xpec_handle_flash_options_write_command, COMMAND_EXEC,
"write str9xpec options");
register_command(cmd_ctx, str9xpec_cmd, "lock", str9xpec_handle_flash_lock_command, COMMAND_EXEC,
"lock str9xpec device");
register_command(cmd_ctx, str9xpec_cmd, "unlock", str9xpec_handle_flash_unlock_command, COMMAND_EXEC,
"unlock str9xpec device");
register_command(cmd_ctx, str9xpec_cmd, "part_id", str9xpec_handle_part_id_command, COMMAND_EXEC,
"print part id of str9xpec flash bank <num>");
return ERROR_OK;
}
void tracer::install(service_spec& spec)
{
auto trace = dsn_config_get_value_bool("task..default", "is_trace", false,
"whether to trace tasks by default");
for (int i = 0; i <= dsn_task_code_max(); i++)
{
if (i == TASK_CODE_INVALID)
continue;
std::string section_name = std::string("task.") + std::string(dsn_task_code_to_string(i));
task_spec* spec = task_spec::get(i);
dassert (spec != nullptr, "task_spec cannot be null");
if (!dsn_config_get_value_bool(section_name.c_str(), "is_trace", trace,
"whether to trace this kind of task"))
continue;
if (dsn_config_get_value_bool(section_name.c_str(), "tracer::on_task_enqueue", true,
"whether to trace when a timer or async task is enqueued"))
spec->on_task_enqueue.put_back(tracer_on_task_enqueue, "tracer");
if (dsn_config_get_value_bool(section_name.c_str(), "tracer::on_task_begin", true,
"whether to trace when a task begins"))
spec->on_task_begin.put_back(tracer_on_task_begin, "tracer");
if (dsn_config_get_value_bool(section_name.c_str(), "tracer::on_task_end", true,
"whether to trace when a task ends"))
spec->on_task_end.put_back(tracer_on_task_end, "tracer");
if (dsn_config_get_value_bool(section_name.c_str(), "tracer::on_task_cancelled", true,
"whether to trace when a task is cancelled"))
spec->on_task_cancelled.put_back(tracer_on_task_cancelled, "tracer");
if (dsn_config_get_value_bool(section_name.c_str(), "tracer::on_task_wait_pre", true,
"whether to trace when a task is to be wait"))
spec->on_task_wait_pre.put_back(tracer_on_task_wait_pre, "tracer");
if (dsn_config_get_value_bool(section_name.c_str(), "tracer::on_task_wait_post", true,
"whether to trace when a task is wait post"))
spec->on_task_wait_post.put_back(tracer_on_task_wait_post, "tracer");
if (dsn_config_get_value_bool(section_name.c_str(), "tracer::on_task_cancel_post", true,
"whether to trace when a task is cancel post"))
spec->on_task_cancel_post.put_back(tracer_on_task_cancel_post, "tracer");
if (dsn_config_get_value_bool(section_name.c_str(), "tracer::on_aio_call", true,
"whether to trace when an aio task is called"))
spec->on_aio_call.put_back(tracer_on_aio_call, "tracer");
if (dsn_config_get_value_bool(section_name.c_str(), "tracer::on_aio_enqueue", true,
"whether to trace when an aio task is enqueued"))
spec->on_aio_enqueue.put_back(tracer_on_aio_enqueue, "tracer");
if (dsn_config_get_value_bool(section_name.c_str(), "tracer::on_rpc_call", true,
"whether to trace when a rpc is made"))
spec->on_rpc_call.put_back(tracer_on_rpc_call, "tracer");
if (dsn_config_get_value_bool(section_name.c_str(), "tracer::on_rpc_request_enqueue", true,
"whether to trace when a rpc request task is enqueued"))
spec->on_rpc_request_enqueue.put_back(tracer_on_rpc_request_enqueue, "tracer");
if (dsn_config_get_value_bool(section_name.c_str(), "tracer::on_rpc_reply", true,
"whether to trace when reply a rpc request"))
spec->on_rpc_reply.put_back(tracer_on_rpc_reply, "tracer");
if (dsn_config_get_value_bool(section_name.c_str(), "tracer::on_rpc_response_enqueue", true,
"whetehr to trace when a rpc response task is enqueued"))
spec->on_rpc_response_enqueue.put_back(tracer_on_rpc_response_enqueue, "tracer");
}
register_command({ "tracer.find" },
"tracer.find - find related logs",
"tracer.find forward|f|backward|b rpc|r|task|t trace_id|task_id(e.g., a023003920302390) log_file_name(log.xx.txt)",
tracer_log_flow
);
}
static __init void delay_cmd_init(void)
{
register_command(&cmd_delay);
}
command_manager::command_manager()
{
register_command(
{"help", "h", "H", "Help"},
"help|Help|h|H [command] - display help information",
"",
[this](const safe_vector<safe_string>& args)
{
safe_sstream ss;
if (args.size() == 0)
{
utils::auto_read_lock l(_lock);
for (auto c : this->_commands)
{
ss << c->help_short << std::endl;
}
}
else
{
utils::auto_read_lock l(_lock);
auto it = _handlers.find(args[0]);
if (it == _handlers.end())
ss << "cannot find command '" << args[0] << "'";
else
{
ss.width(6);
ss << std::left << it->first << ": " << it->second->help_short << std::endl << it->second->help_long << std::endl;
}
}
return ss.str();
}
);
register_command(
{ "repeat", "r", "R", "Repeat" },
"repeat|Repeat|r|R interval_seconds max_count command - execute command periodically",
"repeat|Repeat|r|R interval_seconds max_count command - execute command every interval seconds, to the max count as max_count (0 for infinite)",
[this](const safe_vector<safe_string>& args)
{
safe_sstream ss;
if (args.size() < 3)
{
return "insufficient arguments";
}
int interval_seconds = atoi(args[0].c_str());
if (interval_seconds <= 0)
{
return "invalid interval argument";
}
int max_count = atoi(args[1].c_str());
if (max_count < 0)
{
return "invalid max count";
}
if (max_count == 0)
{
max_count = std::numeric_limits<int>::max();
}
safe_string cmd = args[2];
safe_vector<safe_string> largs;
for (int i = 3; i < (int)args.size(); i++)
{
largs.push_back(args[i]);
}
for (int i = 0; i < max_count; i++)
{
safe_string output;
auto r = this->run_command(cmd, largs, output);
if (!r)
{
break;
}
std::this_thread::sleep_for(std::chrono::seconds(interval_seconds));
}
return "repeat command completed";
}
);
}
int command_tests_passed(){
int i = 0;
for(i = 0; i < 100; i++){
register_command("afdsasd",1);
register_command("%mkdir",1);
register_command("asfdsafsdd",1);
register_command("afdsasd",1);
register_command("afdsafsdsd",1);
register_command("afdsafsdsd",1);
register_command("afsdafsdasd",1);
register_command("asfdsafsdd",1);
register_command("fWS",1);
register_command("afdsafdsfsdfsd",1);
}
register_command("%WS",1);
register_command("%WT",1);
unregister_all_commands();
return 1;
}
static void
register_commands (void)
{
/* The order here is important. Commands registered earlier have higher
* priority. However commands that can read and write a file format
* have higher priority over commands that can only read the same
* format, regardless of the registration order. */
register_command (FR_TYPE_COMMAND_TAR);
register_command (FR_TYPE_COMMAND_CFILE);
register_command (FR_TYPE_COMMAND_7Z);
register_command (FR_TYPE_COMMAND_DPKG);
register_command (FR_TYPE_COMMAND_ACE);
register_command (FR_TYPE_COMMAND_ALZ);
register_command (FR_TYPE_COMMAND_AR);
register_command (FR_TYPE_COMMAND_ARJ);
register_command (FR_TYPE_COMMAND_CPIO);
register_command (FR_TYPE_COMMAND_ISO);
register_command (FR_TYPE_COMMAND_JAR);
register_command (FR_TYPE_COMMAND_LHA);
register_command (FR_TYPE_COMMAND_RAR);
register_command (FR_TYPE_COMMAND_RPM);
register_command (FR_TYPE_COMMAND_UNSTUFF);
register_command (FR_TYPE_COMMAND_ZIP);
register_command (FR_TYPE_COMMAND_LRZIP);
register_command (FR_TYPE_COMMAND_ZOO);
#if HAVE_JSON_GLIB
register_command (FR_TYPE_COMMAND_UNARCHIVER);
#endif
}
static __init void mw_cmd_init(void)
{
register_command(&cmd_mw);
}
