int
main(int argc, char **argv)
{
int option_index = 0;
int argerr = 0;
int flag;
crm_log_cli_init("crmadmin");
crm_set_options(NULL, "command [options]", long_options,
"Development tool for performing some crmd-specific commands."
"\n Likely to be replaced by crm_node in the future");
if (argc < 2) {
crm_help('?', EX_USAGE);
}
while (1) {
flag = crm_get_option(argc, argv, &option_index);
if (flag == -1)
break;
switch (flag) {
case 'V':
BE_VERBOSE = TRUE;
admin_verbose = XML_BOOLEAN_TRUE;
crm_bump_log_level(argc, argv);
break;
case 't':
message_timeout_ms = atoi(optarg);
if (message_timeout_ms < 1) {
message_timeout_ms = 30 * 1000;
}
break;
case '$':
case '?':
crm_help(flag, EX_OK);
break;
case 'D':
DO_WHOIS_DC = TRUE;
break;
case 'B':
BASH_EXPORT = TRUE;
break;
case 'K':
DO_RESET = TRUE;
crm_trace("Option %c => %s", flag, optarg);
dest_node = strdup(optarg);
crmd_operation = CRM_OP_LOCAL_SHUTDOWN;
break;
case 'q':
BE_SILENT = TRUE;
break;
case 'i':
DO_DEBUG = debug_inc;
crm_trace("Option %c => %s", flag, optarg);
dest_node = strdup(optarg);
break;
case 'd':
DO_DEBUG = debug_dec;
crm_trace("Option %c => %s", flag, optarg);
dest_node = strdup(optarg);
break;
case 'S':
DO_HEALTH = TRUE;
crm_trace("Option %c => %s", flag, optarg);
dest_node = strdup(optarg);
break;
case 'E':
DO_ELECT_DC = TRUE;
break;
case 'N':
DO_NODE_LIST = TRUE;
break;
case 'H':
DO_HEALTH = TRUE;
break;
default:
printf("Argument code 0%o (%c) is not (?yet?) supported\n", flag, flag);
++argerr;
break;
}
}
if (optind < argc) {
printf("non-option ARGV-elements: ");
while (optind < argc)
printf("%s ", argv[optind++]);
printf("\n");
}
if (optind > argc) {
++argerr;
}
if (argerr) {
crm_help('?', EX_USAGE);
}
if (do_init()) {
int res = 0;
res = do_work();
if (res > 0) {
/* wait for the reply by creating a mainloop and running it until
* the callbacks are invoked...
*/
mainloop = g_main_new(FALSE);
crm_trace("Waiting for %d replies from the local CRM", expected_responses);
message_timer_id = g_timeout_add(message_timeout_ms, admin_message_timeout, NULL);
g_main_run(mainloop);
} else if (res < 0) {
crm_err("No message to send");
operation_status = -1;
}
} else {
crm_warn("Init failed, could not perform requested operations");
operation_status = -2;
}
crm_trace("%s exiting normally", crm_system_name);
return operation_status;
}
int
ACE_TMAIN (int argc_in,
ACE_TCHAR** argv_in)
{
RPG_TRACE (ACE_TEXT ("::main"));
std::string configuration_path =
RPG_Common_File_Tools::getConfigurationDataDirectory (ACE_TEXT_ALWAYS_CHAR (BASEDIR),
true);
std::string data_path =
RPG_Common_File_Tools::getConfigurationDataDirectory (ACE_TEXT_ALWAYS_CHAR (BASEDIR),
false);
#if defined (DEBUG_DEBUGGER)
configuration_path = Common_File_Tools::getWorkingDirectory ();
data_path = Common_File_Tools::getWorkingDirectory ();
#endif
// step1: init
// step1a set defaults
bool debug_scanner = MAP_PARSER_DEF_DEBUG_SCANNER;
bool debug_parser = MAP_PARSER_DEF_DEBUG_PARSER;
std::string map_file = data_path;
map_file += ACE_DIRECTORY_SEPARATOR_CHAR_A;
#if defined (DEBUG_DEBUGGER)
map_file += (MAP_GENERATOR_DEF_LEVEL ? RPG_Common_Tools::sanitize (ACE_TEXT_ALWAYS_CHAR ("engine"))
: ACE_TEXT_ALWAYS_CHAR ("map"));
map_file += ACE_DIRECTORY_SEPARATOR_CHAR_A;
map_file += ACE_TEXT_ALWAYS_CHAR ("data");
map_file += ACE_DIRECTORY_SEPARATOR_CHAR_A;
#else
map_file += ACE_TEXT_ALWAYS_CHAR(RPG_MAP_DEF_MAPS_SUB);
map_file += ACE_DIRECTORY_SEPARATOR_CHAR_A;
#endif
map_file += (MAP_GENERATOR_DEF_LEVEL ? RPG_Common_Tools::sanitize (ACE_TEXT_ALWAYS_CHAR (RPG_ENGINE_LEVEL_DEF_NAME))
: ACE_TEXT_ALWAYS_CHAR (RPG_MAP_DEF_MAP_FILE));
map_file += (MAP_GENERATOR_DEF_LEVEL ? ACE_TEXT_ALWAYS_CHAR (RPG_ENGINE_LEVEL_FILE_EXT)
: ACE_TEXT_ALWAYS_CHAR (RPG_MAP_FILE_EXT));
std::string schema_directory = configuration_path;
#if defined (DEBUG_DEBUGGER)
schema_directory = Common_File_Tools::getWorkingDirectory ();
schema_directory += ACE_DIRECTORY_SEPARATOR_CHAR_A;
schema_directory += ACE_TEXT_ALWAYS_CHAR ("engine");
#endif
bool trace_information = false;
bool print_version_and_exit = false;
// step1ba: parse/process/validate configuration
if (!do_processArguments (argc_in,
argv_in,
debug_scanner,
debug_parser,
map_file,
trace_information,
print_version_and_exit))
{
// make 'em learn...
do_printUsage (ACE::basename (argv_in[0]));
// clean up
// *PORTABILITY*: on Windows, need to fini ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::fini () == -1)
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
#endif
return EXIT_FAILURE;
} // end IF
// step1bb: validate arguments
if (!Common_File_Tools::isReadable (map_file) ||
!Common_File_Tools::isDirectory (schema_directory))
{
// make 'em learn...
do_printUsage (ACE::basename (argv_in[0]));
// clean up
// *PORTABILITY*: on Windows, need to fini ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::fini () == -1)
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
#endif
return EXIT_FAILURE;
} // end IF
// step1c: initialize logging and/or tracing
std::string log_file;
if (!Common_Tools::initializeLogging (ACE::basename (argv_in[0]), // program name
log_file, // logfile
false, // log to syslog ?
false, // trace messages ?
trace_information, // debug messages ?
NULL)) // logger
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to Common_Tools::initializeLogging(), aborting\n")));
// clean up
// *PORTABILITY*: on Windows, need to fini ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::fini () == -1)
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
#endif
return EXIT_FAILURE;
} // end IF
// step1d: handle specific program modes
if (print_version_and_exit)
{
do_printVersion (ACE::basename (argv_in[0]));
// clean up
// *PORTABILITY*: on Windows, need to fini ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::fini () == -1)
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
#endif
return EXIT_SUCCESS;
} // end IF
ACE_High_Res_Timer timer;
timer.start ();
// step2: do actual work
do_work (schema_directory,
debug_scanner,
debug_parser,
map_file);
timer.stop ();
// debug info
std::string working_time_string;
ACE_Time_Value working_time;
timer.elapsed_time (working_time);
RPG_Common_Tools::period2String (working_time,
working_time_string);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("total working time (h:m:s.us): \"%s\"...\n"),
ACE_TEXT (working_time_string.c_str ())));
// *PORTABILITY*: on Windows, need to fini ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::fini () == -1)
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
#endif
return EXIT_SUCCESS;
}
static int count_hardware_counters(void)
{
struct perf_event_attr hw_event;
int i, hwctrs = 0;
int fdarry[MAX_CTRS];
struct read_format buf;
memset(&hw_event, 0, sizeof(struct perf_event_attr));
hw_event.type = PERF_TYPE_HARDWARE;
hw_event.size = sizeof(struct perf_event_attr);
hw_event.disabled = 1;
hw_event.config = PERF_COUNT_HW_INSTRUCTIONS;
hw_event.read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
PERF_FORMAT_TOTAL_TIME_RUNNING;
for (i = 0; i < MAX_CTRS; i++) {
fdarry[i] = perf_event_open(&hw_event, 0, -1, -1, 0);
if (fdarry[i] == -1) {
if (errno == ENOENT || errno == ENODEV) {
tst_brkm(TCONF | TERRNO, cleanup,
"PERF_COUNT_HW_INSTRUCTIONS not supported");
}
tst_brkm(TBROK | TERRNO, cleanup,
"perf_event_open failed at iteration:%d", i);
}
if (prctl(PR_TASK_PERF_EVENTS_ENABLE) == -1) {
tst_brkm(TBROK | TERRNO, cleanup,
"prctl(PR_TASK_PERF_EVENTS_ENABLE) failed");
}
do_work();
if (prctl(PR_TASK_PERF_EVENTS_DISABLE) == -1) {
tst_brkm(TBROK | TERRNO, cleanup,
"prctl(PR_TASK_PERF_EVENTS_DISABLE) failed");
}
if (read(fdarry[i], &buf, sizeof(buf)) != sizeof(buf)) {
tst_brkm(TBROK | TERRNO, cleanup,
"error reading counter(s)");
}
if (verbose == 1) {
printf("at iteration:%d value:%lld time_enabled:%lld "
"time_running:%lld\n", i, buf.value,
buf.time_enabled, buf.time_running);
}
/*
* Normally time_enabled and time_running are the same value.
* But if more events are started than available counter slots
* on the PMU, then multiplexing happens and events run only
* part of the time. Time_enabled and time_running's values
* will be different. In this case the time_enabled and time_
* running values can be used to scale an estimated value for
* the count. So if buf.time_enabled and buf.time_running are
* not equal, we can think that PMU hardware counters
* multiplexing happens and the number of the opened events
* are the number of max available hardware counters.
*/
if (buf.time_enabled != buf.time_running) {
hwctrs = i;
break;
}
}
for (i = 0; i <= hwctrs; i++)
SAFE_CLOSE(cleanup, fdarry[i]);
return hwctrs;
}
/** [example_snippet] */
int sync_rx_example(struct bladerf *dev)
{
int status, ret;
bool done = false;
/* "User" samples buffers and their associated sizes, in units of samples.
* Recall that one sample = two int16_t values. */
int16_t *rx_samples = NULL;
int16_t *tx_samples = NULL;
const unsigned int samples_len = 10000; /* May be any (reasonable) size */
/* These items configure the underlying asynch stream used by the sync
* interface. The "buffer" here refers to those used internally by worker
* threads, not the `samples` buffer above. */
const unsigned int num_buffers = 16;
const unsigned int buffer_size = 8192; /* Must be a multiple of 1024 */
const unsigned int num_transfers = 8;
const unsigned int timeout_ms = 3500;
/* Allocate a buffer to store received samples in */
rx_samples = malloc(samples_len * 2 * sizeof(int16_t));
if (rx_samples == NULL) {
perror("malloc");
return BLADERF_ERR_MEM;
}
/* Allocate a buffer to prepare transmit data in */
tx_samples = malloc(samples_len * 2 * sizeof(int16_t));
if (tx_samples == NULL) {
perror("malloc");
free(rx_samples);
return BLADERF_ERR_MEM;
}
/* Configure both the device's RX and TX modules for use with the synchronous
* interface. SC16 Q11 samples *without* metadata are used. */
status = bladerf_sync_config(dev,
BLADERF_MODULE_RX,
BLADERF_FORMAT_SC16_Q11,
num_buffers,
buffer_size,
num_transfers,
timeout_ms);
if (status != 0) {
fprintf(stderr, "Failed to configure RX sync interface: %s\n",
bladerf_strerror(status));
goto out;
}
status = bladerf_sync_config(dev,
BLADERF_MODULE_TX,
BLADERF_FORMAT_SC16_Q11,
num_buffers,
buffer_size,
num_transfers,
timeout_ms);
if (status != 0) {
fprintf(stderr, "Failed to configure TX sync interface: %s\n",
bladerf_strerror(status));
goto out;
}
/* We must always enable the modules *after* calling bladerf_sync_config(),
* and *before* attempting to RX or TX samples. */
status = bladerf_enable_module(dev, BLADERF_MODULE_RX, true);
if (status != 0) {
fprintf(stderr, "Failed to enable RX module: %s\n",
bladerf_strerror(status));
goto out;
}
status = bladerf_enable_module(dev, BLADERF_MODULE_TX, true);
if (status != 0) {
fprintf(stderr, "Failed to enable RX module: %s\n",
bladerf_strerror(status));
goto out;
}
/* Receive samples and do work on them and then transmit a response.
*
* Note we transmit more than `buffer_size` samples to ensure that our
* samples are written to the FPGA. (The samples are sent when the
* synchronous interface's internal buffer of `buffer_size` samples is
* filled.) This is generally not nececssary if you are continuously
* streaming TX data. Otherwise, you may need to zero-pad your TX data to
* achieve this.
*/
while (status == 0 && !done) {
status = bladerf_sync_rx(dev, rx_samples, samples_len, NULL, 5000);
if (status == 0) {
done = do_work(rx_samples, samples_len,
tx_samples, samples_len);
if (!done) {
status = bladerf_sync_tx(dev, tx_samples, samples_len,
NULL, 5000);
if (status != 0) {
fprintf(stderr, "Failed to TX samples: %s\n",
bladerf_strerror(status));
}
}
} else {
fprintf(stderr, "Failed to RX samples: %s\n",
bladerf_strerror(status));
}
}
if (status == 0) {
/* Wait a few seconds for any remaining TX samples to finish */
usleep(2000000);
}
out:
ret = status;
/* Disable RX module, shutting down our underlying RX stream */
status = bladerf_enable_module(dev, BLADERF_MODULE_RX, false);
if (status != 0) {
fprintf(stderr, "Failed to disable RX module: %s\n",
bladerf_strerror(status));
}
/* Disable TX module, shutting down our underlying TX stream */
status = bladerf_enable_module(dev, BLADERF_MODULE_TX, false);
if (status != 0) {
fprintf(stderr, "Failed to disable TX module: %s\n",
bladerf_strerror(status));
}
/* Free up our resources */
free(rx_samples);
free(tx_samples);
return ret;
}
void imageCallback(const sensor_msgs::ImageConstPtr& msg)
{
do_work(msg, msg->header.frame_id);
}
int
ACE_TMAIN (int argc_in,
ACE_TCHAR* argv_in[])
{
RPG_TRACE (ACE_TEXT ("::main"));
// step1: initialize libraries
// *PORTABILITY*: on Windows, init ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::init () == -1)
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::init(): \"%m\", aborting\n")));
return EXIT_FAILURE;
} // end IF
#endif
// step2: initialize configuration
// step2a: set defaults
RPG_Dice_ValueRange value_range;
value_range.begin = 0;
value_range.end = 0;
bool print_all_results = false;
bool trace_information = false;
bool print_version_and_exit = false;
// step2b: parse/process/validate configuration
if (!process_arguments (argc_in,
argv_in,
print_all_results,
value_range,
trace_information,
print_version_and_exit))
{
// make 'em learn...
print_usage (ACE::basename (argv_in[0]));
// *PORTABILITY*: on Windows, fini ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::fini () == -1)
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::fini(): \"%m\", aborting\n")));
return EXIT_FAILURE;
} // end IF
#endif
return EXIT_FAILURE;
} // end IF
// // step2c: validate arguments
// if (valueRange.begin == valueRange.end == 0)
// {
// ACE_DEBUG((LM_DEBUG,
// ACE_TEXT("invalid range: \"%s\", aborting\n"),
// RPG_Chance_Dice_Common_Tools::rangeToString(valueRange).c_str()));
//
// // make 'em learn...
// print_usage();
//
// return EXIT_FAILURE;
// } // end IF
// step3: initialize logging and/or tracing
std::string log_file;
if (!Common_Tools::initializeLogging (ACE::basename (argv_in[0]), // program name
log_file, // logfile
false, // log to syslog ?
false, // trace messages ?
trace_information, // debug messages ?
NULL)) // logger
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to Common_Tools::initializeLogging(), aborting\n")));
// *PORTABILITY*: on Windows, need to fini ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::fini () == -1)
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
#endif
return EXIT_FAILURE;
} // end IF
// step4: handle specific program modes
if (print_version_and_exit)
{
do_printVersion (ACE::basename (argv_in[0]));
// *PORTABILITY*: on Windows, need to fini ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::fini () == -1)
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
#endif
return EXIT_SUCCESS;
} // end IF
ACE_High_Res_Timer timer;
timer.start ();
// step5: do work
RPG_Dice_Rolls_t combinations;
do_work (value_range,
combinations);
timer.stop ();
// step6: print results
// header line
std::cout << ACE_TEXT ("results ")
<< RPG_Dice_Common_Tools::rangeToString (value_range)
<< ACE_TEXT (": ")
<< std::endl;
std::cout << std::setw (80)
<< std::setfill (ACE_TEXT_ALWAYS_CHAR ('-'))
<< ACE_TEXT ("")
<< std::setfill (ACE_TEXT_ALWAYS_CHAR (' '))
<< std::endl;
bool perfect_match = true;
int index = 1;
RPG_Dice_ValueRange range;
for (RPG_Dice_RollsIterator_t iterator = combinations.begin ();
iterator != combinations.end ();
iterator++, index++)
{
perfect_match = true;
RPG_Dice::rollToRange (*iterator, range);
if ((range.begin != value_range.begin) || (range.end != value_range.end))
{
// not a perfect match...
perfect_match = false;
if (!print_all_results)
continue;
} // end IF
std::cout << ACE_TEXT ("[")
<< index
<< (perfect_match ? ACE_TEXT ("*]") : ACE_TEXT ("]"))
<< RPG_Dice_Common_Tools::rollToString (*iterator)
<< ACE_TEXT (" : ")
<< RPG_Dice_Common_Tools::rangeToString (range)
<< std::endl;
} // end FOR
// std::string working_time_string;
// ACE_Time_Value working_time;
// timer.elapsed_time(working_time);
// RPS_FLB_Common_Tools::Period2String(working_time,
// working_time_string);
//
// ACE_DEBUG((LM_DEBUG,
// ACE_TEXT("total working time (h:m:s.us): \"%s\"...\n"),
// working_time_string.c_str()));
// step7: finalize libraries
// *PORTABILITY*: on Windows, fini ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::fini () == -1)
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::fini(): \"%m\", aborting\n")));
return EXIT_FAILURE;
} // end IF
#endif
return EXIT_SUCCESS;
} // end main
int
main(int argc, char **argv)
{
int argerr = 0;
int rc = pcmk_ok;
int flag;
const char *source = NULL;
const char *admin_input_xml = NULL;
const char *admin_input_file = NULL;
gboolean dangerous_cmd = FALSE;
gboolean admin_input_stdin = FALSE;
xmlNode *output = NULL;
xmlNode *input = NULL;
int option_index = 0;
crm_xml_init(); /* Sets buffer allocation strategy */
crm_log_cli_init("cibadmin");
set_crm_log_level(LOG_CRIT);
crm_set_options(NULL, "command [options] [data]", long_options,
"Provides direct access to the cluster configuration."
"\n\nAllows the configuration, or sections of it, to be queried, modified, replaced and deleted."
"\n\nWhere necessary, XML data will be obtained using the -X, -x, or -p options.\n");
if (argc < 2) {
crm_help('?', CRM_EX_USAGE);
}
while (1) {
flag = crm_get_option(argc, argv, &option_index);
if (flag == -1)
break;
switch (flag) {
case 't':
message_timeout_ms = atoi(optarg);
if (message_timeout_ms < 1) {
message_timeout_ms = 30;
}
break;
case 'A':
obj_type = optarg;
command_options |= cib_xpath;
break;
case 'e':
command_options |= cib_xpath_address;
break;
case 'u':
cib_action = CIB_OP_UPGRADE;
dangerous_cmd = TRUE;
break;
case 'E':
cib_action = CIB_OP_ERASE;
dangerous_cmd = TRUE;
break;
case 'Q':
cib_action = CIB_OP_QUERY;
break;
case 'P':
cib_action = CIB_OP_APPLY_DIFF;
break;
case 'U':
cib_user = optarg;
break;
case 'M':
cib_action = CIB_OP_MODIFY;
break;
case 'R':
cib_action = CIB_OP_REPLACE;
break;
case 'C':
cib_action = CIB_OP_CREATE;
break;
case 'D':
cib_action = CIB_OP_DELETE;
break;
case '5':
cib_action = "md5-sum";
break;
case '6':
cib_action = "md5-sum-versioned";
break;
case 'c':
command_options |= cib_can_create;
break;
case 'n':
command_options |= cib_no_children;
break;
case 'B':
cib_action = CIB_OP_BUMP;
crm_log_args(argc, argv);
break;
case 'V':
command_options = command_options | cib_verbose;
bump_log_num++;
break;
case '?':
case '$':
case '!':
crm_help(flag, CRM_EX_OK);
break;
case 'o':
crm_trace("Option %c => %s", flag, optarg);
obj_type = optarg;
break;
case 'X':
crm_trace("Option %c => %s", flag, optarg);
admin_input_xml = optarg;
crm_log_args(argc, argv);
break;
case 'x':
crm_trace("Option %c => %s", flag, optarg);
admin_input_file = optarg;
crm_log_args(argc, argv);
break;
case 'p':
admin_input_stdin = TRUE;
crm_log_args(argc, argv);
break;
case 'N':
case 'h':
host = strdup(optarg);
break;
case 'l':
command_options |= cib_scope_local;
break;
case 'd':
cib_action = CIB_OP_DELETE;
command_options |= cib_multiple;
dangerous_cmd = TRUE;
break;
case 'b':
dangerous_cmd = TRUE;
command_options |= cib_inhibit_bcast;
command_options |= cib_scope_local;
break;
case 's':
command_options |= cib_sync_call;
break;
case 'f':
force_flag = TRUE;
command_options |= cib_quorum_override;
crm_log_args(argc, argv);
break;
case 'a':
output = createEmptyCib(1);
if (optind < argc) {
crm_xml_add(output, XML_ATTR_VALIDATION, argv[optind]);
}
admin_input_xml = dump_xml_formatted(output);
fprintf(stdout, "%s\n", crm_str(admin_input_xml));
crm_exit(CRM_EX_OK);
break;
default:
printf("Argument code 0%o (%c)" " is not (?yet?) supported\n", flag, flag);
++argerr;
break;
}
}
while (bump_log_num > 0) {
crm_bump_log_level(argc, argv);
bump_log_num--;
}
if (optind < argc) {
printf("non-option ARGV-elements: ");
while (optind < argc)
printf("%s ", argv[optind++]);
printf("\n");
crm_help('?', CRM_EX_USAGE);
}
if (optind > argc || cib_action == NULL) {
++argerr;
}
if (argerr) {
crm_help('?', CRM_EX_USAGE);
}
if (dangerous_cmd && force_flag == FALSE) {
fprintf(stderr, "The supplied command is considered dangerous."
" To prevent accidental destruction of the cluster,"
" the --force flag is required in order to proceed.\n");
fflush(stderr);
crm_exit(CRM_EX_UNSAFE);
}
if (admin_input_file != NULL) {
input = filename2xml(admin_input_file);
source = admin_input_file;
} else if (admin_input_xml != NULL) {
source = "input string";
input = string2xml(admin_input_xml);
} else if (admin_input_stdin) {
source = "STDIN";
input = stdin2xml();
}
if (input != NULL) {
crm_log_xml_debug(input, "[admin input]");
} else if (source) {
fprintf(stderr, "Couldn't parse input from %s.\n", source);
crm_exit(CRM_EX_CONFIG);
}
if (safe_str_eq(cib_action, "md5-sum")) {
char *digest = NULL;
if (input == NULL) {
fprintf(stderr, "Please supply XML to process with -X, -x or -p\n");
crm_exit(CRM_EX_USAGE);
}
digest = calculate_on_disk_digest(input);
fprintf(stderr, "Digest: ");
fprintf(stdout, "%s\n", crm_str(digest));
free(digest);
free_xml(input);
crm_exit(CRM_EX_OK);
} else if (safe_str_eq(cib_action, "md5-sum-versioned")) {
char *digest = NULL;
const char *version = NULL;
if (input == NULL) {
fprintf(stderr, "Please supply XML to process with -X, -x or -p\n");
crm_exit(CRM_EX_USAGE);
}
version = crm_element_value(input, XML_ATTR_CRM_VERSION);
digest = calculate_xml_versioned_digest(input, FALSE, TRUE, version);
fprintf(stderr, "Versioned (%s) digest: ", version);
fprintf(stdout, "%s\n", crm_str(digest));
free(digest);
free_xml(input);
crm_exit(CRM_EX_OK);
}
rc = do_init();
if (rc != pcmk_ok) {
crm_err("Init failed, could not perform requested operations");
fprintf(stderr, "Init failed, could not perform requested operations\n");
free_xml(input);
crm_exit(crm_errno2exit(rc));
}
rc = do_work(input, command_options, &output);
if (rc > 0) {
/* wait for the reply by creating a mainloop and running it until
* the callbacks are invoked...
*/
request_id = rc;
the_cib->cmds->register_callback(the_cib, request_id, message_timeout_ms, FALSE, NULL,
"cibadmin_op_callback", cibadmin_op_callback);
mainloop = g_main_loop_new(NULL, FALSE);
crm_trace("%s waiting for reply from the local CIB", crm_system_name);
crm_info("Starting mainloop");
g_main_loop_run(mainloop);
} else if ((rc == -pcmk_err_schema_unchanged)
&& crm_str_eq(cib_action, CIB_OP_UPGRADE, TRUE)) {
report_schema_unchanged();
} else if (rc < 0) {
crm_err("Call failed: %s", pcmk_strerror(rc));
fprintf(stderr, "Call failed: %s\n", pcmk_strerror(rc));
if (rc == -pcmk_err_schema_validation) {
if (crm_str_eq(cib_action, CIB_OP_UPGRADE, TRUE)) {
xmlNode *obj = NULL;
int version = 0, rc = 0;
rc = the_cib->cmds->query(the_cib, NULL, &obj, command_options);
if (rc == pcmk_ok) {
update_validation(&obj, &version, 0, TRUE, FALSE);
}
} else if (output) {
validate_xml_verbose(output);
}
}
exit_code = crm_errno2exit(rc);
}
if (output != NULL) {
print_xml_output(output);
free_xml(output);
}
crm_trace("%s exiting normally", crm_system_name);
free_xml(input);
rc = the_cib->cmds->signoff(the_cib);
if (exit_code == CRM_EX_OK) {
exit_code = crm_errno2exit(rc);
}
cib_delete(the_cib);
crm_exit(exit_code);
}
int
main(int argc, char **argv)
{
int argerr = 0;
int flag;
const char *source = NULL;
char *admin_input_xml = NULL;
char *admin_input_file = NULL;
gboolean dangerous_cmd = FALSE;
gboolean admin_input_stdin = FALSE;
xmlNode *output = NULL;
xmlNode *input = NULL;
int option_index = 0;
crm_log_init("cibadmin", LOG_CRIT, FALSE, FALSE, argc, argv);
crm_set_options("V?$o:QDUCEX:t:Srwlsh:MmBfbRx:pP5N:A:uncd", "command [options] [data]", long_options,
"Provides direct access to the cluster configuration."
"\n\n Allows the configuration, or sections of it, to be queried, modified, replaced and deleted."
"\n\n Where necessary, XML data will be obtained using the -X, -x, or -p options\n");
if(argc < 2) {
crm_help('?',LSB_EXIT_EINVAL);
}
while (1) {
flag = crm_get_option(argc, argv, &option_index);
if (flag == -1)
break;
switch(flag) {
case 't':
message_timeout_ms = atoi(optarg);
if(message_timeout_ms < 1) {
message_timeout_ms = 30;
}
break;
case 'A':
obj_type = crm_strdup(optarg);
command_options |= cib_xpath;
break;
case 'u':
cib_action = CIB_OP_UPGRADE;
dangerous_cmd = TRUE;
break;
case 'E':
cib_action = CIB_OP_ERASE;
dangerous_cmd = TRUE;
break;
case 'Q':
cib_action = CIB_OP_QUERY;
break;
case 'P':
cib_action = CIB_OP_APPLY_DIFF;
break;
case 'S':
cib_action = CIB_OP_SYNC;
break;
case 'U':
case 'M':
cib_action = CIB_OP_MODIFY;
break;
case 'R':
cib_action = CIB_OP_REPLACE;
break;
case 'C':
cib_action = CIB_OP_CREATE;
break;
case 'D':
cib_action = CIB_OP_DELETE;
break;
case '5':
cib_action = "md5-sum";
break;
case 'c':
command_options |= cib_can_create;
break;
case 'n':
command_options |= cib_no_children;
break;
case 'm':
cib_action = CIB_OP_ISMASTER;
command_options |= cib_scope_local;
break;
case 'B':
cib_action = CIB_OP_BUMP;
break;
case 'r':
dangerous_cmd = TRUE;
cib_action = CIB_OP_SLAVE;
break;
case 'w':
dangerous_cmd = TRUE;
cib_action = CIB_OP_MASTER;
command_options |= cib_scope_local;
break;
case 'V':
command_options = command_options | cib_verbose;
cl_log_enable_stderr(TRUE);
alter_debug(DEBUG_INC);
break;
case '?':
case '$':
crm_help(flag, LSB_EXIT_OK);
break;
case 'o':
crm_debug_2("Option %c => %s", flag, optarg);
obj_type = crm_strdup(optarg);
break;
case 'X':
crm_debug_2("Option %c => %s", flag, optarg);
admin_input_xml = crm_strdup(optarg);
break;
case 'x':
crm_debug_2("Option %c => %s", flag, optarg);
admin_input_file = crm_strdup(optarg);
break;
case 'p':
admin_input_stdin = TRUE;
break;
case 'N':
case 'h':
host = crm_strdup(optarg);
break;
case 'l':
command_options |= cib_scope_local;
break;
case 'd':
cib_action = CIB_OP_DELETE;
command_options |= cib_multiple;
dangerous_cmd = TRUE;
break;
case 'b':
dangerous_cmd = TRUE;
command_options |= cib_inhibit_bcast;
command_options |= cib_scope_local;
break;
case 's':
command_options |= cib_sync_call;
break;
case 'f':
force_flag = TRUE;
command_options |= cib_quorum_override;
break;
default:
printf("Argument code 0%o (%c)"
" is not (?yet?) supported\n",
flag, flag);
++argerr;
break;
}
}
if (optind < argc) {
printf("non-option ARGV-elements: ");
while (optind < argc)
printf("%s ", argv[optind++]);
printf("\n");
crm_help('?', LSB_EXIT_EINVAL);
}
if (optind > argc || cib_action == NULL) {
++argerr;
}
if (argerr) {
crm_help('?', LSB_EXIT_GENERIC);
}
if(dangerous_cmd && force_flag == FALSE) {
fprintf(stderr, "The supplied command is considered dangerous."
" To prevent accidental destruction of the cluster,"
" the --force flag is required in order to proceed.\n");
fflush(stderr);
exit(LSB_EXIT_GENERIC);
}
if(admin_input_file != NULL) {
input = filename2xml(admin_input_file);
source = admin_input_file;
} else if(admin_input_xml != NULL) {
source = "input string";
input = string2xml(admin_input_xml);
} else if(admin_input_stdin) {
source = "STDIN";
input = stdin2xml();
}
if(input != NULL) {
crm_log_xml_debug(input, "[admin input]");
} else if(source) {
fprintf(stderr, "Couldn't parse input from %s.\n", source);
return 1;
}
if(safe_str_eq(cib_action, "md5-sum")) {
char *digest = NULL;
if(input == NULL) {
fprintf(stderr,
"Please supply XML to process with -X, -x or -p\n");
exit(1);
}
digest = calculate_xml_digest(input, FALSE, FALSE);
fprintf(stderr, "Digest: ");
fprintf(stdout, "%s\n", crm_str(digest));
crm_free(digest);
exit(0);
}
exit_code = do_init();
if(exit_code != cib_ok) {
crm_err("Init failed, could not perform requested operations");
fprintf(stderr, "Init failed, could not perform requested operations\n");
return -exit_code;
}
exit_code = do_work(input, command_options, &output);
if (exit_code > 0) {
/* wait for the reply by creating a mainloop and running it until
* the callbacks are invoked...
*/
request_id = exit_code;
the_cib->cmds->register_callback(
the_cib, request_id, message_timeout_ms, FALSE, NULL,
"cibadmin_op_callback", cibadmin_op_callback);
mainloop = g_main_new(FALSE);
crm_debug_3("%s waiting for reply from the local CIB",
crm_system_name);
crm_info("Starting mainloop");
g_main_run(mainloop);
} else if(exit_code < 0) {
crm_err("Call failed: %s", cib_error2string(exit_code));
fprintf(stderr, "Call failed: %s\n",
cib_error2string(exit_code));
operation_status = exit_code;
if(exit_code == cib_dtd_validation) {
if(crm_str_eq(cib_action, CIB_OP_UPGRADE, TRUE)) {
xmlNode *obj = NULL;
int version = 0, rc = 0;
rc = the_cib->cmds->query(the_cib, NULL, &obj, command_options);
if(rc == cib_ok) {
update_validation(&obj, &version, TRUE, FALSE);
}
} else if(output) {
validate_xml_verbose(output);
}
}
}
if(output != NULL) {
char *buffer = dump_xml_formatted(output);
fprintf(stdout, "%s\n", crm_str(buffer));
crm_free(buffer);
}
the_cib->cmds->signoff(the_cib);
crm_debug_3("%s exiting normally", crm_system_name);
return -exit_code;
}
int do_autodetect_dev(char const *base_path, char const *conf_path,
struct mach_id *list, int verify, struct sdp_work *cmd_head)
{
struct sdp_dev *p_id;
struct mach_id *mach;
libusb_device **devs;
libusb_device *dev;
int err = 0;
ssize_t cnt;
struct sdp_work *curr;
libusb_device_handle *h = NULL;
char const *conf;
int retry;
err = libusb_init(NULL);
if (err < 0)
return err;
cnt = libusb_get_device_list(NULL, &devs);
if (cnt < 0) {
err = LIBUSB_ERROR_NO_DEVICE;
goto out_deinit_usb;
}
// print_devs(devs);
dev = find_imx_dev(devs, &mach, list);
if (!dev) {
libusb_free_device_list(devs, 1);
err = LIBUSB_ERROR_NO_DEVICE;
goto out_deinit_usb;
}
err = libusb_open(dev, &h);
libusb_free_device_list(devs, 1);
if (err < 0) {
fprintf(stderr, "Could not open device vid=0x%x pid=0x%x: %s, err=%d\n",
mach->vid, mach->pid, libusb_strerror(err), err);
goto out_deinit_usb;
}
// Get machine specific configuration file..
conf = conf_file_name(mach->file_name, base_path, conf_path);
if (conf == NULL) {
err = LIBUSB_ERROR_OTHER;
goto out_close_usb;
}
p_id = parse_conf(conf);
if (!p_id) {
err = LIBUSB_ERROR_OTHER;
goto out_close_usb;
}
if (p_id->mode == MODE_HID)
p_id->transfer = &transfer_hid;
if (p_id->mode == MODE_BULK)
p_id->transfer = &transfer_bulk;
// By default, use work from config file...
curr = p_id->work;
if (cmd_head != NULL)
curr = cmd_head;
if (curr == NULL) {
fprintf(stderr, "no job found\n");
err = LIBUSB_ERROR_OTHER;
goto out_close_usb;
}
retry:
// USB private pointer is libusb device handle...
p_id->priv = h;
err = do_work(p_id, &curr, verify);
dbg_printf("do_work finished with err=%d, curr=%p\n", err, curr);
out_close_usb:
libusb_close(h);
/* More work to do? Try to rediscover the same device */
if (curr && !(err < 0)) {
for (retry = 0; retry < 10; retry++) {
msleep(3000);
h = libusb_open_device_with_vid_pid(NULL, mach->vid, mach->pid);
if (h)
goto retry;
fprintf(stderr, "Could not open device vid=0x%x pid=0x%x err=%d\n",
mach->vid, mach->pid, err);
}
}
out_deinit_usb:
libusb_exit(NULL);
return err;
}
int
locktest()
{
int i;
Workblk *array;
struct scripttab *k;
hrtime_t start;
hrtime_t vstart;
hrtime_t end;
hrtime_t vend;
struct timeval ttime;
time_t secs;
head.size = narrays;
head.arrays = (Workblk *) calloc(narrays, sizeof(Workblk));
for(i = 0, array = head.arrays; i < narrays; i ++, array ++) {
array->index = i;
}
printf( "%s: number of %s = %d, number of blocks = %d, repeat %d times %s\n",
name, model, nthreads, narrays, repeat_count,
(uniprocessor == 0 ? "" : "[single CPU]") );
#ifdef SOLARIS
tid = (thread_t *) calloc(nthreads*repeat_count, sizeof(thread_t));
#endif
#ifdef POSIX
tid = (pthread_t *) calloc(nthreads*repeat_count, sizeof(pthread_t));
#endif
for(count = 0; count < repeat_count; count ++) {
(void) gettimeofday(&ttime, NULL);
secs = (time_t)ttime.tv_sec;
printf("Iteration %d, starting %s\n",
count+1,
prtime (&secs) );
if(job_index == -1) {
for (i = 0; ; i++) {
k = &scripttab[i];
if (k->test_name == NULL) {
break;
}
printf("begin thread_work, %s\n", k->test_name);
init_arrays(i);
start = gethrtime();
vstart = gethrvtime();
if( strcmp(k->test_name, "nothreads") == 0 ){
/* the "nothreads" task is special-cased to run in the main thread */
do_work(NULL);
} else if(nthreads == 1) {
do_work(NULL);
} else {
thread_work();
}
end = gethrtime();
vend = gethrvtime();
#if OS(Solaris)
check_sigmask(2);
#endif /* OS(Solaris) */
dump_arrays(end-start, vend-vstart, i);
}
} else {
k = &scripttab[job_index];
if (k->test_name == NULL) {
break;
}
printf("begin thread_work, %s\n", k->test_name);
init_arrays(job_index);
start = gethrtime();
vstart = gethrvtime();
if( strcmp(k->test_name, "nothreads") == 0 ){
/* first one is special-cased to run in 1 thread */
do_work(NULL);
} else if(nthreads == 1) {
do_work(NULL);
} else {
thread_work();
}
end = gethrtime();
vend = gethrvtime();
#if OS(Solaris)
check_sigmask(2);
#endif /* OS(Solaris) */
dump_arrays(end-start, vend-vstart, job_index);
}
}
/* we're done, return */
return(0);
}
int main(int argc, char *argv[])
{
int rc, i, j = 0, rid, ret;
armci_ckpt_ds_t ckptds;
ARMCI_Group grp;
ARMCI_Init_args(&argc, &argv);
nproc = armci_msg_nproc();
me = armci_msg_me();
if (me == 0) {
if (nproc > MAXPROCS) {
ARMCI_Error("nproc > MAXPROCS", nproc);
}
else {
printf("ARMCI test program (%d processes)\n", nproc);
fflush(stdout);
sleep(1);
}
}
armci_init_checkpoint2();
ARMCI_Group_get_world(&grp);
size = SIZE_;
rc = ARMCI_Malloc((void **)ptr_arr, size * 8);
printf("ARMCI test program (%d processes)\n", nproc);
fflush(stdout);
for (size = 1; size <= SIZE_; size *= 2) {
t1 = MPI_Wtime();
for (i = 0; i < 5; i++) {
for (rc = 0; rc < 15; rc++) {
do_work(size);
}
}
time_array[j++] = MPI_Wtime() - t1;
ARMCI_Barrier();
printf("%d:done for size %ld\n", me, size);
fflush(stdout);
}
(void)ARMCI_Ckpt_create_ds(&ckptds, 1);
ckptds.ptr_arr[0] = ptr_arr[me];
ckptds.sz[0] = SIZE_ * 8;
rid = ARMCI_Ckpt_init(NULL, &grp, 1, 0, &ckptds);
printf("%d: After ARMCI_Ckpt_init(): \n", me);
j = 0;
for (size = 128; size <= SIZE_; size *= 2) {
int rc;
int simulate_restart = 1;
t1 = MPI_Wtime();
ret = ARMCI_Ckpt(rid);
if (ret == ARMCI_CKPT) {
printf("%d: Performed CHECKPOINT @ size=%ld\n", me, size);
}
else if (ret == ARMCI_RESTART) {
simulate_restart = 0;
printf("%d: Performed RESTART @ size=%ld\n", me, size);
}
for (i = 0; i < 5; i++) {
for (rc = 0; rc < 15; rc++)
if (i == 3 && rc == 10) {
}
do_work(size);
}
time_array1[j++] = MPI_Wtime() - t1;
sleep(1);
if (simulate_restart && size == FAILURE_SIZE_) {
printf("%d: Simulating FAILURE @ size = %d\n", me, size);
ARMCI_Restart_simulate(rid, 1);
}
printf("%d: DONE for size=%ld regular=%f withckpt=%f\n\n",
me, size, time_array[j-1], time_array1[j-1]);
fflush(stdout);
}
ARMCI_Ckpt_finalize(rid);
printf("Before Finalize()\n");
ARMCI_Barrier();
ARMCI_Finalize();
armci_msg_finalize();
return(0);
}
int main(int argc, char* argv[]) {
auto uri = mongocxx::uri{(argc >= 2) ? argv[1] : mongocxx::uri::k_default_uri};
configure(std::move(uri));
return do_work() ? EXIT_SUCCESS : EXIT_FAILURE;
}
int
ACE_TMAIN (int argc_in,
ACE_TCHAR* argv_in[])
{
RPG_TRACE (ACE_TEXT ("::main"));
// *PROCESS PROFILE*
ACE_Profile_Timer process_profile;
// start profile timer...
process_profile.start ();
// step1: initialize
// // *PORTABILITY*: on Windows, init ACE...
//#if defined (ACE_WIN32) || defined (ACE_WIN64)
// if (ACE::init () == -1)
// {
// ACE_DEBUG ((LM_ERROR,
// ACE_TEXT ("failed to ACE::init(): \"%m\", aborting\n")));
// return EXIT_FAILURE;
// } // end IF
//#endif
// step1 init/validate configuration
// step1a: process commandline arguments
std::string configuration_path =
RPG_Common_File_Tools::getConfigurationDataDirectory (ACE_TEXT_ALWAYS_CHAR (BASEDIR),
true);
#if defined (DEBUG_DEBUGGER)
configuration_path = Common_File_Tools::getWorkingDirectory ();
#endif // #ifdef DEBUG_DEBUGGER
std::string configuration_file = configuration_path;
configuration_file += ACE_DIRECTORY_SEPARATOR_CHAR_A;
#if defined (DEBUG_DEBUGGER)
configuration_file += ACE_TEXT_ALWAYS_CHAR ("protocol");
configuration_file += ACE_DIRECTORY_SEPARATOR_CHAR_A;
#endif
configuration_file += ACE_TEXT_ALWAYS_CHAR (IRC_CLIENT_CNF_DEF_INI_FILE);
bool debug_parser = false;
bool log_to_file = false;
bool trace_information = false;
bool print_version_and_exit = false;
unsigned int num_thread_pool_threads = IRC_CLIENT_DEF_NUM_TP_THREADS;
if (!do_processArguments (argc_in,
argv_in,
configuration_file,
debug_parser,
log_to_file,
trace_information,
print_version_and_exit,
num_thread_pool_threads))
{
// make 'em learn...
do_printUsage (ACE::basename (argv_in[0]));
// // *PORTABILITY*: on Windows, fini ACE...
//#if defined (ACE_WIN32) || defined (ACE_WIN64)
// if (ACE::fini () == -1)
// ACE_DEBUG ((LM_ERROR,
// ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
//#endif
return EXIT_FAILURE;
} // end IF
// validate argument(s)
if (!Common_File_Tools::isReadable (configuration_file))
{
// make 'em learn...
do_printUsage (ACE::basename (argv_in[0]));
// // *PORTABILITY*: on Windows, fini ACE...
//#if defined (ACE_WIN32) || defined (ACE_WIN64)
// if (ACE::fini () == -1)
// ACE_DEBUG ((LM_ERROR,
// ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
//#endif
return EXIT_FAILURE;
} // end IF
// initialize logging and/or tracing
std::string log_file;
if (log_to_file)
log_file = RPG_Common_File_Tools::getLogFilename (ACE::basename (argv_in[0]));
if (!Common_Tools::initializeLogging (ACE::basename (argv_in[0]), // program name
log_file, // logfile
false, // log to syslog ?
false, // trace messages ?
trace_information, // debug messages ?
NULL)) // logger
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to Common_Tools::initializeLogging(), aborting\n")));
// // *PORTABILITY*: on Windows, need to fini ACE...
//#if defined (ACE_WIN32) || defined (ACE_WIN64)
// if (ACE::fini () == -1)
// ACE_DEBUG ((LM_ERROR,
// ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
//#endif
return EXIT_FAILURE;
} // end IF
// handle specific program modes
if (print_version_and_exit)
{
do_printVersion (ACE::basename (argv_in[0]));
Common_Tools::finalizeLogging ();
// // *PORTABILITY*: on Windows, fini ACE...
//#if defined (ACE_WIN32) || defined (ACE_WIN64)
// if (ACE::fini () == -1)
// ACE_DEBUG ((LM_ERROR,
// ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
//#endif
return EXIT_SUCCESS;
} // end IF
// initialize configuration object
Stream_AllocatorHeap heap_allocator;
RPG_Net_Protocol_MessageAllocator message_allocator (RPG_NET_MAXIMUM_NUMBER_OF_INFLIGHT_MESSAGES,
&heap_allocator);
RPG_Net_Protocol_Module_IRCHandler_Module IRC_handler_module (std::string ("IRCHandler"),
NULL);
RPG_Net_Protocol_Module_IRCHandler* IRC_handler_impl = NULL;
IRC_handler_impl =
dynamic_cast<RPG_Net_Protocol_Module_IRCHandler*>(IRC_handler_module.writer ());
if (!IRC_handler_impl)
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("dynamic_cast<RPG_Net_Protocol_Module_IRCHandler> failed, aborting\n")));
Common_Tools::finalizeLogging ();
// // *PORTABILITY*: on Windows, fini ACE...
//#if defined (ACE_WIN32) || defined (ACE_WIN64)
// if (ACE::fini () == -1)
// ACE_DEBUG ((LM_ERROR,
// ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
//#endif
return EXIT_FAILURE;
} // end IF
if (!IRC_handler_impl->initialize (&message_allocator,
RPG_NET_PROTOCOL_BUFFER_SIZE,
true, // auto-answer "ping" as a client ?...
true)) // clients print ('.') dots for received "pings"...
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to initialize module: \"%s\", aborting\n"),
ACE_TEXT (IRC_handler_module.name ())));
Common_Tools::finalizeLogging ();
// // *PORTABILITY*: on Windows, fini ACE...
//#if defined (ACE_WIN32) || defined (ACE_WIN64)
// if (ACE::fini () == -1)
// ACE_DEBUG ((LM_ERROR,
// ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
//#endif
return EXIT_FAILURE;
} // end IF
RPG_Net_Protocol_Configuration configuration;
// ************ socket configuration data ************
configuration.socketConfiguration.bufferSize =
RPG_NET_DEFAULT_SOCKET_RECEIVE_BUFFER_SIZE;
// ************ stream configuration data ****************
configuration.streamConfiguration.messageAllocator = &message_allocator;
configuration.streamConfiguration.bufferSize = RPG_NET_PROTOCOL_BUFFER_SIZE;
configuration.streamConfiguration.module = &IRC_handler_module;
configuration.streamConfiguration.statisticReportingInterval = 0; // == off
// ************ protocol configuration data **************
configuration.protocolConfiguration.streamConfiguration.crunchMessageBuffers =
RPG_NET_PROTOCOL_DEF_CRUNCH_MESSAGES;
configuration.protocolConfiguration.streamConfiguration.debugScanner =
debug_parser;
configuration.protocolConfiguration.streamConfiguration.debugParser =
debug_parser;
configuration.protocolConfiguration.clientPingInterval = 0; // servers only
configuration.protocolConfiguration.loginOptions.nick =
IRC_CLIENT_DEF_IRC_NICK;
std::string hostname;
Net_Common_Tools::retrieveLocalHostname (hostname);
if (IRC_CLIENT_CNF_IRC_USERMSG_TRADITIONAL)
{
configuration.protocolConfiguration.loginOptions.user.hostname.discriminator =
RPG_Net_Protocol_IRCLoginOptions::User::Hostname::STRING;
configuration.protocolConfiguration.loginOptions.user.hostname.string = &hostname;
} // end IF
else
{
configuration.protocolConfiguration.loginOptions.user.hostname.discriminator =
RPG_Net_Protocol_IRCLoginOptions::User::Hostname::BITMASK;
// *NOTE*: hybrid-7.2.3 seems to have a bug: 4 --> +i
configuration.protocolConfiguration.loginOptions.user.hostname.mode =
IRC_CLIENT_DEF_IRC_USERMODE;
} // end ELSE
configuration.protocolConfiguration.loginOptions.user.servername =
ACE_TEXT_ALWAYS_CHAR (RPG_NET_PROTOCOL_DEF_IRC_SERVERNAME);
configuration.protocolConfiguration.loginOptions.channel =
ACE_TEXT_ALWAYS_CHAR (IRC_CLIENT_DEF_IRC_CHANNEL);
// populate user/realname
Common_Tools::getCurrentUserName (configuration.protocolConfiguration.loginOptions.user.username,
configuration.protocolConfiguration.loginOptions.user.realname);
// step1db: parse config file (if any)
std::string serverHostname = ACE_TEXT_ALWAYS_CHAR(IRC_CLIENT_DEF_SERVER_HOSTNAME);
unsigned short serverPortNumber = IRC_CLIENT_DEF_SERVER_PORT;
if (!configuration_file.empty ())
do_parseConfigurationFile (configuration_file,
configuration.protocolConfiguration.loginOptions,
serverHostname,
serverPortNumber);
ACE_High_Res_Timer timer;
timer.start();
// step2: do actual work
do_work (configuration,
serverHostname,
serverPortNumber,
num_thread_pool_threads);
// clean up
IRC_handler_module.close ();
timer.stop ();
// debug info
std::string working_time_string;
ACE_Time_Value working_time;
timer.elapsed_time (working_time);
Common_Tools::period2String (working_time,
working_time_string);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("total working time (h:m:s.us): \"%s\"...\n"),
ACE_TEXT (working_time_string.c_str ())));
// stop profile timer...
process_profile.stop ();
// only process profile left to do...
ACE_Profile_Timer::ACE_Elapsed_Time elapsed_time;
elapsed_time.real_time = 0.0;
elapsed_time.user_time = 0.0;
elapsed_time.system_time = 0.0;
if (process_profile.elapsed_time (elapsed_time) == -1)
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE_Profile_Timer::elapsed_time: \"%m\", aborting\n")));
Common_Tools::finalizeLogging ();
// // *PORTABILITY*: on Windows, fini ACE...
//#if defined (ACE_WIN32) || defined (ACE_WIN64)
// if (ACE::fini () == -1)
// ACE_DEBUG ((LM_ERROR,
// ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
//#endif
return EXIT_FAILURE;
} // end IF
ACE_Profile_Timer::Rusage elapsed_rusage;
ACE_OS::memset (&elapsed_rusage, 0, sizeof (ACE_Profile_Timer::Rusage));
process_profile.elapsed_rusage(elapsed_rusage);
ACE_Time_Value user_time(elapsed_rusage.ru_utime);
ACE_Time_Value system_time(elapsed_rusage.ru_stime);
std::string user_time_string;
std::string system_time_string;
Common_Tools::period2String (user_time,
user_time_string);
Common_Tools::period2String (system_time,
system_time_string);
// debug info
#if !defined (ACE_WIN32) && !defined (ACE_WIN64)
ACE_DEBUG((LM_DEBUG,
ACE_TEXT(" --> Process Profile <--\nreal time = %A seconds\nuser time = %A seconds\nsystem time = %A seconds\n --> Resource Usage <--\nuser time used: %s\nsystem time used: %s\nmaximum resident set size = %d\nintegral shared memory size = %d\nintegral unshared data size = %d\nintegral unshared stack size = %d\npage reclaims = %d\npage faults = %d\nswaps = %d\nblock input operations = %d\nblock output operations = %d\nmessages sent = %d\nmessages received = %d\nsignals received = %d\nvoluntary context switches = %d\ninvoluntary context switches = %d\n"),
elapsed_time.real_time,
elapsed_time.user_time,
elapsed_time.system_time,
user_time_string.c_str(),
system_time_string.c_str(),
elapsed_rusage.ru_maxrss,
elapsed_rusage.ru_ixrss,
elapsed_rusage.ru_idrss,
elapsed_rusage.ru_isrss,
elapsed_rusage.ru_minflt,
elapsed_rusage.ru_majflt,
elapsed_rusage.ru_nswap,
elapsed_rusage.ru_inblock,
elapsed_rusage.ru_oublock,
elapsed_rusage.ru_msgsnd,
elapsed_rusage.ru_msgrcv,
elapsed_rusage.ru_nsignals,
elapsed_rusage.ru_nvcsw,
elapsed_rusage.ru_nivcsw));
#else
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT (" --> Process Profile <--\nreal time = %A seconds\nuser time = %A seconds\nsystem time = %A seconds\n --> Resource Usage <--\nuser time used: %s\nsystem time used: %s\n"),
elapsed_time.real_time,
elapsed_time.user_time,
elapsed_time.system_time,
user_time_string.c_str (),
system_time_string.c_str ()));
#endif
Common_Tools::finalizeLogging ();
// // *PORTABILITY*: on Windows, fini ACE...
//#if defined (ACE_WIN32) || defined (ACE_WIN64)
// if (ACE::fini () == -1)
// ACE_DEBUG ((LM_ERROR,
// ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
//#endif
return EXIT_SUCCESS;
} // end main
int main(int argc, char *argv[])
{
do_work(argc, argv);
return 0;
}
int
ACE_TMAIN (int argc_in,
ACE_TCHAR* argv_in[])
{
RPG_TRACE (ACE_TEXT ("::main"));
// step0: init ACE
// *PORTABILITY*: on Windows, init ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::init () == -1)
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::init(): \"%m\", aborting\n")));
return EXIT_FAILURE;
} // end IF
#endif
// step1: init
// step1a set defaults
std::string configuration_path =
RPG_Common_File_Tools::getConfigurationDataDirectory (ACE_TEXT_ALWAYS_CHAR (BASEDIR),
true);
std::string data_path =
RPG_Common_File_Tools::getConfigurationDataDirectory (ACE_TEXT_ALWAYS_CHAR (BASEDIR),
false);
#if defined (DEBUG_DEBUGGER)
configuration_path = Common_File_Tools::getWorkingDirectory ();
data_path = Common_File_Tools::getWorkingDirectory ();
#endif // DEBUG_DEBUGGER
bool dump_dictionary = false;
std::string sound_directory = data_path;
sound_directory += ACE_DIRECTORY_SEPARATOR_CHAR_A;
#if defined (DEBUG_DEBUGGER)
sound_directory += ACE_TEXT_ALWAYS_CHAR ("sound");
sound_directory += ACE_DIRECTORY_SEPARATOR_CHAR_A;
sound_directory += ACE_TEXT_ALWAYS_CHAR (RPG_COMMON_DATA_SUB);
#else
sound_directory += ACE_TEXT_ALWAYS_CHAR (RPG_SOUND_DATA_SUB);
#endif // DEBUG_DEBUGGER
bool play_random_sounds = SOUNDPARSER_DEF_PLAY_RANDOM_SOUNDS;
std::string schema_repository = configuration_path;
#if defined (DEBUG_DEBUGGER)
schema_repository += ACE_DIRECTORY_SEPARATOR_CHAR_A;
schema_repository += ACE_TEXT_ALWAYS_CHAR("engine");
#endif // DEBUG_DEBUGGER
std::string filename = configuration_path;
filename += ACE_DIRECTORY_SEPARATOR_CHAR_A;
#if defined (DEBUG_DEBUGGER)
filename += ACE_TEXT_ALWAYS_CHAR ("sound");
filename += ACE_DIRECTORY_SEPARATOR_CHAR_A;
#endif // DEBUG_DEBUGGER
filename += ACE_TEXT_ALWAYS_CHAR (RPG_SOUND_DICTIONARY_FILE);
bool trace_information = false;
bool print_version_and_exit = false;
bool validate_XML = true;
// RPG_Sound_SDLConfig_t audio_config;
// audio_config.frequency = RPG_SOUND_DEF_AUDIO_FREQUENCY;
// audio_config.format = RPG_SOUND_DEF_AUDIO_FORMAT;
// audio_config.channels = RPG_SOUND_DEF_AUDIO_CHANNELS;
// audio_config.chunksize = RPG_SOUND_DEF_AUDIO_CHUNKSIZE;
// step1b: parse/process/validate configuration
if (!do_processArguments (argc_in,
argv_in,
dump_dictionary,
sound_directory,
play_random_sounds,
filename,
trace_information,
print_version_and_exit,
validate_XML))
{
// make 'em learn...
do_printUsage (ACE::basename (argv_in[0]));
// *PORTABILITY*: on Windows, fini ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::fini () == -1)
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
#endif
return EXIT_FAILURE;
} // end IF
// step1b: validate arguments
if ((play_random_sounds &&
!Common_File_Tools::isDirectory (sound_directory)) ||
!Common_File_Tools::isReadable (filename))
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("invalid argument, aborting\n")));
// make 'em learn...
do_printUsage (ACE::basename (argv_in[0]));
// *PORTABILITY*: on Windows, fini ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::fini () == -1)
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
#endif
return EXIT_FAILURE;
} // end IF
// step1c: initialize logging and/or tracing
std::string log_file;
if (!Common_Tools::initializeLogging (ACE::basename (argv_in[0]), // program name
log_file, // logfile
false, // log to syslog ?
false, // trace messages ?
trace_information, // debug messages ?
NULL)) // logger
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to RPG_Common_Tools::initLogging(), aborting\n")));
// *PORTABILITY*: on Windows, fini ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::fini () == -1)
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::fini(): \"%m\", aborting\n")));
#endif
return EXIT_FAILURE;
} // end IF
// step1d: handle specific program modes
if (print_version_and_exit)
{
do_printVersion (ACE::basename (argv_in[0]));
return EXIT_SUCCESS;
} // end IF
// step2: init SDL
if (SDL_Init (SDL_INIT_TIMER |
SDL_INIT_AUDIO |
SDL_INIT_CDROM |
SDL_INIT_NOPARACHUTE) == -1) // "...Prevents SDL from catching fatal signals..."
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to SDL_Init(): \"%s\", aborting\n"),
ACE_TEXT (SDL_GetError ())));
// *PORTABILITY*: on Windows, we must fini ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::fini () == -1)
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n")));
#endif
return EXIT_FAILURE;
} // end IF
// ***** keyboard setup *****
// enable Unicode translation
SDL_EnableUNICODE (1);
// enable key repeat
SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY,
SDL_DEFAULT_REPEAT_INTERVAL);
// // ignore keyboard events
// SDL_EventState(SDL_KEYDOWN, SDL_IGNORE);
// SDL_EventState(SDL_KEYUP, SDL_IGNORE);
// // SDL event filter (filter mouse motion events and the like)
// SDL_SetEventFilter(event_filter_SDL_cb);
// step3: do actual work
ACE_High_Res_Timer timer;
timer.start ();
do_work (dump_dictionary,
sound_directory,
play_random_sounds,
schema_repository,
filename,
validate_XML);
timer.stop ();
// debug info
std::string working_time_string;
ACE_Time_Value working_time;
timer.elapsed_time (working_time);
Common_Tools::period2String (working_time,
working_time_string);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("total working time (h:m:s.us): \"%s\"...\n"),
ACE_TEXT (working_time_string.c_str ())));
// step4a: fini SDL
SDL_Quit ();
// *PORTABILITY*: on Windows, fini ACE...
#if defined (ACE_WIN32) || defined (ACE_WIN64)
if (ACE::fini () == -1)
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to ACE::fini(): \"%m\", aborting\n")));
return EXIT_FAILURE;
} // end IF
#endif
return EXIT_SUCCESS;
} // end main
static void do_workKK(void)
{
ServerScope = PR_GLOBAL_THREAD;
ClientScope = PR_GLOBAL_THREAD;
do_work();
}
int
main(int argc, char **argv)
{
int c;
int sts;
int use_localtime = 0;
int isdaemon = 0;
char *pmnsfile = PM_NS_DEFAULT;
char *username;
char *logfile = "pmlogger.log";
/* default log (not archive) file name */
char *endnum;
int i;
task_t *tp;
optcost_t ocp;
__pmFdSet readyfds;
char *p;
char *runtime = NULL;
int ctx; /* handle corresponding to ctxp below */
__pmContext *ctxp; /* pmlogger has just this one context */
int niter;
pid_t target_pid = 0;
__pmGetUsername(&username);
sep = __pmPathSeparator();
/*
* Warning:
* If any of the pmlogger options change, make sure the
* corresponding changes are made to pmnewlog when pmlogger
* options are passed through from the control file
*/
while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) {
switch (c) {
case 'c': /* config file */
if (access(opts.optarg, F_OK) == 0)
configfile = strdup(opts.optarg);
else {
/* does not exist as given, try the standard place */
char *sysconf = pmGetConfig("PCP_VAR_DIR");
int sz = strlen(sysconf)+strlen("/config/pmlogger/")+strlen(opts.optarg)+1;
if ((configfile = (char *)malloc(sz)) == NULL)
__pmNoMem("config file name", sz, PM_FATAL_ERR);
snprintf(configfile, sz,
"%s%c" "config%c" "pmlogger%c" "%s",
sysconf, sep, sep, sep, opts.optarg);
if (access(configfile, F_OK) != 0) {
/* still no good, error handling happens below */
free(configfile);
configfile = strdup(opts.optarg);
}
}
break;
case 'C': /* parse config and exit */
Cflag = 1;
break;
case 'D': /* debug flag */
sts = __pmParseDebug(opts.optarg);
if (sts < 0) {
pmprintf("%s: unrecognized debug flag specification (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
}
else
pmDebug |= sts;
break;
case 'h': /* hostname for PMCD to contact */
pmcd_host_conn = opts.optarg;
break;
case 'l': /* log file name */
logfile = opts.optarg;
break;
case 'K':
if ((endnum = __pmSpecLocalPMDA(opts.optarg)) != NULL) {
pmprintf("%s: __pmSpecLocalPMDA failed: %s\n",
pmProgname, endnum);
opts.errors++;
}
break;
case 'L': /* linger if not primary logger */
linger = 1;
break;
case 'm': /* note for port map file */
note = opts.optarg;
isdaemon = ((strcmp(note, "pmlogger_check") == 0) ||
(strcmp(note, "pmlogger_daily") == 0));
break;
case 'n': /* alternative name space file */
pmnsfile = opts.optarg;
break;
case 'o': /* local context mode, no pmcd */
/*
* Note, using Lflag here because this has the same
* semantics as -L for all the other PCP commands, but
* -L was already taken (for "linger") in pmlogger, so
* we're forced to use -o on the command line.
*/
host_context = PM_CONTEXT_LOCAL;
opts.Lflag = 1;
break;
case 'p':
target_pid = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0') {
pmprintf("%s: invalid process identifier (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
} else if (!__pmProcessExists(target_pid)) {
pmprintf("%s: PID error - no such process (%d)\n",
pmProgname, target_pid);
opts.errors++;
}
break;
case 'P': /* this is the primary pmlogger */
primary = 1;
isdaemon = 1;
break;
case 'r': /* report sizes of pmResult records */
rflag = 1;
break;
case 's': /* exit size */
sts = ParseSize(opts.optarg, &exit_samples, &exit_bytes, &exit_time);
if (sts < 0) {
pmprintf("%s: illegal size argument '%s' for exit size\n",
pmProgname, opts.optarg);
opts.errors++;
}
else if (exit_time.tv_sec > 0) {
__pmAFregister(&exit_time, NULL, run_done_callback);
}
break;
case 'T': /* end time */
runtime = opts.optarg;
break;
case 't': /* change default logging interval */
if (pmParseInterval(opts.optarg, &delta, &p) < 0) {
pmprintf("%s: illegal -t argument\n%s", pmProgname, p);
free(p);
opts.errors++;
}
break;
case 'U': /* run as named user */
username = opts.optarg;
isdaemon = 1;
break;
case 'u': /* flush output buffers after each fetch */
/*
* all archive write I/O is unbuffered now, so maintain -u
* for backwards compatibility only
*/
break;
case 'v': /* volume switch after given size */
sts = ParseSize(opts.optarg, &vol_switch_samples, &vol_switch_bytes,
&vol_switch_time);
if (sts < 0) {
pmprintf("%s: illegal size argument '%s' for volume size\n",
pmProgname, opts.optarg);
opts.errors++;
}
else if (vol_switch_time.tv_sec > 0) {
vol_switch_afid = __pmAFregister(&vol_switch_time, NULL,
vol_switch_callback);
}
break;
case 'V':
archive_version = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0' || archive_version != PM_LOG_VERS02) {
pmprintf("%s: -V requires a version number of %d\n",
pmProgname, PM_LOG_VERS02);
opts.errors++;
}
break;
case 'x': /* recording session control fd */
rsc_fd = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0' || rsc_fd < 0) {
pmprintf("%s: -x requires a non-negative numeric argument\n", pmProgname);
opts.errors++;
}
else {
time(&rsc_start);
}
break;
case 'y':
use_localtime = 1;
break;
case '?':
default:
opts.errors++;
break;
}
}
if (pmcd_host_conn != NULL && primary) {
pmprintf(
"%s: -P and -h are mutually exclusive; use -P only when running\n"
"%s on the same (local) host as the PMCD to which it connects.\n",
pmProgname, pmProgname);
opts.errors++;
}
if (pmcd_host_conn != NULL && host_context == PM_CONTEXT_LOCAL) {
pmprintf(
"%s: -o and -h are mutually exclusive; use -o only when running\n"
"%s on the same (local) host as the DSO PMDA(s) being used.\n",
pmProgname, pmProgname);
opts.errors++;
}
if (!opts.errors && opts.optind != argc - 1) {
pmprintf("%s: insufficient arguments\n", pmProgname);
opts.errors++;
}
if (opts.errors) {
pmUsageMessage(&opts);
exit(1);
}
if (rsc_fd != -1 && note == NULL) {
/* add default note to indicate running with -x */
static char xnote[10];
snprintf(xnote, sizeof(xnote), "-x %d", rsc_fd);
note = xnote;
}
/* if we are running as a daemon, change user early */
if (isdaemon)
__pmSetProcessIdentity(username);
if (Cflag == 0) {
__pmOpenLog("pmlogger", logfile, stderr, &sts);
if (sts != 1) {
fprintf(stderr, "%s: Warning: log file (%s) creation failed\n", pmProgname, logfile);
/* continue on ... writing to stderr */
}
}
/* base name for archive is here ... */
archBase = argv[opts.optind];
/* initialise access control */
if (__pmAccAddOp(PM_OP_LOG_ADV) < 0 ||
__pmAccAddOp(PM_OP_LOG_MAND) < 0 ||
__pmAccAddOp(PM_OP_LOG_ENQ) < 0) {
fprintf(stderr, "%s: access control initialisation failed\n", pmProgname);
exit(1);
}
if (pmnsfile != PM_NS_DEFAULT) {
if ((sts = pmLoadASCIINameSpace(pmnsfile, 1)) < 0) {
fprintf(stderr, "%s: Cannot load namespace from \"%s\": %s\n", pmProgname, pmnsfile, pmErrStr(sts));
exit(1);
}
}
if (host_context == PM_CONTEXT_LOCAL)
pmcd_host_conn = "local context";
else if (pmcd_host_conn == NULL)
pmcd_host_conn = "local:";
if ((ctx = pmNewContext(host_context, pmcd_host_conn)) < 0) {
fprintf(stderr, "%s: Cannot connect to PMCD on host \"%s\": %s\n", pmProgname, pmcd_host_conn, pmErrStr(ctx));
exit(1);
}
pmcd_host = (char *)pmGetContextHostName(ctx);
if (strlen(pmcd_host) == 0) {
fprintf(stderr, "%s: pmGetContextHostName(%d) failed\n",
pmProgname, ctx);
exit(1);
}
if (rsc_fd == -1 && host_context != PM_CONTEXT_LOCAL) {
/* no -x, so register client id with pmcd */
__pmSetClientIdArgv(argc, argv);
}
/*
* discover fd for comms channel to PMCD ...
*/
if (host_context != PM_CONTEXT_LOCAL) {
if ((ctxp = __pmHandleToPtr(ctx)) == NULL) {
fprintf(stderr, "%s: botch: __pmHandleToPtr(%d) returns NULL!\n", pmProgname, ctx);
exit(1);
}
pmcdfd = ctxp->c_pmcd->pc_fd;
PM_UNLOCK(ctxp->c_lock);
}
yyin = do_pmcpp(configfile);
/* do not return unless yyin is valid */
if (configfile == NULL)
configfile = strdup("<stdin>");
__pmOptFetchGetParams(&ocp);
ocp.c_scope = 1;
__pmOptFetchPutParams(&ocp);
/* prevent early timer events ... */
__pmAFblock();
if (yyparse() != 0)
exit(1);
fclose(yyin);
yyend();
#ifdef PCP_DEBUG
fprintf(stderr, "Config parsed\n");
#endif
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_LOG) {
fprintf(stderr, "optFetch Cost Parameters: pmid=%d indom=%d fetch=%d scope=%d\n",
ocp.c_pmid, ocp.c_indom, ocp.c_fetch, ocp.c_scope);
fprintf(stderr, "\nAfter loading config ...\n");
for (tp = tasklist; tp != NULL; tp = tp->t_next) {
if (tp->t_numvalid == 0)
continue;
fprintf(stderr, " state: %sin log, %savail, %s, %s",
PMLC_GET_INLOG(tp->t_state) ? "" : "not ",
PMLC_GET_AVAIL(tp->t_state) ? "" : "un",
PMLC_GET_MAND(tp->t_state) ? "mand" : "adv",
PMLC_GET_ON(tp->t_state) ? "on" : "off");
fprintf(stderr, " delta: %ld usec",
(long)(1000 * tp->t_delta.tv_sec + tp->t_delta.tv_usec));
fprintf(stderr, " numpmid: %d\n", tp->t_numpmid);
for (i = 0; i < tp->t_numpmid; i++) {
fprintf(stderr, " %s (%s):\n", pmIDStr(tp->t_pmidlist[i]), tp->t_namelist[i]);
}
__pmOptFetchDump(stderr, tp->t_fetch);
}
}
#endif
if (Cflag)
exit(0);
fprintf(stderr, "Starting %slogger for host \"%s\" via \"%s\"\n",
primary ? "primary " : "", pmcd_host, pmcd_host_conn);
if (!primary && tasklist == NULL && !linger) {
fprintf(stderr, "Nothing to log, and not the primary logger instance ... good-bye\n");
exit(1);
}
if ((sts = __pmLogCreate(pmcd_host, archBase, archive_version, &logctl)) < 0) {
fprintf(stderr, "__pmLogCreate: %s\n", pmErrStr(sts));
exit(1);
}
else {
/*
* try and establish $TZ from the remote PMCD ...
* Note the label record has been set up, but not written yet
*/
char *name = "pmcd.timezone";
pmID pmid;
pmResult *resp;
__pmtimevalNow(&epoch);
sts = pmUseContext(ctx);
if (sts >= 0)
sts = pmLookupName(1, &name, &pmid);
if (sts >= 0)
sts = pmFetch(1, &pmid, &resp);
if (sts >= 0) {
if (resp->vset[0]->numval > 0) { /* pmcd.timezone present */
strcpy(logctl.l_label.ill_tz, resp->vset[0]->vlist[0].value.pval->vbuf);
/* prefer to use remote time to avoid clock drift problems */
epoch = resp->timestamp; /* struct assignment */
if (! use_localtime)
pmNewZone(logctl.l_label.ill_tz);
}
#ifdef PCP_DEBUG
else if (pmDebug & DBG_TRACE_LOG) {
fprintf(stderr,
"main: Could not get timezone from host %s\n",
pmcd_host);
}
#endif
pmFreeResult(resp);
}
}
/* do ParseTimeWindow stuff for -T */
if (runtime) {
struct timeval res_end; /* time window end */
struct timeval start;
struct timeval end;
struct timeval last_delta;
char *err_msg; /* parsing error message */
time_t now;
struct timeval now_tv;
time(&now);
now_tv.tv_sec = now;
now_tv.tv_usec = 0;
start = now_tv;
end.tv_sec = INT_MAX;
end.tv_usec = INT_MAX;
sts = __pmParseTime(runtime, &start, &end, &res_end, &err_msg);
if (sts < 0) {
fprintf(stderr, "%s: illegal -T argument\n%s", pmProgname, err_msg);
exit(1);
}
last_delta = res_end;
tsub(&last_delta, &now_tv);
__pmAFregister(&last_delta, NULL, run_done_callback);
last_stamp = res_end;
}
fprintf(stderr, "Archive basename: %s\n", archBase);
#ifndef IS_MINGW
/* detach yourself from the launching process */
if (isdaemon)
setpgid(getpid(), 0);
#endif
/* set up control port */
init_ports();
__pmFD_ZERO(&fds);
for (i = 0; i < CFD_NUM; ++i) {
if (ctlfds[i] >= 0)
__pmFD_SET(ctlfds[i], &fds);
}
#ifndef IS_MINGW
if (pmcdfd != -1)
__pmFD_SET(pmcdfd, &fds);
#endif
if (rsc_fd != -1)
__pmFD_SET(rsc_fd, &fds);
numfds = maxfd() + 1;
if ((sts = do_preamble()) < 0)
fprintf(stderr, "Warning: problem writing archive preamble: %s\n",
pmErrStr(sts));
sts = 0; /* default exit status */
parse_done = 1; /* enable callback processing */
__pmAFunblock();
for ( ; ; ) {
int nready;
#ifdef PCP_DEBUG
if ((pmDebug & DBG_TRACE_APPL2) && (pmDebug & DBG_TRACE_DESPERATE)) {
fprintf(stderr, "before __pmSelectRead(%d,...): run_done_alarm=%d vol_switch_alarm=%d log_alarm=%d\n", numfds, run_done_alarm, vol_switch_alarm, log_alarm);
}
#endif
niter = 0;
while (log_alarm && niter++ < 10) {
__pmAFblock();
log_alarm = 0;
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "delayed callback: log_alarm\n");
#endif
for (tp = tasklist; tp != NULL; tp = tp->t_next) {
if (tp->t_alarm) {
tp->t_alarm = 0;
do_work(tp);
}
}
__pmAFunblock();
}
if (vol_switch_alarm) {
__pmAFblock();
vol_switch_alarm = 0;
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "delayed callback: vol_switch_alarm\n");
#endif
newvolume(VOL_SW_TIME);
__pmAFunblock();
}
if (run_done_alarm) {
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "delayed callback: run_done_alarm\n");
#endif
run_done(0, NULL);
/*NOTREACHED*/
}
__pmFD_COPY(&readyfds, &fds);
nready = __pmSelectRead(numfds, &readyfds, NULL);
#ifdef PCP_DEBUG
if ((pmDebug & DBG_TRACE_APPL2) && (pmDebug & DBG_TRACE_DESPERATE)) {
fprintf(stderr, "__pmSelectRead(%d,...) done: nready=%d run_done_alarm=%d vol_switch_alarm=%d log_alarm=%d\n", numfds, nready, run_done_alarm, vol_switch_alarm, log_alarm);
}
#endif
__pmAFblock();
if (nready > 0) {
/* handle request on control port */
for (i = 0; i < CFD_NUM; ++i) {
if (ctlfds[i] >= 0 && __pmFD_ISSET(ctlfds[i], &readyfds)) {
if (control_req(ctlfds[i])) {
/* new client has connected */
__pmFD_SET(clientfd, &fds);
if (clientfd >= numfds)
numfds = clientfd + 1;
}
}
}
if (clientfd >= 0 && __pmFD_ISSET(clientfd, &readyfds)) {
/* process request from client, save clientfd in case client
* closes connection, resetting clientfd to -1
*/
int fd = clientfd;
if (client_req()) {
/* client closed connection */
__pmFD_CLR(fd, &fds);
__pmCloseSocket(clientfd);
clientfd = -1;
numfds = maxfd() + 1;
qa_case = 0;
}
}
#ifndef IS_MINGW
if (pmcdfd >= 0 && __pmFD_ISSET(pmcdfd, &readyfds)) {
/*
* do not expect this, given synchronous commumication with the
* pmcd ... either pmcd has terminated, or bogus PDU ... or its
* Win32 and we are operating under the different conditions of
* our AF.c implementation there, which has to deal with a lack
* of signal support on Windows - race condition exists between
* this check and the async event timer callback.
*/
__pmPDU *pb;
__pmPDUHdr *php;
sts = __pmGetPDU(pmcdfd, ANY_SIZE, TIMEOUT_NEVER, &pb);
if (sts <= 0) {
if (sts < 0)
fprintf(stderr, "Error: __pmGetPDU: %s\n", pmErrStr(sts));
disconnect(sts);
}
else {
php = (__pmPDUHdr *)pb;
fprintf(stderr, "Error: Unsolicited %s PDU from PMCD\n",
__pmPDUTypeStr(php->type));
disconnect(PM_ERR_IPC);
}
if (sts > 0)
__pmUnpinPDUBuf(pb);
}
#endif
if (rsc_fd >= 0 && __pmFD_ISSET(rsc_fd, &readyfds)) {
/*
* some action on the recording session control fd
* end-of-file means launcher has quit, otherwise we
* expect one of these commands
* V<number>\n - version
* F<folio>\n - folio name
* P<name>\n - launcher's name
* R\n - launcher can replay
* D\n - detach from launcher
* Q\n - quit pmlogger
*/
char rsc_buf[MAXPATHLEN];
char *rp = rsc_buf;
char myc;
int fake_x = 0;
for (rp = rsc_buf; ; rp++) {
if (read(rsc_fd, &myc, 1) <= 0) {
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "recording session control: eof\n");
#endif
if (rp != rsc_buf) {
*rp = '\0';
fprintf(stderr, "Error: incomplete recording session control message: \"%s\"\n", rsc_buf);
}
fake_x = 1;
break;
}
if (rp >= &rsc_buf[MAXPATHLEN]) {
fprintf(stderr, "Error: absurd recording session control message: \"%100.100s ...\"\n", rsc_buf);
fake_x = 1;
break;
}
if (myc == '\n') {
*rp = '\0';
break;
}
*rp = myc;
}
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2) {
if (fake_x == 0)
fprintf(stderr, "recording session control: \"%s\"\n", rsc_buf);
}
#endif
if (fake_x)
do_dialog('X');
else if (strcmp(rsc_buf, "Q") == 0 ||
strcmp(rsc_buf, "D") == 0 ||
strcmp(rsc_buf, "?") == 0)
do_dialog(rsc_buf[0]);
else if (rsc_buf[0] == 'F')
folio_name = strdup(&rsc_buf[1]);
else if (rsc_buf[0] == 'P')
rsc_prog = strdup(&rsc_buf[1]);
else if (strcmp(rsc_buf, "R") == 0)
rsc_replay = 1;
else if (rsc_buf[0] == 'V' && rsc_buf[1] == '0') {
/*
* version 0 of the recording session control ...
* this is all we grok at the moment
*/
;
}
else {
fprintf(stderr, "Error: illegal recording session control message: \"%s\"\n", rsc_buf);
do_dialog('X');
}
}
}
else if (vol_switch_flag) {
newvolume(VOL_SW_SIGHUP);
vol_switch_flag = 0;
}
else if (nready < 0 && neterror() != EINTR)
fprintf(stderr, "Error: select: %s\n", netstrerror());
__pmAFunblock();
if (target_pid && !__pmProcessExists(target_pid))
exit(EXIT_SUCCESS);
if (exit_code)
break;
}
exit(exit_code);
}
void imageCallbackWithInfo(const sensor_msgs::ImageConstPtr& msg, const sensor_msgs::CameraInfoConstPtr& cam_info)
{
do_work(msg, cam_info->header.frame_id);
}
void gauss_mp(double* img, int N, int max_iter){
double delta = 2.0/(double)(N+2);
double delta2 = pow(delta,2);
int* start;
int* finish;
#pragma omp parallel shared(start, finish, delta, delta2,img,N,max_iter)
{
#pragma omp single
{
printf("NumThreads %i\n", omp_get_num_threads());
start = malloc(sizeof(int) * (omp_get_num_threads() + 2));
finish = malloc(sizeof(int) * (omp_get_num_threads() + 2));
start[omp_get_num_threads() + 1] = max_iter + 1;
finish[0] = max_iter + 1;
}
int thread_id = omp_get_thread_num() + 1;
start[thread_id] = 0;
finish[thread_id] = 0;
const int grid_size = N / omp_get_num_threads();
int i_lower = (grid_size * (thread_id - 1)) + 1;
int i_upper = grid_size * thread_id;
// TODO Fix rounding errors
#pragma omp barrier
for(int k = 1; k <= max_iter; k++){
//printf("%i waiting for first guard on %i'th iteration finish[%i] \n", thread_id, k, finish[thread_id-1]);
while(finish[thread_id - 1] < k) { // Guard 1
#pragma omp flush(finish)
}
//printf("%i passed first guard on %i'th iteration\n", thread_id, k);
#pragma omp for schedule(static) nowait
for(int i = 1; i <= N; i++) {
if(i == i_lower) {
do_work(img, delta2, delta, N, i); // TODO Check if this is inlined
start[thread_id] = k;
#pragma omp flush(start)
}
else if(i == i_upper) {
// printf("%i waiting on second guard on %i'th iteration start[%i] \n", thread_id, k, start[thread_id+1]);
while(start[thread_id + 1] < k-1) { // Guard 2
#pragma omp flush(start)
}
//printf("%i passed second guard on %i'th iteration\n", thread_id, k);
do_work(img, delta2, delta ,N, i);
finish[thread_id] = k;
#pragma omp flush(finish)
}
else {
do_work(img, delta2, delta, N, i);
//printf("%.1f ",f(i,j,N+2,delta)*delta2);
}
} /* for j */
} /* parallel for i */
//printf("\n");
} /* for k*/
return;
}
static void do_workUU(void)
{
ServerScope = PR_LOCAL_THREAD;
ClientScope = PR_LOCAL_THREAD;
do_work();
}
void operator () () {
do_work();
}
