static void initialize_hardware_concurrency_info () {
int err;
int availableProcs = 0;
int numMasks = 1;
#if __linux__
#if __TBB_MAIN_THREAD_AFFINITY_BROKEN
int maxProcs = INT_MAX; // To check the entire mask.
int pid = 0; // Get the mask of the calling thread.
#else
int maxProcs = sysconf(_SC_NPROCESSORS_ONLN);
int pid = getpid();
#endif
cpu_set_t *processMask;
const size_t BasicMaskSize = sizeof(cpu_set_t);
for (;;) {
int curMaskSize = BasicMaskSize * numMasks;
processMask = new cpu_set_t[numMasks];
memset( processMask, 0, curMaskSize );
err = sched_getaffinity( pid, curMaskSize, processMask );
if ( !err || errno != EINVAL || curMaskSize * CHAR_BIT >= 256 * 1024 )
break;
delete[] processMask;
numMasks <<= 1;
}
#else /* FreeBSD >= 7.1 */
int maxProcs = sysconf(_SC_NPROCESSORS_ONLN);
cpuset_t *processMask;
const size_t BasicMaskSize = sizeof(cpuset_t);
for (;;) {
int curMaskSize = BasicMaskSize * numMasks;
processMask = new cpuset_t[numMasks];
memset( processMask, 0, curMaskSize );
// CPU_LEVEL_WHICH - anonymous (current) mask, CPU_LEVEL_CPUSET - assigned mask
#if __TBB_MAIN_THREAD_AFFINITY_BROKEN
err = cpuset_getaffinity( CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, curMaskSize, processMask );
#else
err = cpuset_getaffinity( CPU_LEVEL_WHICH, CPU_WHICH_PID, -1, curMaskSize, processMask );
#endif
if ( !err || errno != ERANGE || curMaskSize * CHAR_BIT >= 16 * 1024 )
break;
delete[] processMask;
numMasks <<= 1;
}
#endif /* FreeBSD >= 7.1 */
if ( !err ) {
for ( int m = 0; availableProcs < maxProcs && m < numMasks; ++m ) {
for ( size_t i = 0; (availableProcs < maxProcs) && (i < BasicMaskSize * CHAR_BIT); ++i ) {
if ( CPU_ISSET( i, processMask + m ) )
++availableProcs;
}
}
num_masks = numMasks;
process_mask = processMask;
}
else {
availableProcs = (maxProcs == INT_MAX) ? sysconf(_SC_NPROCESSORS_ONLN) : maxProcs;
delete[] processMask;
}
theNumProcs = availableProcs > 0 ? availableProcs : 1; // Fail safety strap
__TBB_ASSERT( theNumProcs <= sysconf(_SC_NPROCESSORS_ONLN), NULL );
}
/**
* Signal handler for HUP which tells us to swap the log file
* and reload configuration file if specified
*
* @param sig
*/
void
do_signal_sighup(RunTimeOpts * rtOpts, PtpClock * ptpClock)
{
NOTIFY("SIGHUP received\n");
#ifdef RUNTIME_DEBUG
if(rtOpts->transport == UDP_IPV4 && rtOpts->ip_mode != IPMODE_UNICAST) {
DBG("SIGHUP - running an ipv4 multicast based mode, re-sending IGMP joins\n");
netRefreshIGMP(&ptpClock->netPath, rtOpts, ptpClock);
}
#endif /* RUNTIME_DEBUG */
/* if we don't have a config file specified, we're done - just reopen log files*/
if(strlen(rtOpts->configFile) == 0)
goto end;
dictionary* tmpConfig = dictionary_new(0);
/* Try reloading the config file */
NOTIFY("Reloading configuration file: %s\n",rtOpts->configFile);
if(!loadConfigFile(&tmpConfig, rtOpts)) {
dictionary_del(tmpConfig);
goto end;
}
dictionary_merge(rtOpts->cliConfig, tmpConfig, 1, "from command line");
/* Load default config to fill in the blanks in the config file */
RunTimeOpts tmpOpts;
loadDefaultSettings(&tmpOpts);
/* Check the new configuration for errors, fill in the blanks from defaults */
if( ( rtOpts->candidateConfig = parseConfig(tmpConfig,&tmpOpts)) == NULL ) {
WARNING("Configuration file has errors, reload aborted\n");
dictionary_del(tmpConfig);
goto end;
}
/* Check for changes between old and new configuration */
if(compareConfig(rtOpts->candidateConfig,rtOpts->currentConfig)) {
INFO("Configuration unchanged\n");
goto cleanup;
}
/*
* Mark which subsystems have to be restarted. Most of this will be picked up by doState()
* If there are errors past config correctness (such as non-existent NIC,
* or lock file clashes if automatic lock files used - abort the mission
*/
rtOpts->restartSubsystems =
checkSubsystemRestart(rtOpts->candidateConfig, rtOpts->currentConfig);
/* If we're told to re-check lock files, do it: tmpOpts already has what rtOpts should */
if( (rtOpts->restartSubsystems & PTPD_CHECK_LOCKS) &&
tmpOpts.autoLockFile && !checkOtherLocks(&tmpOpts)) {
rtOpts->restartSubsystems = -1;
}
/* If the network configuration has changed, check if the interface is OK */
if(rtOpts->restartSubsystems & PTPD_RESTART_NETWORK) {
INFO("Network configuration changed - checking interface\n");
if(!testInterface(tmpOpts.ifaceName, &tmpOpts)) {
rtOpts->restartSubsystems = -1;
ERROR("Error: Cannot use %s interface\n",tmpOpts.ifaceName);
}
}
#if defined(linux) && defined(HAVE_SCHED_H)
/* Changing the CPU affinity mask */
if(rtOpts->restartSubsystems & PTPD_CHANGE_CPUAFFINITY) {
NOTIFY("Applying CPU binding configuration: changing selected CPU core\n");
cpu_set_t mask;
CPU_ZERO(&mask);
if(tmpOpts.cpuNumber > -1) {
CPU_SET(tmpOpts.cpuNumber,&mask);
} else {
int i;
for(i = 0; i < CPU_SETSIZE; i++) {
CPU_SET(i, &mask);
}
}
if(sched_setaffinity(0, sizeof(mask), &mask) < 0) {
if(tmpOpts.cpuNumber == -1) {
PERROR("Could not unbind from CPU core %d", rtOpts->cpuNumber);
} else {
PERROR("Could bind to CPU core %d", tmpOpts.cpuNumber);
}
rtOpts->restartSubsystems = -1;
} else {
if(tmpOpts.cpuNumber > -1)
INFO("Successfully bound "PTPD_PROGNAME" to CPU core %d\n", tmpOpts.cpuNumber);
else
INFO("Successfully unbound "PTPD_PROGNAME" from cpu core CPU core %d\n", rtOpts->cpuNumber);
}
}
#endif /* linux && HAVE_SCHED_H */
#ifdef HAVE_SYS_CPUSET_H
/* Changing the CPU affinity mask */
if (rtOpts->restartSubsystems & PTPD_CHANGE_CPUAFFINITY) {
NOTIFY("Applying CPU binding configuration:"
"changing selected CPU core\n");
cpuset_t mask;
CPU_ZERO(&mask);
if (tmpOpts.cpuNumber < 0) {
if (cpuset_getaffinity(CPU_LEVEL_ROOT, CPU_WHICH_CPUSET, 1,
sizeof(mask), &mask) < 0)
PERROR("Could not get affinity.");
if (cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID,
-1, sizeof(mask), &mask) < 0)
PERROR("Could not unbind from CPU core %d",
rtOpts->cpuNumber);
else
INFO("Successfully unbound "
PTPD_PROGNAME" from cpu core CPU core %d\n",
rtOpts->cpuNumber);
} else {
CPU_SET(tmpOpts.cpuNumber,&mask);
if (cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID,
-1, sizeof(mask), &mask) < 0) {
PERROR("Could not bind to CPU core %d",
tmpOpts.cpuNumber);
rtOpts->restartSubsystems = -1;
} else {
INFO("Successfully bound "
PTPD_PROGNAME" to CPU core %d\n",
tmpOpts.cpuNumber);
}
}
}
#endif
if(rtOpts->restartSubsystems == -1) {
ERROR("New configuration cannot be applied - aborting reload\n");
rtOpts->restartSubsystems = 0;
goto cleanup;
}
/* Tell parseConfig to shut up - it's had its chance already */
dictionary_set(rtOpts->candidateConfig,"%quiet%:%quiet%","Y");
/**
* Commit changes to rtOpts and currentConfig
* (this should never fail as the config has already been checked if we're here)
* However if this DOES fail, some default has been specified out of range -
* this is the only situation where parse will succeed but commit not:
* disable quiet mode to show what went wrong, then die.
*/
if (rtOpts->currentConfig) {
dictionary_del(rtOpts->currentConfig);
}
if ( (rtOpts->currentConfig = parseConfig(rtOpts->candidateConfig,rtOpts)) == NULL) {
CRITICAL("************ "PTPD_PROGNAME": parseConfig returned NULL during config commit"
" - this is a BUG - report the following: \n");
dictionary_unset(rtOpts->candidateConfig,"%quiet%:%quiet%");
if ((rtOpts->currentConfig = parseConfig(rtOpts->candidateConfig,rtOpts)) == NULL)
CRITICAL("*****************" PTPD_PROGNAME" shutting down **********************\n");
/*
* Could be assert(), but this should be done any time this happens regardless of
* compile options. Anyhow, if we're here, the daemon will no doubt segfault soon anyway
*/
abort();
}
/* clean up */
cleanup:
dictionary_del(tmpConfig);
dictionary_del(rtOpts->candidateConfig);
end:
if(rtOpts->recordLog.logEnabled ||
rtOpts->eventLog.logEnabled ||
(rtOpts->statisticsLog.logEnabled))
INFO("Reopening log files\n");
restartLogging(rtOpts);
if(rtOpts->statisticsLog.logEnabled)
ptpClock->resetStatisticsLog = TRUE;
}
