/*
* read_slurmdbd_conf - load the SlurmDBD configuration from the slurmdbd.conf
* file. Store result into global variable slurmdbd_conf.
* This function can be called more than once.
* RET SLURM_SUCCESS if no error, otherwise an error code
*/
extern int read_slurmdbd_conf(void)
{
s_p_options_t options[] = {
{"ArchiveDir", S_P_STRING},
{"ArchiveEvents", S_P_BOOLEAN},
{"ArchiveJobs", S_P_BOOLEAN},
{"ArchiveResvs", S_P_BOOLEAN},
{"ArchiveScript", S_P_STRING},
{"ArchiveSteps", S_P_BOOLEAN},
{"ArchiveSuspend", S_P_BOOLEAN},
{"ArchiveTXN", S_P_BOOLEAN},
{"ArchiveUsage", S_P_BOOLEAN},
{"AuthInfo", S_P_STRING},
{"AuthType", S_P_STRING},
{"CommitDelay", S_P_UINT16},
{"DbdAddr", S_P_STRING},
{"DbdBackupHost", S_P_STRING},
{"DbdHost", S_P_STRING},
{"DbdPort", S_P_UINT16},
{"DebugFlags", S_P_STRING},
{"DebugLevel", S_P_STRING},
{"DebugLevelSyslog", S_P_STRING},
{"DefaultQOS", S_P_STRING},
{"JobPurge", S_P_UINT32},
{"LogFile", S_P_STRING},
{"LogTimeFormat", S_P_STRING},
{"MaxQueryTimeRange", S_P_STRING},
{"MessageTimeout", S_P_UINT16},
{"PidFile", S_P_STRING},
{"PluginDir", S_P_STRING},
{"PrivateData", S_P_STRING},
{"PurgeEventAfter", S_P_STRING},
{"PurgeJobAfter", S_P_STRING},
{"PurgeResvAfter", S_P_STRING},
{"PurgeStepAfter", S_P_STRING},
{"PurgeSuspendAfter", S_P_STRING},
{"PurgeTXNAfter", S_P_STRING},
{"PurgeUsageAfter", S_P_STRING},
{"PurgeEventMonths", S_P_UINT32},
{"PurgeJobMonths", S_P_UINT32},
{"PurgeStepMonths", S_P_UINT32},
{"PurgeSuspendMonths", S_P_UINT32},
{"PurgeTXNMonths", S_P_UINT32},
{"PurgeUsageMonths", S_P_UINT32},
{"SlurmUser", S_P_STRING},
{"StepPurge", S_P_UINT32},
{"StorageBackupHost", S_P_STRING},
{"StorageHost", S_P_STRING},
{"StorageLoc", S_P_STRING},
{"StoragePass", S_P_STRING},
{"StoragePort", S_P_UINT16},
{"StorageType", S_P_STRING},
{"StorageUser", S_P_STRING},
{"TCPTimeout", S_P_UINT16},
{"TrackWCKey", S_P_BOOLEAN},
{"TrackSlurmctldDown", S_P_BOOLEAN},
{NULL} };
s_p_hashtbl_t *tbl = NULL;
char *conf_path = NULL;
char *temp_str = NULL;
struct stat buf;
/* Set initial values */
slurm_mutex_lock(&conf_mutex);
if (slurmdbd_conf == NULL) {
slurmdbd_conf = xmalloc(sizeof(slurm_dbd_conf_t));
boot_time = time(NULL);
}
slurmdbd_conf->debug_level = LOG_LEVEL_INFO;
_clear_slurmdbd_conf();
/* Get the slurmdbd.conf path and validate the file */
conf_path = get_extra_conf_path("slurmdbd.conf");
if ((conf_path == NULL) || (stat(conf_path, &buf) == -1)) {
info("No slurmdbd.conf file (%s)", conf_path);
} else {
bool a_events = false, a_jobs = false, a_resv = false;
bool a_steps = false, a_suspend = false, a_txn = false;
bool a_usage = false;
debug("Reading slurmdbd.conf file %s", conf_path);
tbl = s_p_hashtbl_create(options);
if (s_p_parse_file(tbl, NULL, conf_path, false)
== SLURM_ERROR) {
fatal("Could not open/read/parse slurmdbd.conf file %s",
conf_path);
}
if (!s_p_get_string(&slurmdbd_conf->archive_dir, "ArchiveDir",
tbl))
slurmdbd_conf->archive_dir =
xstrdup(DEFAULT_SLURMDBD_ARCHIVE_DIR);
s_p_get_boolean(&a_events, "ArchiveEvents", tbl);
s_p_get_boolean(&a_jobs, "ArchiveJobs", tbl);
s_p_get_boolean(&a_resv, "ArchiveResvs", tbl);
s_p_get_string(&slurmdbd_conf->archive_script, "ArchiveScript",
tbl);
s_p_get_boolean(&a_steps, "ArchiveSteps", tbl);
s_p_get_boolean(&a_suspend, "ArchiveSuspend", tbl);
s_p_get_boolean(&a_txn, "ArchiveTXN", tbl);
s_p_get_boolean(&a_usage, "ArchiveUsage", tbl);
s_p_get_string(&slurmdbd_conf->auth_info, "AuthInfo", tbl);
s_p_get_string(&slurmdbd_conf->auth_type, "AuthType", tbl);
s_p_get_uint16(&slurmdbd_conf->commit_delay,
"CommitDelay", tbl);
s_p_get_string(&slurmdbd_conf->dbd_backup,
"DbdBackupHost", tbl);
s_p_get_string(&slurmdbd_conf->dbd_host, "DbdHost", tbl);
s_p_get_string(&slurmdbd_conf->dbd_addr, "DbdAddr", tbl);
s_p_get_uint16(&slurmdbd_conf->dbd_port, "DbdPort", tbl);
if (s_p_get_string(&temp_str, "DebugFlags", tbl)) {
if (debug_str2flags(temp_str,
&slurmdbd_conf->debug_flags)
!= SLURM_SUCCESS)
fatal("DebugFlags invalid: %s", temp_str);
xfree(temp_str);
} else /* Default: no DebugFlags */
slurmdbd_conf->debug_flags = 0;
if (s_p_get_string(&temp_str, "DebugLevel", tbl)) {
slurmdbd_conf->debug_level = log_string2num(temp_str);
if (slurmdbd_conf->debug_level == NO_VAL16)
fatal("Invalid DebugLevel %s", temp_str);
xfree(temp_str);
}
s_p_get_string(&slurmdbd_conf->default_qos, "DefaultQOS", tbl);
if (s_p_get_uint32(&slurmdbd_conf->purge_job,
"JobPurge", tbl)) {
if (!slurmdbd_conf->purge_job)
slurmdbd_conf->purge_job = NO_VAL;
else
slurmdbd_conf->purge_job |=
SLURMDB_PURGE_MONTHS;
}
s_p_get_string(&slurmdbd_conf->log_file, "LogFile", tbl);
if (s_p_get_string(&temp_str, "DebugLevelSyslog", tbl)) {
slurmdbd_conf->syslog_debug = log_string2num(temp_str);
if (slurmdbd_conf->syslog_debug == NO_VAL16)
fatal("Invalid DebugLevelSyslog %s", temp_str);
xfree(temp_str);
}
if (s_p_get_string(&temp_str, "LogTimeFormat", tbl)) {
if (xstrcasestr(temp_str, "iso8601_ms"))
slurmdbd_conf->log_fmt = LOG_FMT_ISO8601_MS;
else if (xstrcasestr(temp_str, "iso8601"))
slurmdbd_conf->log_fmt = LOG_FMT_ISO8601;
else if (xstrcasestr(temp_str, "rfc5424_ms"))
slurmdbd_conf->log_fmt = LOG_FMT_RFC5424_MS;
else if (xstrcasestr(temp_str, "rfc5424"))
slurmdbd_conf->log_fmt = LOG_FMT_RFC5424;
else if (xstrcasestr(temp_str, "clock"))
slurmdbd_conf->log_fmt = LOG_FMT_CLOCK;
else if (xstrcasestr(temp_str, "short"))
slurmdbd_conf->log_fmt = LOG_FMT_SHORT;
else if (xstrcasestr(temp_str, "thread_id"))
slurmdbd_conf->log_fmt = LOG_FMT_THREAD_ID;
xfree(temp_str);
} else
slurmdbd_conf->log_fmt = LOG_FMT_ISO8601_MS;
if (s_p_get_string(&temp_str, "MaxQueryTimeRange", tbl)) {
slurmdbd_conf->max_time_range = time_str2secs(temp_str);
xfree(temp_str);
} else {
slurmdbd_conf->max_time_range = INFINITE;
}
if (!s_p_get_uint16(&slurmdbd_conf->msg_timeout,
"MessageTimeout", tbl))
slurmdbd_conf->msg_timeout = DEFAULT_MSG_TIMEOUT;
else if (slurmdbd_conf->msg_timeout > 100) {
info("WARNING: MessageTimeout is too high for "
"effective fault-tolerance");
}
s_p_get_string(&slurmdbd_conf->pid_file, "PidFile", tbl);
s_p_get_string(&slurmdbd_conf->plugindir, "PluginDir", tbl);
slurmdbd_conf->private_data = 0; /* default visible to all */
if (s_p_get_string(&temp_str, "PrivateData", tbl)) {
if (xstrcasestr(temp_str, "account"))
slurmdbd_conf->private_data
|= PRIVATE_DATA_ACCOUNTS;
if (xstrcasestr(temp_str, "job"))
slurmdbd_conf->private_data
|= PRIVATE_DATA_JOBS;
if (xstrcasestr(temp_str, "event"))
slurmdbd_conf->private_data
|= PRIVATE_DATA_EVENTS;
if (xstrcasestr(temp_str, "node"))
slurmdbd_conf->private_data
|= PRIVATE_DATA_NODES;
if (xstrcasestr(temp_str, "partition"))
slurmdbd_conf->private_data
|= PRIVATE_DATA_PARTITIONS;
if (xstrcasestr(temp_str, "reservation"))
slurmdbd_conf->private_data
|= PRIVATE_DATA_RESERVATIONS;
if (xstrcasestr(temp_str, "usage"))
slurmdbd_conf->private_data
|= PRIVATE_DATA_USAGE;
if (xstrcasestr(temp_str, "user"))
slurmdbd_conf->private_data
|= PRIVATE_DATA_USERS;
if (xstrcasestr(temp_str, "all"))
slurmdbd_conf->private_data = 0xffff;
xfree(temp_str);
}
if (s_p_get_string(&temp_str, "PurgeEventAfter", tbl)) {
/* slurmdb_parse_purge will set SLURMDB_PURGE_FLAGS */
if ((slurmdbd_conf->purge_event =
slurmdb_parse_purge(temp_str)) == NO_VAL) {
fatal("Bad value \"%s\" for PurgeEventAfter",
temp_str);
}
xfree(temp_str);
}
if (s_p_get_string(&temp_str, "PurgeJobAfter", tbl)) {
/* slurmdb_parse_purge will set SLURMDB_PURGE_FLAGS */
if ((slurmdbd_conf->purge_job =
slurmdb_parse_purge(temp_str)) == NO_VAL) {
fatal("Bad value \"%s\" for PurgeJobAfter",
temp_str);
}
xfree(temp_str);
}
if (s_p_get_string(&temp_str, "PurgeResvAfter", tbl)) {
/* slurmdb_parse_purge will set SLURMDB_PURGE_FLAGS */
if ((slurmdbd_conf->purge_resv =
slurmdb_parse_purge(temp_str)) == NO_VAL) {
fatal("Bad value \"%s\" for PurgeResvAfter",
temp_str);
}
xfree(temp_str);
}
if (s_p_get_string(&temp_str, "PurgeStepAfter", tbl)) {
/* slurmdb_parse_purge will set SLURMDB_PURGE_FLAGS */
if ((slurmdbd_conf->purge_step =
slurmdb_parse_purge(temp_str)) == NO_VAL) {
fatal("Bad value \"%s\" for PurgeStepAfter",
temp_str);
}
xfree(temp_str);
}
if (s_p_get_string(&temp_str, "PurgeSuspendAfter", tbl)) {
/* slurmdb_parse_purge will set SLURMDB_PURGE_FLAGS */
if ((slurmdbd_conf->purge_suspend =
slurmdb_parse_purge(temp_str)) == NO_VAL) {
fatal("Bad value \"%s\" for PurgeSuspendAfter",
temp_str);
}
xfree(temp_str);
}
if (s_p_get_string(&temp_str, "PurgeTXNAfter", tbl)) {
/* slurmdb_parse_purge will set SLURMDB_PURGE_FLAGS */
if ((slurmdbd_conf->purge_txn =
slurmdb_parse_purge(temp_str)) == NO_VAL) {
fatal("Bad value \"%s\" for PurgeTXNAfter",
temp_str);
}
xfree(temp_str);
}
if (s_p_get_string(&temp_str, "PurgeUsageAfter", tbl)) {
/* slurmdb_parse_purge will set SLURMDB_PURGE_FLAGS */
if ((slurmdbd_conf->purge_usage =
slurmdb_parse_purge(temp_str)) == NO_VAL) {
fatal("Bad value \"%s\" for PurgeUsageAfter",
temp_str);
}
xfree(temp_str);
}
if (s_p_get_uint32(&slurmdbd_conf->purge_event,
"PurgeEventMonths", tbl)) {
if (!slurmdbd_conf->purge_event)
slurmdbd_conf->purge_event = NO_VAL;
else
slurmdbd_conf->purge_event |=
SLURMDB_PURGE_MONTHS;
}
if (s_p_get_uint32(&slurmdbd_conf->purge_job,
"PurgeJobMonths", tbl)) {
if (!slurmdbd_conf->purge_job)
slurmdbd_conf->purge_job = NO_VAL;
else
slurmdbd_conf->purge_job |=
SLURMDB_PURGE_MONTHS;
}
if (s_p_get_uint32(&slurmdbd_conf->purge_step,
"PurgeStepMonths", tbl)) {
if (!slurmdbd_conf->purge_step)
slurmdbd_conf->purge_step = NO_VAL;
else
slurmdbd_conf->purge_step |=
SLURMDB_PURGE_MONTHS;
}
if (s_p_get_uint32(&slurmdbd_conf->purge_suspend,
"PurgeSuspendMonths", tbl)) {
if (!slurmdbd_conf->purge_suspend)
slurmdbd_conf->purge_suspend = NO_VAL;
else
slurmdbd_conf->purge_suspend
|= SLURMDB_PURGE_MONTHS;
}
if (s_p_get_uint32(&slurmdbd_conf->purge_txn,
"PurgeTXNMonths", tbl)) {
if (!slurmdbd_conf->purge_txn)
slurmdbd_conf->purge_txn = NO_VAL;
else
slurmdbd_conf->purge_txn
|= SLURMDB_PURGE_MONTHS;
}
if (s_p_get_uint32(&slurmdbd_conf->purge_usage,
"PurgeUsageMonths", tbl)) {
if (!slurmdbd_conf->purge_usage)
slurmdbd_conf->purge_usage = NO_VAL;
else
slurmdbd_conf->purge_usage
|= SLURMDB_PURGE_MONTHS;
}
s_p_get_string(&slurmdbd_conf->slurm_user_name,
"SlurmUser", tbl);
if (s_p_get_uint32(&slurmdbd_conf->purge_step,
"StepPurge", tbl)) {
if (!slurmdbd_conf->purge_step)
slurmdbd_conf->purge_step = NO_VAL;
else
slurmdbd_conf->purge_step |=
SLURMDB_PURGE_MONTHS;
}
s_p_get_string(&slurmdbd_conf->storage_backup_host,
"StorageBackupHost", tbl);
s_p_get_string(&slurmdbd_conf->storage_host,
"StorageHost", tbl);
s_p_get_string(&slurmdbd_conf->storage_loc,
"StorageLoc", tbl);
s_p_get_string(&slurmdbd_conf->storage_pass,
"StoragePass", tbl);
s_p_get_uint16(&slurmdbd_conf->storage_port,
"StoragePort", tbl);
s_p_get_string(&slurmdbd_conf->storage_type,
"StorageType", tbl);
s_p_get_string(&slurmdbd_conf->storage_user,
"StorageUser", tbl);
if (!s_p_get_uint16(&slurmdbd_conf->tcp_timeout,
"TCPTimeout", tbl))
slurmdbd_conf->tcp_timeout = DEFAULT_TCP_TIMEOUT;
if (!s_p_get_boolean((bool *)&slurmdbd_conf->track_wckey,
"TrackWCKey", tbl))
slurmdbd_conf->track_wckey = false;
if (!s_p_get_boolean((bool *)&slurmdbd_conf->track_ctld,
"TrackSlurmctldDown", tbl))
slurmdbd_conf->track_ctld = false;
if (a_events && slurmdbd_conf->purge_event)
slurmdbd_conf->purge_event |= SLURMDB_PURGE_ARCHIVE;
if (a_jobs && slurmdbd_conf->purge_job)
slurmdbd_conf->purge_job |= SLURMDB_PURGE_ARCHIVE;
if (a_resv && slurmdbd_conf->purge_resv)
slurmdbd_conf->purge_resv |= SLURMDB_PURGE_ARCHIVE;
if (a_steps && slurmdbd_conf->purge_step)
slurmdbd_conf->purge_step |= SLURMDB_PURGE_ARCHIVE;
if (a_suspend && slurmdbd_conf->purge_suspend)
slurmdbd_conf->purge_suspend |= SLURMDB_PURGE_ARCHIVE;
if (a_txn && slurmdbd_conf->purge_txn)
slurmdbd_conf->purge_txn |= SLURMDB_PURGE_ARCHIVE;
if (a_usage && slurmdbd_conf->purge_usage)
slurmdbd_conf->purge_usage |= SLURMDB_PURGE_ARCHIVE;
s_p_hashtbl_destroy(tbl);
}
xfree(conf_path);
if (slurmdbd_conf->auth_type == NULL)
slurmdbd_conf->auth_type = xstrdup(DEFAULT_SLURMDBD_AUTHTYPE);
if (slurmdbd_conf->dbd_host == NULL) {
error("slurmdbd.conf lacks DbdHost parameter, "
"using 'localhost'");
slurmdbd_conf->dbd_host = xstrdup("localhost");
}
if (slurmdbd_conf->dbd_addr == NULL)
slurmdbd_conf->dbd_addr = xstrdup(slurmdbd_conf->dbd_host);
if (slurmdbd_conf->pid_file == NULL)
slurmdbd_conf->pid_file = xstrdup(DEFAULT_SLURMDBD_PIDFILE);
if (slurmdbd_conf->dbd_port == 0)
slurmdbd_conf->dbd_port = SLURMDBD_PORT;
if (slurmdbd_conf->plugindir == NULL)
slurmdbd_conf->plugindir = xstrdup(default_plugin_path);
if (slurmdbd_conf->slurm_user_name) {
uid_t pw_uid;
if (uid_from_string (slurmdbd_conf->slurm_user_name,
&pw_uid) < 0)
fatal("Invalid user for SlurmUser %s, ignored",
slurmdbd_conf->slurm_user_name);
else
slurmdbd_conf->slurm_user_id = pw_uid;
} else {
slurmdbd_conf->slurm_user_name = xstrdup("root");
slurmdbd_conf->slurm_user_id = 0;
}
if (slurmdbd_conf->storage_type == NULL)
fatal("StorageType must be specified");
if (!xstrcmp(slurmdbd_conf->storage_type,
"accounting_storage/slurmdbd")) {
fatal("StorageType=%s is invalid in slurmdbd.conf",
slurmdbd_conf->storage_type);
}
if (!slurmdbd_conf->storage_host)
slurmdbd_conf->storage_host = xstrdup(DEFAULT_STORAGE_HOST);
if (!slurmdbd_conf->storage_user)
slurmdbd_conf->storage_user = xstrdup(getlogin());
if (!xstrcmp(slurmdbd_conf->storage_type,
"accounting_storage/mysql")) {
if (!slurmdbd_conf->storage_port)
slurmdbd_conf->storage_port = DEFAULT_MYSQL_PORT;
if (!slurmdbd_conf->storage_loc)
slurmdbd_conf->storage_loc =
xstrdup(DEFAULT_ACCOUNTING_DB);
} else {
if (!slurmdbd_conf->storage_port)
slurmdbd_conf->storage_port = DEFAULT_STORAGE_PORT;
if (!slurmdbd_conf->storage_loc)
slurmdbd_conf->storage_loc =
xstrdup(DEFAULT_STORAGE_LOC);
}
if (slurmdbd_conf->archive_dir) {
if (stat(slurmdbd_conf->archive_dir, &buf) < 0)
fatal("Failed to stat the archive directory %s: %m",
slurmdbd_conf->archive_dir);
if (!(buf.st_mode & S_IFDIR))
fatal("archive directory %s isn't a directory",
slurmdbd_conf->archive_dir);
if (access(slurmdbd_conf->archive_dir, W_OK) < 0)
fatal("archive directory %s is not writable",
slurmdbd_conf->archive_dir);
}
if (slurmdbd_conf->archive_script) {
if (stat(slurmdbd_conf->archive_script, &buf) < 0)
fatal("Failed to stat the archive script %s: %m",
slurmdbd_conf->archive_dir);
if (!(buf.st_mode & S_IFREG))
fatal("archive script %s isn't a regular file",
slurmdbd_conf->archive_script);
if (access(slurmdbd_conf->archive_script, X_OK) < 0)
fatal("archive script %s is not executable",
slurmdbd_conf->archive_script);
}
if (!slurmdbd_conf->purge_event)
slurmdbd_conf->purge_event = NO_VAL;
if (!slurmdbd_conf->purge_job)
slurmdbd_conf->purge_job = NO_VAL;
if (!slurmdbd_conf->purge_resv)
slurmdbd_conf->purge_resv = NO_VAL;
if (!slurmdbd_conf->purge_step)
slurmdbd_conf->purge_step = NO_VAL;
if (!slurmdbd_conf->purge_suspend)
slurmdbd_conf->purge_suspend = NO_VAL;
if (!slurmdbd_conf->purge_txn)
slurmdbd_conf->purge_txn = NO_VAL;
if (!slurmdbd_conf->purge_usage)
slurmdbd_conf->purge_usage = NO_VAL;
slurm_mutex_unlock(&conf_mutex);
return SLURM_SUCCESS;
}
extern void acct_gather_energy_p_conf_set(s_p_hashtbl_t *tbl)
{
char *tmp_char;
/* Set initial values */
reset_slurm_ipmi_conf(&slurm_ipmi_conf);
if (tbl) {
/* ipmi initialisation parameters */
s_p_get_uint32(&slurm_ipmi_conf.driver_type,
"EnergyIPMIDriverType", tbl);
s_p_get_uint32(&slurm_ipmi_conf.disable_auto_probe,
"EnergyIPMIDisableAutoProbe", tbl);
s_p_get_uint32(&slurm_ipmi_conf.driver_address,
"EnergyIPMIDriverAddress", tbl);
s_p_get_uint32(&slurm_ipmi_conf.register_spacing,
"EnergyIPMIRegisterSpacing", tbl);
s_p_get_string(&slurm_ipmi_conf.driver_device,
"EnergyIPMIDriverDevice", tbl);
s_p_get_uint32(&slurm_ipmi_conf.protocol_version,
"EnergyIPMIProtocolVersion", tbl);
if (!s_p_get_string(&slurm_ipmi_conf.username,
"EnergyIPMIUsername", tbl))
slurm_ipmi_conf.username = xstrdup(DEFAULT_IPMI_USER);
s_p_get_string(&slurm_ipmi_conf.password,
"EnergyIPMIPassword", tbl);
if (!slurm_ipmi_conf.password)
slurm_ipmi_conf.password = xstrdup("foopassword");
s_p_get_uint32(&slurm_ipmi_conf.privilege_level,
"EnergyIPMIPrivilegeLevel", tbl);
s_p_get_uint32(&slurm_ipmi_conf.authentication_type,
"EnergyIPMIAuthenticationType", tbl);
s_p_get_uint32(&slurm_ipmi_conf.cipher_suite_id,
"EnergyIPMICipherSuiteId", tbl);
s_p_get_uint32(&slurm_ipmi_conf.session_timeout,
"EnergyIPMISessionTimeout", tbl);
s_p_get_uint32(&slurm_ipmi_conf.retransmission_timeout,
"EnergyIPMIRetransmissionTimeout", tbl);
s_p_get_uint32(&slurm_ipmi_conf. workaround_flags,
"EnergyIPMIWorkaroundFlags", tbl);
if (!s_p_get_boolean(&slurm_ipmi_conf.reread_sdr_cache,
"EnergyIPMIRereadSdrCache", tbl))
slurm_ipmi_conf.reread_sdr_cache = false;
if (!s_p_get_boolean(&slurm_ipmi_conf.
ignore_non_interpretable_sensors,
"EnergyIPMIIgnoreNonInterpretableSensors",
tbl))
slurm_ipmi_conf.ignore_non_interpretable_sensors =
false;
if (!s_p_get_boolean(&slurm_ipmi_conf.bridge_sensors,
"EnergyIPMIBridgeSensors", tbl))
slurm_ipmi_conf.bridge_sensors = false;
if (!s_p_get_boolean(&slurm_ipmi_conf.interpret_oem_data,
"EnergyIPMIInterpretOemData", tbl))
slurm_ipmi_conf.interpret_oem_data = false;
if (!s_p_get_boolean(&slurm_ipmi_conf.shared_sensors,
"EnergyIPMISharedSensors", tbl))
slurm_ipmi_conf.shared_sensors = false;
if (!s_p_get_boolean(&slurm_ipmi_conf.discrete_reading,
"EnergyIPMIDiscreteReading", tbl))
slurm_ipmi_conf.discrete_reading = false;
if (!s_p_get_boolean(&slurm_ipmi_conf.ignore_scanning_disabled,
"EnergyIPMIIgnoreScanningDisabled", tbl))
slurm_ipmi_conf.ignore_scanning_disabled = false;
if (!s_p_get_boolean(&slurm_ipmi_conf.assume_bmc_owner,
"EnergyIPMIAssumeBmcOwner", tbl))
slurm_ipmi_conf.assume_bmc_owner = false;
if (!s_p_get_boolean(&slurm_ipmi_conf.entity_sensor_names,
"EnergyIPMIEntitySensorNames", tbl))
slurm_ipmi_conf.entity_sensor_names = false;
s_p_get_uint32(&slurm_ipmi_conf.freq,
"EnergyIPMIFrequency", tbl);
if ((int)slurm_ipmi_conf.freq <= 0)
fatal("EnergyIPMIFrequency must be a positive integer "
"in acct_gather.conf.");
if (!s_p_get_boolean(&(slurm_ipmi_conf.adjustment),
"EnergyIPMICalcAdjustment", tbl))
slurm_ipmi_conf.adjustment = false;
s_p_get_uint32(&slurm_ipmi_conf.power_sensor_num,
"EnergyIPMIPowerSensor", tbl);
s_p_get_uint32(&slurm_ipmi_conf.timeout,
"EnergyIPMITimeout", tbl);
if (s_p_get_string(&tmp_char, "EnergyIPMIVariable", tbl)) {
if (!strcmp(tmp_char, "Temp"))
slurm_ipmi_conf.variable =
IPMI_MONITORING_SENSOR_TYPE_TEMPERATURE;
xfree(tmp_char);
}
}
if (!_run_in_daemon())
return;
if (!flag_init) {
local_energy = acct_gather_energy_alloc();
local_energy->consumed_energy=0;
local_energy->base_consumed_energy=0;
local_energy->base_watts=0;
flag_init = true;
if (_is_thread_launcher()) {
pthread_attr_t attr;
slurm_attr_init(&attr);
if (pthread_create(&thread_ipmi_id_launcher, &attr,
&_thread_launcher, NULL)) {
//if (pthread_create(... (void *)arg)) {
debug("energy accounting failed to create "
"_thread_launcher thread: %m");
}
slurm_attr_destroy(&attr);
if (debug_flags & DEBUG_FLAG_ENERGY)
info("%s thread launched", plugin_name);
} else
_get_joules_task(0);
}
verbose("%s loaded", plugin_name);
}
/*
* Read and process the bluegene.conf configuration file so to interpret what
* blocks are static/dynamic, torus/mesh, etc.
*/
extern int read_bg_conf(void)
{
int i;
bool tmp_bool = 0;
int count = 0;
s_p_hashtbl_t *tbl = NULL;
char *tmp_char = NULL;
select_ba_request_t **blockreq_array = NULL;
image_t **image_array = NULL;
image_t *image = NULL;
static time_t last_config_update = (time_t) 0;
struct stat config_stat;
ListIterator itr = NULL;
char* bg_conf_file = NULL;
static int *dims = NULL;
if (!dims)
dims = select_g_ba_get_dims();
if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE)
info("Reading the bluegene.conf file");
/* check if config file has changed */
bg_conf_file = get_extra_conf_path("bluegene.conf");
if (stat(bg_conf_file, &config_stat) < 0)
fatal("can't stat bluegene.conf file %s: %m", bg_conf_file);
if (last_config_update) {
_reopen_bridge_log();
if (last_config_update == config_stat.st_mtime) {
if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE)
info("%s unchanged", bg_conf_file);
} else {
info("Restart slurmctld for %s changes "
"to take effect",
bg_conf_file);
}
last_config_update = config_stat.st_mtime;
xfree(bg_conf_file);
return SLURM_SUCCESS;
}
last_config_update = config_stat.st_mtime;
/* initialization */
/* bg_conf defined in bg_node_alloc.h */
if (!(tbl = config_make_tbl(bg_conf_file)))
fatal("something wrong with opening/reading bluegene "
"conf file");
xfree(bg_conf_file);
#ifdef HAVE_BGL
if (s_p_get_array((void ***)&image_array,
&count, "AltBlrtsImage", tbl)) {
for (i = 0; i < count; i++) {
list_append(bg_conf->blrts_list, image_array[i]);
image_array[i] = NULL;
}
}
if (!s_p_get_string(&bg_conf->default_blrtsimage, "BlrtsImage", tbl)) {
if (!list_count(bg_conf->blrts_list))
fatal("BlrtsImage not configured "
"in bluegene.conf");
itr = list_iterator_create(bg_conf->blrts_list);
image = list_next(itr);
image->def = true;
list_iterator_destroy(itr);
bg_conf->default_blrtsimage = xstrdup(image->name);
info("Warning: using %s as the default BlrtsImage. "
"If this isn't correct please set BlrtsImage",
bg_conf->default_blrtsimage);
} else {
if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE)
info("default BlrtsImage %s",
bg_conf->default_blrtsimage);
image = xmalloc(sizeof(image_t));
image->name = xstrdup(bg_conf->default_blrtsimage);
image->def = true;
image->groups = NULL;
/* we want it to be first */
list_push(bg_conf->blrts_list, image);
}
if (s_p_get_array((void ***)&image_array,
&count, "AltLinuxImage", tbl)) {
for (i = 0; i < count; i++) {
list_append(bg_conf->linux_list, image_array[i]);
image_array[i] = NULL;
}
}
if (!s_p_get_string(&bg_conf->default_linuximage, "LinuxImage", tbl)) {
if (!list_count(bg_conf->linux_list))
fatal("LinuxImage not configured "
"in bluegene.conf");
itr = list_iterator_create(bg_conf->linux_list);
image = list_next(itr);
image->def = true;
list_iterator_destroy(itr);
bg_conf->default_linuximage = xstrdup(image->name);
info("Warning: using %s as the default LinuxImage. "
"If this isn't correct please set LinuxImage",
bg_conf->default_linuximage);
} else {
if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE)
info("default LinuxImage %s",
bg_conf->default_linuximage);
image = xmalloc(sizeof(image_t));
image->name = xstrdup(bg_conf->default_linuximage);
image->def = true;
image->groups = NULL;
/* we want it to be first */
list_push(bg_conf->linux_list, image);
}
if (s_p_get_array((void ***)&image_array,
&count, "AltRamDiskImage", tbl)) {
for (i = 0; i < count; i++) {
list_append(bg_conf->ramdisk_list, image_array[i]);
image_array[i] = NULL;
}
}
if (!s_p_get_string(&bg_conf->default_ramdiskimage,
"RamDiskImage", tbl)) {
if (!list_count(bg_conf->ramdisk_list))
fatal("RamDiskImage not configured "
"in bluegene.conf");
itr = list_iterator_create(bg_conf->ramdisk_list);
image = list_next(itr);
image->def = true;
list_iterator_destroy(itr);
bg_conf->default_ramdiskimage = xstrdup(image->name);
info("Warning: using %s as the default RamDiskImage. "
"If this isn't correct please set RamDiskImage",
bg_conf->default_ramdiskimage);
} else {
if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE)
info("default RamDiskImage %s",
bg_conf->default_ramdiskimage);
image = xmalloc(sizeof(image_t));
image->name = xstrdup(bg_conf->default_ramdiskimage);
image->def = true;
image->groups = NULL;
/* we want it to be first */
list_push(bg_conf->ramdisk_list, image);
}
#elif defined HAVE_BGP
if (s_p_get_array((void ***)&image_array,
&count, "AltCnloadImage", tbl)) {
for (i = 0; i < count; i++) {
list_append(bg_conf->linux_list, image_array[i]);
image_array[i] = NULL;
}
}
if (!s_p_get_string(&bg_conf->default_linuximage, "CnloadImage", tbl)) {
if (!list_count(bg_conf->linux_list))
fatal("CnloadImage not configured "
"in bluegene.conf");
itr = list_iterator_create(bg_conf->linux_list);
image = list_next(itr);
image->def = true;
list_iterator_destroy(itr);
bg_conf->default_linuximage = xstrdup(image->name);
info("Warning: using %s as the default CnloadImage. "
"If this isn't correct please set CnloadImage",
bg_conf->default_linuximage);
} else {
if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE)
info("default CnloadImage %s",
bg_conf->default_linuximage);
image = xmalloc(sizeof(image_t));
image->name = xstrdup(bg_conf->default_linuximage);
image->def = true;
image->groups = NULL;
/* we want it to be first */
list_push(bg_conf->linux_list, image);
}
if (s_p_get_array((void ***)&image_array,
&count, "AltIoloadImage", tbl)) {
for (i = 0; i < count; i++) {
list_append(bg_conf->ramdisk_list, image_array[i]);
image_array[i] = NULL;
}
}
if (!s_p_get_string(&bg_conf->default_ramdiskimage,
"IoloadImage", tbl)) {
if (!list_count(bg_conf->ramdisk_list))
fatal("IoloadImage not configured "
"in bluegene.conf");
itr = list_iterator_create(bg_conf->ramdisk_list);
image = list_next(itr);
image->def = true;
list_iterator_destroy(itr);
bg_conf->default_ramdiskimage = xstrdup(image->name);
info("Warning: using %s as the default IoloadImage. "
"If this isn't correct please set IoloadImage",
bg_conf->default_ramdiskimage);
} else {
if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE)
info("default IoloadImage %s",
bg_conf->default_ramdiskimage);
image = xmalloc(sizeof(image_t));
image->name = xstrdup(bg_conf->default_ramdiskimage);
image->def = true;
image->groups = NULL;
/* we want it to be first */
list_push(bg_conf->ramdisk_list, image);
}
#endif
if (s_p_get_array((void ***)&image_array,
&count, "AltMloaderImage", tbl)) {
for (i = 0; i < count; i++) {
list_append(bg_conf->mloader_list, image_array[i]);
image_array[i] = NULL;
}
}
if (!s_p_get_string(&bg_conf->default_mloaderimage,
"MloaderImage", tbl)) {
if (!list_count(bg_conf->mloader_list))
fatal("MloaderImage not configured "
"in bluegene.conf");
itr = list_iterator_create(bg_conf->mloader_list);
image = list_next(itr);
image->def = true;
list_iterator_destroy(itr);
bg_conf->default_mloaderimage = xstrdup(image->name);
info("Warning: using %s as the default MloaderImage. "
"If this isn't correct please set MloaderImage",
bg_conf->default_mloaderimage);
} else {
if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE)
info("default MloaderImage %s",
bg_conf->default_mloaderimage);
image = xmalloc(sizeof(image_t));
image->name = xstrdup(bg_conf->default_mloaderimage);
image->def = true;
image->groups = NULL;
/* we want it to be first */
list_push(bg_conf->mloader_list, image);
}
if (!s_p_get_uint16(&bg_conf->mp_cnode_cnt, "MidplaneNodeCnt", tbl)) {
if (!s_p_get_uint16(&bg_conf->mp_cnode_cnt,
"BasePartitionNodeCnt", tbl)) {
error("MidplaneNodeCnt not configured in bluegene.conf "
"defaulting to 512 as MidplaneNodeCnt");
bg_conf->mp_cnode_cnt = 512;
}
}
if (bg_conf->mp_cnode_cnt <= 0)
fatal("You should have more than 0 nodes "
"per midplane");
bg_conf->actual_cnodes_per_mp = bg_conf->mp_cnode_cnt;
bg_conf->quarter_cnode_cnt = bg_conf->mp_cnode_cnt/4;
/* bg_conf->cpus_per_mp should had already been set from the
* node_init */
if (bg_conf->cpus_per_mp < bg_conf->mp_cnode_cnt) {
fatal("For some reason we have only %u cpus per mp, but "
"have %u cnodes per mp. You need at least the same "
"number of cpus as you have cnodes per mp. "
"Check the NodeName CPUs= "
"definition in the slurm.conf.",
bg_conf->cpus_per_mp, bg_conf->mp_cnode_cnt);
}
bg_conf->cpu_ratio = bg_conf->cpus_per_mp/bg_conf->mp_cnode_cnt;
if (!bg_conf->cpu_ratio)
fatal("We appear to have less than 1 cpu on a cnode. "
"You specified %u for MidplaneNodeCnt "
"in the blugene.conf and %u cpus "
"for each node in the slurm.conf",
bg_conf->mp_cnode_cnt, bg_conf->cpus_per_mp);
num_unused_cpus = 1;
for (i = 0; i<SYSTEM_DIMENSIONS; i++)
num_unused_cpus *= dims[i];
num_unused_cpus *= bg_conf->cpus_per_mp;
num_possible_unused_cpus = num_unused_cpus;
if (!s_p_get_uint16(&bg_conf->nodecard_cnode_cnt,
"NodeBoardNodeCnt", tbl)) {
if (!s_p_get_uint16(&bg_conf->nodecard_cnode_cnt,
"NodeCardNodeCnt", tbl)) {
error("NodeCardNodeCnt not configured in bluegene.conf "
"defaulting to 32 as NodeCardNodeCnt");
bg_conf->nodecard_cnode_cnt = 32;
}
}
if (bg_conf->nodecard_cnode_cnt <= 0)
fatal("You should have more than 0 nodes per nodecard");
bg_conf->mp_nodecard_cnt =
bg_conf->mp_cnode_cnt / bg_conf->nodecard_cnode_cnt;
if (!s_p_get_uint16(&bg_conf->ionodes_per_mp, "IONodesPerMP", tbl))
if (!s_p_get_uint16(&bg_conf->ionodes_per_mp, "Numpsets", tbl))
fatal("Warning: IONodesPerMP not configured "
"in bluegene.conf");
s_p_get_uint16(&bg_conf->max_block_err, "MaxBlockInError", tbl);
tmp_bool = 0;
s_p_get_boolean(&tmp_bool, "SubMidplaneSystem", tbl);
bg_conf->sub_mp_sys = tmp_bool;
#ifdef HAVE_BGQ
tmp_bool = 0;
s_p_get_boolean(&tmp_bool, "AllowSubBlockAllocations", tbl);
bg_conf->sub_blocks = tmp_bool;
/* You can only have 16 ionodes per midplane */
if (bg_conf->ionodes_per_mp > bg_conf->mp_nodecard_cnt)
bg_conf->ionodes_per_mp = bg_conf->mp_nodecard_cnt;
#endif
for (i=0; i<SYSTEM_DIMENSIONS; i++)
bg_conf->default_conn_type[i] = (uint16_t)NO_VAL;
s_p_get_string(&tmp_char, "DefaultConnType", tbl);
if (tmp_char) {
verify_conn_type(tmp_char, bg_conf->default_conn_type);
if ((bg_conf->default_conn_type[0] != SELECT_MESH)
&& (bg_conf->default_conn_type[0] != SELECT_TORUS))
fatal("Can't have a DefaultConnType of %s "
"(only Mesh or Torus values are valid).",
tmp_char);
xfree(tmp_char);
} else
bg_conf->default_conn_type[0] = SELECT_TORUS;
#ifndef HAVE_BG_L_P
int first_conn_type = bg_conf->default_conn_type[0];
for (i=1; i<SYSTEM_DIMENSIONS; i++) {
if (bg_conf->default_conn_type[i] == (uint16_t)NO_VAL)
bg_conf->default_conn_type[i] = first_conn_type;
else if (bg_conf->default_conn_type[i] >= SELECT_SMALL)
fatal("Can't have a DefaultConnType of %s "
"(only Mesh or Torus values are valid).",
tmp_char);
}
#endif
if (bg_conf->ionodes_per_mp) {
bitstr_t *tmp_bitmap = NULL;
int small_size = 1;
/* THIS IS A HACK TO MAKE A 1 NODECARD SYSTEM WORK,
* Sometime on a Q system the nodecard isn't in the 0
* spot so only do this if you know it is in that
* spot. Otherwise say the whole midplane is there
* and just make blocks over the whole thing. They
* you can error out the blocks that aren't usable. */
if (bg_conf->sub_mp_sys
&& bg_conf->mp_cnode_cnt == bg_conf->nodecard_cnode_cnt) {
#ifdef HAVE_BGQ
bg_conf->quarter_ionode_cnt = 1;
bg_conf->nodecard_ionode_cnt = 1;
#else
bg_conf->quarter_ionode_cnt = 2;
bg_conf->nodecard_ionode_cnt = 2;
#endif
} else {
bg_conf->quarter_ionode_cnt = bg_conf->ionodes_per_mp/4;
bg_conf->nodecard_ionode_cnt =
bg_conf->quarter_ionode_cnt/4;
}
/* How many nodecards per ionode */
bg_conf->nc_ratio =
((double)bg_conf->mp_cnode_cnt
/ (double)bg_conf->nodecard_cnode_cnt)
/ (double)bg_conf->ionodes_per_mp;
/* How many ionodes per nodecard */
bg_conf->io_ratio =
(double)bg_conf->ionodes_per_mp /
((double)bg_conf->mp_cnode_cnt
/ (double)bg_conf->nodecard_cnode_cnt);
/* How many cnodes per ionode */
bg_conf->ionode_cnode_cnt =
bg_conf->nodecard_cnode_cnt * bg_conf->nc_ratio;
//info("got %f %f", bg_conf->nc_ratio, bg_conf->io_ratio);
/* figure out the smallest block we can have on the
system */
#ifdef HAVE_BGL
if (bg_conf->io_ratio >= 1)
bg_conf->smallest_block=32;
else
bg_conf->smallest_block=128;
#else
if (bg_conf->io_ratio >= 2)
bg_conf->smallest_block=16;
else if (bg_conf->io_ratio == 1)
bg_conf->smallest_block=32;
else if (bg_conf->io_ratio == .5)
bg_conf->smallest_block=64;
else if (bg_conf->io_ratio == .25)
bg_conf->smallest_block=128;
else if (bg_conf->io_ratio == .125)
bg_conf->smallest_block=256;
else {
error("unknown ioratio %f. Can't figure out "
"smallest block size, setting it to midplane",
bg_conf->io_ratio);
bg_conf->smallest_block = 512;
}
#endif
if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE)
info("Smallest block possible on this system is %u",
bg_conf->smallest_block);
/* below we are creating all the possible bitmaps for
* each size of small block
*/
if ((int)bg_conf->nodecard_ionode_cnt < 1) {
bg_conf->nodecard_ionode_cnt = 0;
} else {
bg_lists->valid_small32 = list_create(_destroy_bitmap);
/* This is suppose to be = and not ==, we only
want to decrement when small_size equals
something.
*/
if ((small_size = bg_conf->nodecard_ionode_cnt))
small_size--;
i = 0;
while (i<bg_conf->ionodes_per_mp) {
tmp_bitmap = bit_alloc(bg_conf->ionodes_per_mp);
bit_nset(tmp_bitmap, i, i+small_size);
i += small_size+1;
list_append(bg_lists->valid_small32,
tmp_bitmap);
}
}
/* If we only have 1 nodecard just jump to the end
since this will never need to happen below.
Pretty much a hack to avoid seg fault;). */
if (bg_conf->mp_cnode_cnt == bg_conf->nodecard_cnode_cnt)
goto no_calc;
bg_lists->valid_small128 = list_create(_destroy_bitmap);
if ((small_size = bg_conf->quarter_ionode_cnt))
small_size--;
i = 0;
while (i<bg_conf->ionodes_per_mp) {
tmp_bitmap = bit_alloc(bg_conf->ionodes_per_mp);
bit_nset(tmp_bitmap, i, i+small_size);
i += small_size+1;
list_append(bg_lists->valid_small128, tmp_bitmap);
}
#ifndef HAVE_BGL
bg_lists->valid_small64 = list_create(_destroy_bitmap);
if ((small_size = bg_conf->nodecard_ionode_cnt * 2))
small_size--;
i = 0;
while (i<bg_conf->ionodes_per_mp) {
tmp_bitmap = bit_alloc(bg_conf->ionodes_per_mp);
bit_nset(tmp_bitmap, i, i+small_size);
i += small_size+1;
list_append(bg_lists->valid_small64, tmp_bitmap);
}
bg_lists->valid_small256 = list_create(_destroy_bitmap);
if ((small_size = bg_conf->quarter_ionode_cnt * 2))
small_size--;
i = 0;
while (i<bg_conf->ionodes_per_mp) {
tmp_bitmap = bit_alloc(bg_conf->ionodes_per_mp);
bit_nset(tmp_bitmap, i, i+small_size);
i += small_size+1;
list_append(bg_lists->valid_small256, tmp_bitmap);
}
#endif
} else {
fatal("your ionodes_per_mp is 0");
}
no_calc:
if (!s_p_get_uint16(&bg_conf->bridge_api_verb, "BridgeAPIVerbose", tbl))
info("Warning: BridgeAPIVerbose not configured "
"in bluegene.conf");
if (!s_p_get_string(&bg_conf->bridge_api_file,
"BridgeAPILogFile", tbl))
info("BridgeAPILogFile not configured in bluegene.conf");
else
_reopen_bridge_log();
if (s_p_get_string(&tmp_char, "DenyPassthrough", tbl)) {
if (strstr(tmp_char, "A"))
ba_deny_pass |= PASS_DENY_A;
if (strstr(tmp_char, "X"))
ba_deny_pass |= PASS_DENY_X;
if (strstr(tmp_char, "Y"))
ba_deny_pass |= PASS_DENY_Y;
if (strstr(tmp_char, "Z"))
ba_deny_pass |= PASS_DENY_Z;
if (!xstrcasecmp(tmp_char, "ALL"))
ba_deny_pass |= PASS_DENY_ALL;
bg_conf->deny_pass = ba_deny_pass;
xfree(tmp_char);
}
if (!s_p_get_string(&tmp_char, "LayoutMode", tbl)) {
info("Warning: LayoutMode was not specified in bluegene.conf "
"defaulting to STATIC partitioning");
bg_conf->layout_mode = LAYOUT_STATIC;
} else {
if (!xstrcasecmp(tmp_char,"STATIC"))
bg_conf->layout_mode = LAYOUT_STATIC;
else if (!xstrcasecmp(tmp_char,"OVERLAP"))
bg_conf->layout_mode = LAYOUT_OVERLAP;
else if (!xstrcasecmp(tmp_char,"DYNAMIC"))
bg_conf->layout_mode = LAYOUT_DYNAMIC;
else {
fatal("I don't understand this LayoutMode = %s",
tmp_char);
}
xfree(tmp_char);
}
/* add blocks defined in file */
if (bg_conf->layout_mode != LAYOUT_DYNAMIC) {
if (!s_p_get_array((void ***)&blockreq_array,
&count, "MPs", tbl)) {
if (!s_p_get_array((void ***)&blockreq_array,
&count, "BPs", tbl)) {
info("WARNING: no blocks defined in "
"bluegene.conf, "
"only making full system block");
/* create_full_system_block(NULL); */
if (bg_conf->sub_mp_sys ||
(bg_conf->mp_cnode_cnt ==
bg_conf->nodecard_cnode_cnt))
fatal("On a sub-midplane system you "
"need to define the blocks you "
"want on your system.");
}
}
for (i = 0; i < count; i++) {
add_bg_record(bg_lists->main, NULL,
blockreq_array[i], 0, 0);
}
} else if (bg_conf->sub_mp_sys ||
(bg_conf->mp_cnode_cnt == bg_conf->nodecard_cnode_cnt))
/* we can't do dynamic here on a sub-midplane system */
fatal("On a sub-midplane system we can only do OVERLAP or "
"STATIC LayoutMode. Please update your bluegene.conf.");
#ifdef HAVE_BGQ
if ((bg_recover != NOT_FROM_CONTROLLER) && assoc_mgr_qos_list
&& s_p_get_string(&tmp_char, "RebootQOSList", tbl)) {
bool valid;
char *token, *last = NULL;
slurmdb_qos_rec_t *qos = NULL;
assoc_mgr_lock_t locks = { NO_LOCK, NO_LOCK, NO_LOCK,
READ_LOCK, NO_LOCK,
NO_LOCK, NO_LOCK };
/* Lock here to avoid g_qos_count changing under us */
assoc_mgr_lock(&locks);
bg_conf->reboot_qos_bitmap = bit_alloc(g_qos_count);
itr = list_iterator_create(assoc_mgr_qos_list);
token = strtok_r(tmp_char, ",", &last);
while (token) {
valid = false;
while((qos = list_next(itr))) {
if (!xstrcasecmp(token, qos->name)) {
bit_set(bg_conf->reboot_qos_bitmap,
qos->id);
valid = true;
break;
}
}
if (!valid)
error("Invalid RebootQOSList value: %s", token);
list_iterator_reset(itr);
token = strtok_r(NULL, ",", &last);
}
list_iterator_destroy(itr);
xfree(tmp_char);
assoc_mgr_unlock(&locks);
}
#endif
s_p_hashtbl_destroy(tbl);
return SLURM_SUCCESS;
}
/*
* read_slurm_cgroup_conf - load the Slurm cgroup configuration from the
* cgroup.conf file.
* RET SLURM_SUCCESS if no error, otherwise an error code
*/
extern int read_slurm_cgroup_conf(slurm_cgroup_conf_t *slurm_cgroup_conf)
{
s_p_options_t options[] = {
{"CgroupAutomount", S_P_BOOLEAN},
{"CgroupMountpoint", S_P_STRING},
{"CgroupSubsystems", S_P_STRING},
{"CgroupReleaseAgentDir", S_P_STRING},
{"ConstrainCores", S_P_BOOLEAN},
{"TaskAffinity", S_P_BOOLEAN},
{"ConstrainRAMSpace", S_P_BOOLEAN},
{"AllowedRAMSpace", S_P_STRING},
{"MaxRAMPercent", S_P_STRING},
{"MinRAMSpace", S_P_UINT32},
{"ConstrainSwapSpace", S_P_BOOLEAN},
{"AllowedSwapSpace", S_P_STRING},
{"MaxSwapPercent", S_P_STRING},
{"ConstrainCores", S_P_BOOLEAN},
{"MemoryLimitEnforcement", S_P_BOOLEAN},
{"MemoryLimitThreshold", S_P_STRING},
{"ConstrainDevices", S_P_BOOLEAN},
{"AllowedDevicesFile", S_P_STRING},
{NULL} };
s_p_hashtbl_t *tbl = NULL;
char *conf_path = NULL;
struct stat buf;
/* Set initial values */
if (slurm_cgroup_conf == NULL) {
return SLURM_ERROR;
}
_clear_slurm_cgroup_conf(slurm_cgroup_conf);
/* Get the cgroup.conf path and validate the file */
conf_path = get_extra_conf_path("cgroup.conf");
if ((conf_path == NULL) || (stat(conf_path, &buf) == -1)) {
debug2("%s: No cgroup.conf file (%s)", __func__, conf_path);
} else {
debug("Reading cgroup.conf file %s", conf_path);
tbl = s_p_hashtbl_create(options);
if (s_p_parse_file(tbl, NULL, conf_path, false) ==
SLURM_ERROR) {
fatal("Could not open/read/parse cgroup.conf file %s",
conf_path);
}
/* cgroup initialisation parameters */
if (!s_p_get_boolean(&slurm_cgroup_conf->cgroup_automount,
"CgroupAutomount", tbl))
slurm_cgroup_conf->cgroup_automount = false;
if (!s_p_get_string(&slurm_cgroup_conf->cgroup_mountpoint,
"CgroupMountpoint", tbl))
slurm_cgroup_conf->cgroup_mountpoint =
xstrdup(DEFAULT_CGROUP_BASEDIR);
s_p_get_string(&slurm_cgroup_conf->cgroup_subsystems,
"CgroupSubsystems", tbl);
s_p_get_string(&slurm_cgroup_conf->cgroup_release_agent,
"CgroupReleaseAgentDir", tbl);
if (! slurm_cgroup_conf->cgroup_release_agent)
slurm_cgroup_conf->cgroup_release_agent =
xstrdup("/etc/slurm/cgroup");
/* cgroup prepend directory */
#ifndef MULTIPLE_SLURMD
slurm_cgroup_conf->cgroup_prepend = xstrdup("/slurm");
#else
slurm_cgroup_conf->cgroup_prepend = xstrdup("/slurm_%n");
#endif
/* Cores constraints related conf items */
if (!s_p_get_boolean(&slurm_cgroup_conf->constrain_cores,
"ConstrainCores", tbl))
slurm_cgroup_conf->constrain_cores = false;
if (!s_p_get_boolean(&slurm_cgroup_conf->task_affinity,
"TaskAffinity", tbl))
slurm_cgroup_conf->task_affinity = false;
/* RAM and Swap constraints related conf items */
if (!s_p_get_boolean(&slurm_cgroup_conf->constrain_ram_space,
"ConstrainRAMSpace", tbl))
slurm_cgroup_conf->constrain_ram_space = false;
conf_get_float (tbl,
"AllowedRAMSpace",
&slurm_cgroup_conf->allowed_ram_space);
conf_get_float (tbl,
"MaxRAMPercent",
&slurm_cgroup_conf->max_ram_percent);
if (!s_p_get_boolean(&slurm_cgroup_conf->constrain_swap_space,
"ConstrainSwapSpace", tbl))
slurm_cgroup_conf->constrain_swap_space = false;
conf_get_float (tbl,
"AllowedSwapSpace",
&slurm_cgroup_conf->allowed_swap_space);
conf_get_float (tbl,
"MaxSwapPercent",
&slurm_cgroup_conf->max_swap_percent);
s_p_get_uint32 (&slurm_cgroup_conf->min_ram_space,
"MinRAMSpace", tbl);
/* Memory limits */
if (!s_p_get_boolean(&slurm_cgroup_conf->memlimit_enforcement,
"MemoryLimitEnforcement", tbl))
slurm_cgroup_conf->memlimit_enforcement = false;
conf_get_float (tbl,
"MemoryLimitThreshold",
&slurm_cgroup_conf->memlimit_threshold);
/* Devices constraint related conf items */
if (!s_p_get_boolean(&slurm_cgroup_conf->constrain_devices,
"ConstrainDevices", tbl))
slurm_cgroup_conf->constrain_devices = false;
s_p_get_string(&slurm_cgroup_conf->allowed_devices_file,
"AllowedDevicesFile", tbl);
if (! slurm_cgroup_conf->allowed_devices_file)
slurm_cgroup_conf->allowed_devices_file =
xstrdup("/etc/slurm/cgroup_allowed_devices_file.conf");
s_p_hashtbl_destroy(tbl);
}
xfree(conf_path);
return SLURM_SUCCESS;
}
extern int create_config(void)
{
int rc = SLURM_SUCCESS;
char* cray_conf_file = NULL;
static time_t last_config_update = (time_t) 0;
struct stat config_stat;
s_p_hashtbl_t *tbl = NULL;
if (cray_conf)
return SLURM_ERROR;
cray_conf = xmalloc(sizeof(cray_config_t));
cray_conf_file = get_extra_conf_path("cray.conf");
if (stat(cray_conf_file, &config_stat) < 0) {
cray_conf->apbasil = xstrdup(DEFAULT_APBASIL);
cray_conf->apbasil_timeout = DEFAULT_APBASIL_TIMEOUT;
cray_conf->apkill = xstrdup(DEFAULT_APKILL);
cray_conf->sdb_db = xstrdup(DEFAULT_CRAY_SDB_DB);
cray_conf->sdb_host = xstrdup(DEFAULT_CRAY_SDB_HOST);
cray_conf->sdb_pass = xstrdup(DEFAULT_CRAY_SDB_PASS);
cray_conf->sdb_port = DEFAULT_CRAY_SDB_PORT;
cray_conf->sdb_user = xstrdup(DEFAULT_CRAY_SDB_USER);
cray_conf->sync_timeout = DEFAULT_CRAY_SYNC_TIMEOUT;
xfree(cray_conf_file);
goto end_it;
}
if (cray_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE)
info("Reading the cray.conf file %s", cray_conf_file);
if (last_config_update) {
if (last_config_update == config_stat.st_mtime) {
if (cray_conf->slurm_debug_flags
& DEBUG_FLAG_SELECT_TYPE)
info("%s unchanged", cray_conf_file);
} else {
info("Restart slurmctld for %s changes "
"to take effect",
cray_conf_file);
}
last_config_update = config_stat.st_mtime;
xfree(cray_conf_file);
return SLURM_SUCCESS;
}
tbl = s_p_hashtbl_create(cray_conf_file_options);
if (s_p_parse_file(tbl, NULL, cray_conf_file, false) == SLURM_ERROR)
fatal("something wrong with opening/reading cray "
"conf file %s", cray_conf_file);
xfree(cray_conf_file);
if (!s_p_get_string(&cray_conf->apbasil, "apbasil", tbl))
cray_conf->apbasil = xstrdup(DEFAULT_APBASIL);
if (!s_p_get_uint16(&cray_conf->apbasil_timeout, "ApbasilTimeout", tbl))
cray_conf->apbasil_timeout = DEFAULT_APBASIL_TIMEOUT;
if (!s_p_get_string(&cray_conf->apkill, "apkill", tbl))
cray_conf->apkill = xstrdup(DEFAULT_APKILL);
s_p_get_string(&cray_conf->alps_engine, "AlpsEngine", tbl);
s_p_get_boolean(&cray_conf->no_apid_signal_on_kill,
"NoAPIDSignalOnKill", tbl);
if (!s_p_get_string(&cray_conf->sdb_db, "SDBdb", tbl))
cray_conf->sdb_db = xstrdup(DEFAULT_CRAY_SDB_DB);
if (!s_p_get_string(&cray_conf->sdb_host, "SDBhost", tbl))
cray_conf->sdb_host = xstrdup(DEFAULT_CRAY_SDB_HOST);
if (!s_p_get_string(&cray_conf->sdb_pass, "SDBpass", tbl))
cray_conf->sdb_pass = xstrdup(DEFAULT_CRAY_SDB_PASS);
if (!s_p_get_uint32(&cray_conf->sdb_port, "SDBport", tbl))
cray_conf->sdb_port = DEFAULT_CRAY_SDB_PORT;
if (!s_p_get_string(&cray_conf->sdb_user, "SDBuser", tbl))
cray_conf->sdb_user = xstrdup(DEFAULT_CRAY_SDB_USER);
s_p_get_boolean(&cray_conf->sub_alloc, "SubAllocate", tbl);
if (!s_p_get_uint32(&cray_conf->sync_timeout, "SyncTimeout", tbl))
cray_conf->sync_timeout = DEFAULT_CRAY_SYNC_TIMEOUT;
s_p_hashtbl_destroy(tbl);
end_it:
cray_conf->slurm_debug_flags = slurmctld_conf.debug_flags;
#if 0
info("Cray conf is...");
info("\tapbasil=\t%s", cray_conf->apbasil);
info("\ApbasilTimeout=\t%s", cray_conf->apbasil);
info("\tapkill=\t\t%s", cray_conf->apkill);
info("\tAlpsEngine=\t\t%u", cray_conf->apbasil_timeout);
info("\tSDBdb=\t\t%s", cray_conf->sdb_db);
info("\tSDBhost=\t%s", cray_conf->sdb_host);
info("\tSDBpass=\t%s", cray_conf->sdb_pass);
info("\tSDBport=\t%u", cray_conf->sdb_port);
info("\tSDBuser=\t%s", cray_conf->sdb_user);
info("\tSubAllocate=\t%u", cray_conf->sub_alloc);
info("\tSyncTimeout=\t%u", cray_conf->sync_timeout);
#endif
return rc;
}
extern int load_defaults(void)
{
s_p_hashtbl_t *hashtbl = NULL;
s_p_options_t sview_conf_options[] = {
{"AdminMode", S_P_BOOLEAN},
{"ButtonSize", S_P_UINT16},
{"DefaultPage", S_P_STRING},
{"ExcludedPartitions", S_P_STRING}, /* Vestigial */
{"FullInfoPopupWidth", S_P_UINT32},
{"FullInfoPopupHeight", S_P_UINT32},
{"GridHorizontal", S_P_UINT32},
{"GridSpeedUp", S_P_BOOLEAN},
{"GridTopo", S_P_BOOLEAN},
{"GridVertical", S_P_UINT32},
{"GridXWidth", S_P_UINT32},
{"MainHeight", S_P_UINT32},
{"MainWidth", S_P_UINT32},
{"PageOptsBlock", S_P_STRING},
{"PageOptsJob", S_P_STRING},
{"PageOptsNode", S_P_STRING},
{"PageOptsPartition", S_P_STRING},
{"PageOptsReservation", S_P_STRING},
{"PageOptsFrontend", S_P_STRING},
{"PageOptsBurstBuffer", S_P_STRING},
{"RefreshDelay", S_P_UINT16},
{"RuledTables", S_P_BOOLEAN},
{"SavePageSettings", S_P_BOOLEAN},
{"ShowGrid", S_P_BOOLEAN},
{"ShowHidden", S_P_BOOLEAN},
{"TabPosition", S_P_STRING},
{"VisiblePages", S_P_STRING},
{NULL}
};
char *pathname = NULL;
char *home = getenv("HOME");
uint32_t hash_val = NO_VAL;
int i, rc = SLURM_SUCCESS;
char *tmp_str;
_init_sview_conf();
if (!home)
goto end_it;
pathname = xstrdup_printf("%s/.slurm", home);
if ((mkdir(pathname, 0750) < 0) && (errno != EEXIST)) {
error("mkdir(%s): %m", pathname);
rc = SLURM_ERROR;
goto end_it;
}
xstrcat(pathname, "/sviewrc");
if (access(pathname, R_OK) != 0) {
rc = SLURM_ERROR;
goto end_it;
}
hashtbl = s_p_hashtbl_create(sview_conf_options);
if (s_p_parse_file(hashtbl, &hash_val, pathname, true) == SLURM_ERROR)
error("something wrong with opening/reading conf file");
s_p_get_boolean(&default_sview_config.admin_mode, "AdminMode", hashtbl);
if (s_p_get_uint16(&default_sview_config.button_size, "ButtonSize",
hashtbl)) {
default_sview_config.gap_size =
MAX(default_sview_config.button_size/2, 2);
}
if (s_p_get_string(&tmp_str, "DefaultPage", hashtbl)) {
if (slurm_strcasestr(tmp_str, "job"))
default_sview_config.default_page = JOB_PAGE;
else if (slurm_strcasestr(tmp_str, "part"))
default_sview_config.default_page = PART_PAGE;
else if (slurm_strcasestr(tmp_str, "res"))
default_sview_config.default_page = RESV_PAGE;
else if (slurm_strcasestr(tmp_str, "block"))
default_sview_config.default_page = BLOCK_PAGE;
else if (slurm_strcasestr(tmp_str, "node"))
default_sview_config.default_page = NODE_PAGE;
else if (slurm_strcasestr(tmp_str, "frontend"))
default_sview_config.default_page = FRONT_END_PAGE;
else if (slurm_strcasestr(tmp_str, "burstbuffer"))
default_sview_config.default_page = BB_PAGE;
xfree(tmp_str);
}
s_p_get_uint32(&default_sview_config.grid_hori,
"GridHorizontal", hashtbl);
s_p_get_boolean(&default_sview_config.grid_topological,
"GridTopo", hashtbl);
if (default_sview_config.grid_topological == 0)
default_sview_config.grid_topological = FALSE;
s_p_get_uint32(&default_sview_config.grid_vert,
"GridVertical", hashtbl);
s_p_get_uint32(&default_sview_config.grid_x_width,
"GridXWidth", hashtbl);
s_p_get_uint16(&default_sview_config.refresh_delay,
"RefreshDelay", hashtbl);
s_p_get_boolean(&default_sview_config.ruled_treeview,
"RuledTables", hashtbl);
s_p_get_boolean(&default_sview_config.show_grid,
"ShowGrid", hashtbl);
s_p_get_boolean(&default_sview_config.show_hidden,
"ShowHidden", hashtbl);
s_p_get_boolean(&default_sview_config.save_page_opts,
"SavePageSettings", hashtbl);
s_p_get_uint32(&default_sview_config.main_width,
"MainWidth", hashtbl);
s_p_get_uint32(&default_sview_config.main_height,
"MainHeight", hashtbl);
s_p_get_uint32(&default_sview_config.fi_popup_width,
"FullInfoPopupWidth", hashtbl);
s_p_get_uint32(&default_sview_config.fi_popup_height,
"FullInfoPopupHeight", hashtbl);
if (s_p_get_string(&tmp_str, "TabPosition", hashtbl)) {
if (slurm_strcasestr(tmp_str, "top"))
default_sview_config.tab_pos = GTK_POS_TOP;
else if (slurm_strcasestr(tmp_str, "bottom"))
default_sview_config.tab_pos = GTK_POS_BOTTOM;
else if (slurm_strcasestr(tmp_str, "left"))
default_sview_config.tab_pos = GTK_POS_LEFT;
else if (slurm_strcasestr(tmp_str, "right"))
default_sview_config.tab_pos = GTK_POS_RIGHT;
xfree(tmp_str);
}
if (s_p_get_string(&tmp_str, "VisiblePages", hashtbl)) {
int i = 0;
for (i=0; i<PAGE_CNT; i++)
default_sview_config.page_visible[i] = FALSE;
if (slurm_strcasestr(tmp_str, "job"))
default_sview_config.page_visible[JOB_PAGE] = 1;
if (slurm_strcasestr(tmp_str, "part"))
default_sview_config.page_visible[PART_PAGE] = 1;
if (slurm_strcasestr(tmp_str, "res"))
default_sview_config.page_visible[RESV_PAGE] = 1;
if (slurm_strcasestr(tmp_str, "block"))
default_sview_config.page_visible[BLOCK_PAGE] = 1;
if (slurm_strcasestr(tmp_str, "node"))
default_sview_config.page_visible[NODE_PAGE] = 1;
if (slurm_strcasestr(tmp_str, "frontend"))
default_sview_config.page_visible[FRONT_END_PAGE] = 1;
if (slurm_strcasestr(tmp_str, "burstbuffer"))
default_sview_config.page_visible[BB_PAGE] = 1;
xfree(tmp_str);
}
/*pull in page options*/
for (i=0; i<PAGE_CNT; i++) {
char *col_list = NULL;
char *page_name = page_to_str(i);
page_opts_t *page_opts = &default_sview_config.page_opts[i];
if (!page_name)
continue;
memset(page_opts, 0, sizeof(page_opts_t));
page_opts->page_name = page_name;
tmp_str = xstrdup_printf("PageOpts%s", page_name);
s_p_get_string(&col_list, tmp_str, hashtbl);
xfree(tmp_str);
if (col_list) {
page_opts->col_list = list_create(slurm_destroy_char);
slurm_addto_char_list(page_opts->col_list, col_list);
xfree(col_list);
}
}
xfree(tmp_str);
s_p_hashtbl_destroy(hashtbl);
end_it:
/* copy it all into the working struct (memory will work out
* in the end the col_list doesn't change) */
memcpy(&working_sview_config, &default_sview_config,
sizeof(sview_config_t));
xfree(pathname);
return rc;
}