static void _read_config(void)
{
char *knl_conf_file;
s_p_hashtbl_t *tbl;
capmc_timeout = DEFAULT_CAPMC_TIMEOUT;
knl_conf_file = get_extra_conf_path("knl_cray.conf");
if ((tbl = _config_make_tbl(knl_conf_file))) {
(void) s_p_get_string(&capmc_path, "CapmcPath", tbl);
(void) s_p_get_uint32(&capmc_poll_freq, "CapmcPollFreq", tbl);
(void) s_p_get_uint32(&capmc_timeout, "CapmcTimeout", tbl);
(void) s_p_get_string(&log_file, "LogFile", tbl);
}
xfree(knl_conf_file);
s_p_hashtbl_destroy(tbl);
if (!capmc_path)
capmc_path = xstrdup("/opt/cray/capmc/default/bin/capmc");
capmc_timeout = MAX(capmc_timeout, MIN_CAPMC_TIMEOUT);
if (!log_file)
log_file = slurm_get_job_slurmctld_logfile();
}
extern void acct_gather_infiniband_p_conf_set(s_p_hashtbl_t *tbl)
{
if (tbl) {
if (!s_p_get_uint32(&ofed_conf.port,
"InfinibandOFEDPort", tbl))
ofed_conf.port = INFINIBAND_DEFAULT_PORT;
}
if (!_run_in_daemon())
return;
debug("%s loaded", plugin_name);
ofed_sens.update_time = time(NULL);
}
/* Load configuration file contents into global variables.
* Call nonstop_free_config to free memory. */
extern void nonstop_read_config(void)
{
char *nonstop_file = NULL;
s_p_hashtbl_t *tbl = NULL;
struct stat config_stat;
nonstop_file = get_extra_conf_path("nonstop.conf");
if (stat(nonstop_file, &config_stat) < 0)
fatal("Can't stat nonstop.conf %s: %m", nonstop_file);
tbl = s_p_hashtbl_create(nonstop_options);
if (s_p_parse_file(tbl, NULL, nonstop_file, false) == SLURM_ERROR)
fatal("Can't parse nonstop.conf %s: %m", nonstop_file);
s_p_get_string(&nonstop_backup_addr, "BackupAddr", tbl);
if (!s_p_get_string(&nonstop_control_addr, "ControlAddr", tbl))
fatal("No ControlAddr in nonstop.conf %s", nonstop_file);
s_p_get_uint16(&nonstop_debug, "Debug", tbl);
s_p_get_string(&hot_spare_count_str, "HotSpareCount", tbl);
s_p_get_uint32(&max_spare_node_count, "MaxSpareNodeCount", tbl);
if (!s_p_get_uint16(&nonstop_comm_port, "Port", tbl))
nonstop_comm_port = DEFAULT_NONSTOP_PORT;
s_p_get_uint16(&time_limit_delay, "TimeLimitDelay", tbl);
s_p_get_uint16(&time_limit_drop, "TimeLimitDrop", tbl);
s_p_get_uint16(&time_limit_extend, "TimeLimitExtend", tbl);
s_p_get_string(&user_drain_allow_str, "UserDrainAllow", tbl);
s_p_get_string(&user_drain_deny_str, "UserDrainDeny", tbl);
s_p_get_uint32(&read_timeout, "ReadTimeout", tbl);
s_p_get_uint32(&write_timeout, "WriteTimeout", tbl);
_validate_config();
if (nonstop_debug > 0)
_print_config();
s_p_hashtbl_destroy(tbl);
xfree(nonstop_file);
}
static int _parse_switches(void **dest, slurm_parser_enum_t type,
const char *key, const char *value,
const char *line, char **leftover)
{
s_p_hashtbl_t *tbl;
slurm_conf_switches_t *s;
static s_p_options_t _switch_options[] = {
{"LinkSpeed", S_P_UINT32},
{"Nodes", S_P_STRING},
{"Switches", S_P_STRING},
{NULL}
};
tbl = s_p_hashtbl_create(_switch_options);
s_p_parse_line(tbl, *leftover, leftover);
s = xmalloc(sizeof(slurm_conf_switches_t));
s->switch_name = xstrdup(value);
if (!s_p_get_uint32(&s->link_speed, "LinkSpeed", tbl))
s->link_speed = 1;
s_p_get_string(&s->nodes, "Nodes", tbl);
s_p_get_string(&s->switches, "Switches", tbl);
s_p_hashtbl_destroy(tbl);
if (s->nodes && s->switches) {
error("switch %s has both child switches and nodes",
s->switch_name);
_destroy_switches(s);
return -1;
}
if (!s->nodes && !s->switches) {
error("switch %s has neither child switches nor nodes",
s->switch_name);
_destroy_switches(s);
return -1;
}
*dest = (void *)s;
return 1;
}
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->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");
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");
xfree(cray_conf_file);
if (!s_p_get_string(&cray_conf->apbasil, "apbasil", tbl))
cray_conf->apbasil = xstrdup(DEFAULT_APBASIL);
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);
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);
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("\tapkill=\t\t%s", cray_conf->apkill);
info("\tAlpsEngine=\t\t%s", cray_conf->alps_engine);
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("\tSyncTimeout=\t%u", cray_conf->sync_timeout);
#endif
return rc;
}
extern int _ext_sensors_read_conf(void)
{
s_p_options_t options[] = {
{"JobData", S_P_STRING},
{"NodeData", S_P_STRING},
{"SwitchData", S_P_STRING},
{"ColdDoorData", S_P_STRING},
{"MinWatt", S_P_UINT32},
{"MaxWatt", S_P_UINT32},
{"MinTemp", S_P_UINT32},
{"MaxTemp", S_P_UINT32},
{"EnergyRRA", S_P_STRING},
{"TempRRA", S_P_STRING},
{"EnergyPathRRD", S_P_STRING},
{"TempPathRRD", S_P_STRING},
{NULL} };
s_p_hashtbl_t *tbl = NULL;
char *conf_path = NULL;
struct stat buf;
char *temp_str = NULL;
/* Set initial values */
if (ext_sensors_cnf == NULL) {
return SLURM_ERROR;
}
_ext_sensors_clear_free_conf();
/* Get the ext_sensors.conf path and validate the file */
conf_path = get_extra_conf_path("ext_sensors.conf");
if ((conf_path == NULL) || (stat(conf_path, &buf) == -1)) {
fatal("ext_sensors: No ext_sensors file (%s)", conf_path);
} else {
debug2("ext_sensors: Reading ext_sensors file %s", conf_path);
tbl = s_p_hashtbl_create(options);
if (s_p_parse_file(tbl, NULL, conf_path, false) ==
SLURM_ERROR) {
fatal("ext_sensors: Could not open/read/parse "
"ext_sensors file %s", conf_path);
}
/* ext_sensors initialization parameters */
if (s_p_get_string(&temp_str, "JobData", tbl)) {
if (strstr(temp_str, "energy"))
ext_sensors_cnf->dataopts
|= EXT_SENSORS_OPT_JOB_ENERGY;
}
xfree(temp_str);
if (s_p_get_string(&temp_str, "NodeData", tbl)) {
if (strstr(temp_str, "energy"))
ext_sensors_cnf->dataopts
|= EXT_SENSORS_OPT_NODE_ENERGY;
if (strstr(temp_str, "temp"))
ext_sensors_cnf->dataopts
|= EXT_SENSORS_OPT_NODE_TEMP;
}
xfree(temp_str);
if (s_p_get_string(&temp_str, "SwitchData", tbl)) {
if (strstr(temp_str, "energy"))
ext_sensors_cnf->dataopts
|= EXT_SENSORS_OPT_SWITCH_ENERGY;
if (strstr(temp_str, "temp"))
ext_sensors_cnf->dataopts
|= EXT_SENSORS_OPT_SWITCH_TEMP;
}
xfree(temp_str);
if (s_p_get_string(&temp_str, "ColdDoorData", tbl)) {
if (strstr(temp_str, "temp"))
ext_sensors_cnf->dataopts
|= EXT_SENSORS_OPT_COLDDOOR_TEMP;
}
xfree(temp_str);
s_p_get_uint32(&ext_sensors_cnf->min_watt,"MinWatt", tbl);
s_p_get_uint32(&ext_sensors_cnf->max_watt,"MaxWatt", tbl);
s_p_get_uint32(&ext_sensors_cnf->min_temp,"MinTemp", tbl);
s_p_get_uint32(&ext_sensors_cnf->max_temp,"MaxTemp", tbl);
if (!s_p_get_string(&ext_sensors_cnf->energy_rra_name,
"EnergyRRA", tbl)) {
if (ext_sensors_cnf->dataopts
& EXT_SENSORS_OPT_JOB_ENERGY)
fatal("ext_sensors/rrd: EnergyRRA "
"must be set to gather JobData=energy. "
"Please set this value in your "
"ext_sensors.conf file.");
}
if (!s_p_get_string(&ext_sensors_cnf->temp_rra_name,
"TempRRA", tbl)) {
if (ext_sensors_cnf->dataopts
& EXT_SENSORS_OPT_NODE_TEMP)
fatal("ext_sensors/rrd: TempRRA "
"must be set to gather NodeData=temp. "
"Please set this value in your "
"ext_sensors.conf file.");
}
s_p_get_string(&ext_sensors_cnf->energy_rrd_file,
"EnergyPathRRD", tbl);
s_p_get_string(&ext_sensors_cnf->temp_rrd_file,
"TempPathRRD", tbl);
s_p_hashtbl_destroy(tbl);
}
xfree(conf_path);
return SLURM_SUCCESS;
}
/*
* 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_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;
}
/* Load and process BurstBufferParameters configuration parameter */
static void _load_config(void)
{
s_p_hashtbl_t *bb_hashtbl = NULL;
char *bb_conf, *tmp = NULL, *value;
static s_p_options_t bb_options[] = {
{"AllowUsers", S_P_STRING},
{"DenyUsers", S_P_STRING},
{"GetSysState", S_P_STRING},
{"JobSizeLimit", S_P_STRING},
{"StagedInPrioBoost", S_P_UINT32},
{"StartStageIn", S_P_STRING},
{"StartStageOut", S_P_STRING},
{"StopStageIn", S_P_STRING},
{"StopStageOut", S_P_STRING},
{"UserSizeLimit", S_P_STRING},
{NULL}
};
_clear_config();
if (slurm_get_debug_flags() & DEBUG_FLAG_BURST_BUF)
debug_flag = true;
bb_conf = get_extra_conf_path("burst_buffer.conf");
bb_hashtbl = s_p_hashtbl_create(bb_options);
if (s_p_parse_file(bb_hashtbl, NULL, bb_conf, false) == SLURM_ERROR)
fatal("something wrong with opening/reading %s: %m", bb_conf);
if (s_p_get_string(&allow_users_str, "AllowUsers", bb_hashtbl))
allow_users = _parse_users(allow_users_str);
if (s_p_get_string(&deny_users_str, "DenyUsers", bb_hashtbl))
deny_users = _parse_users(deny_users_str);
s_p_get_string(&get_sys_state, "GetSysState", bb_hashtbl);
if (s_p_get_string(&tmp, "JobSizeLimit", bb_hashtbl)) {
job_size_limit = _get_size_num(tmp);
xfree(tmp);
}
s_p_get_uint32(&prio_boost, "StagedInPrioBoost", bb_hashtbl);
s_p_get_string(&start_stage_in, "StartStageIn", bb_hashtbl);
s_p_get_string(&start_stage_out, "StartStageOut", bb_hashtbl);
s_p_get_string(&stop_stage_in, "StopStageIn", bb_hashtbl);
s_p_get_string(&stop_stage_out, "StopStageOut", bb_hashtbl);
if (s_p_get_string(&tmp, "UserSizeLimit", bb_hashtbl)) {
user_size_limit = _get_size_num(tmp);
xfree(tmp);
}
s_p_hashtbl_destroy(bb_hashtbl);
xfree(bb_conf);
if (debug_flag) {
value = _print_users(allow_users);
info("%s: AllowUsers:%s", __func__, value);
xfree(value);
value = _print_users(deny_users);
info("%s: DenyUsers:%s", __func__, value);
xfree(value);
info("%s: GetSysState:%s", __func__, get_sys_state);
info("%s: JobSizeLimit:%u", __func__, job_size_limit);
info("%s: StagedInPrioBoost:%u", __func__, prio_boost);
info("%s: StartStageIn:%s", __func__, start_stage_in);
info("%s: StartStageOut:%s", __func__, start_stage_out);
info("%s: StopStageIn:%s", __func__, stop_stage_in);
info("%s: StopStageOut:%s", __func__, stop_stage_out);
info("%s: UserSizeLimit:%u", __func__, user_size_limit);
}
}
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;
}
/* Load and process configuration parameters */
extern void bb_load_config(bb_state_t *state_ptr, char *plugin_type)
{
s_p_hashtbl_t *bb_hashtbl = NULL;
char *bb_conf, *tmp = NULL, *value;
#if _SUPPORT_ALT_POOL
char *colon, *save_ptr = NULL, *tok;
uint32_t pool_cnt;
#endif
int fd, i;
static s_p_options_t bb_options[] = {
{"AllowUsers", S_P_STRING},
#if _SUPPORT_ALT_POOL
{"AltPool", S_P_STRING},
#endif
{"CreateBuffer", S_P_STRING},
{"DefaultPool", S_P_STRING},
{"DenyUsers", S_P_STRING},
{"DestroyBuffer", S_P_STRING},
{"Flags", S_P_STRING},
{"GetSysState", S_P_STRING},
{"Granularity", S_P_STRING},
{"OtherTimeout", S_P_UINT32},
{"StageInTimeout", S_P_UINT32},
{"StageOutTimeout", S_P_UINT32},
{"StartStageIn", S_P_STRING},
{"StartStageOut", S_P_STRING},
{"StopStageIn", S_P_STRING},
{"StopStageOut", S_P_STRING},
{"ValidateTimeout", S_P_UINT32},
{NULL}
};
xfree(state_ptr->name);
if (plugin_type) {
tmp = strchr(plugin_type, '/');
if (tmp)
tmp++;
else
tmp = plugin_type;
state_ptr->name = xstrdup(tmp);
}
/* Set default configuration */
bb_clear_config(&state_ptr->bb_config, false);
if (slurm_get_debug_flags() & DEBUG_FLAG_BURST_BUF)
state_ptr->bb_config.debug_flag = true;
state_ptr->bb_config.flags |= BB_FLAG_DISABLE_PERSISTENT;
state_ptr->bb_config.other_timeout = DEFAULT_OTHER_TIMEOUT;
state_ptr->bb_config.stage_in_timeout = DEFAULT_STATE_IN_TIMEOUT;
state_ptr->bb_config.stage_out_timeout = DEFAULT_STATE_OUT_TIMEOUT;
state_ptr->bb_config.validate_timeout = DEFAULT_VALIDATE_TIMEOUT;
/* First look for "burst_buffer.conf" then with "type" field,
* for example "burst_buffer_cray.conf" */
bb_conf = get_extra_conf_path("burst_buffer.conf");
fd = open(bb_conf, 0);
if (fd >= 0) {
close(fd);
} else {
char *new_path = NULL;
xfree(bb_conf);
xstrfmtcat(new_path, "burst_buffer_%s.conf", state_ptr->name);
bb_conf = get_extra_conf_path(new_path);
fd = open(bb_conf, 0);
if (fd < 0) {
info("%s: Unable to find configuration file %s or "
"burst_buffer.conf", __func__, new_path);
xfree(bb_conf);
xfree(new_path);
return;
}
close(fd);
xfree(new_path);
}
bb_hashtbl = s_p_hashtbl_create(bb_options);
if (s_p_parse_file(bb_hashtbl, NULL, bb_conf, false) == SLURM_ERROR) {
fatal("%s: something wrong with opening/reading %s: %m",
__func__, bb_conf);
}
if (s_p_get_string(&state_ptr->bb_config.allow_users_str, "AllowUsers",
bb_hashtbl)) {
state_ptr->bb_config.allow_users = _parse_users(
state_ptr->bb_config.allow_users_str);
}
s_p_get_string(&state_ptr->bb_config.create_buffer, "CreateBuffer",
bb_hashtbl);
s_p_get_string(&state_ptr->bb_config.default_pool, "DefaultPool",
bb_hashtbl);
if (s_p_get_string(&state_ptr->bb_config.deny_users_str, "DenyUsers",
bb_hashtbl)) {
state_ptr->bb_config.deny_users = _parse_users(
state_ptr->bb_config.deny_users_str);
}
s_p_get_string(&state_ptr->bb_config.destroy_buffer, "DestroyBuffer",
bb_hashtbl);
if (s_p_get_string(&tmp, "Flags", bb_hashtbl)) {
state_ptr->bb_config.flags = slurm_bb_str2flags(tmp);
xfree(tmp);
}
/* By default, disable persistent buffer creation by normal users */
if (state_ptr->bb_config.flags & BB_FLAG_ENABLE_PERSISTENT)
state_ptr->bb_config.flags &= (~BB_FLAG_DISABLE_PERSISTENT);
s_p_get_string(&state_ptr->bb_config.get_sys_state, "GetSysState",
bb_hashtbl);
if (s_p_get_string(&tmp, "Granularity", bb_hashtbl)) {
state_ptr->bb_config.granularity = bb_get_size_num(tmp, 1);
xfree(tmp);
if (state_ptr->bb_config.granularity == 0) {
error("%s: Granularity=0 is invalid", __func__);
state_ptr->bb_config.granularity = 1;
}
}
#if _SUPPORT_ALT_POOL
if (s_p_get_string(&tmp, "AltPool", bb_hashtbl)) {
tok = strtok_r(tmp, ",", &save_ptr);
while (tok) {
colon = strchr(tok, ':');
if (colon) {
colon[0] = '\0';
pool_cnt = _atoi(colon + 1);
} else
pool_cnt = 1;
state_ptr->bb_config.pool_ptr = xrealloc(
state_ptr->bb_config.pool_ptr,
sizeof(burst_buffer_pool_t) *
(state_ptr->bb_config.pool_cnt + 1));
state_ptr->bb_config.
pool_ptr[state_ptr->bb_config.pool_cnt].name =
xstrdup(tok);
state_ptr->bb_config.
pool_ptr[state_ptr->bb_config.pool_cnt].
avail_space = pool_cnt;
state_ptr->bb_config.pool_cnt++;
tok = strtok_r(NULL, ",", &save_ptr);
}
xfree(tmp);
}
#endif
(void) s_p_get_uint32(&state_ptr->bb_config.other_timeout,
"OtherTimeout", bb_hashtbl);
(void) s_p_get_uint32(&state_ptr->bb_config.stage_in_timeout,
"StageInTimeout", bb_hashtbl);
(void) s_p_get_uint32(&state_ptr->bb_config.stage_out_timeout,
"StageOutTimeout", bb_hashtbl);
s_p_get_string(&state_ptr->bb_config.start_stage_in, "StartStageIn",
bb_hashtbl);
s_p_get_string(&state_ptr->bb_config.start_stage_out, "StartStageOut",
bb_hashtbl);
s_p_get_string(&state_ptr->bb_config.stop_stage_in, "StopStageIn",
bb_hashtbl);
s_p_get_string(&state_ptr->bb_config.stop_stage_out, "StopStageOut",
bb_hashtbl);
(void) s_p_get_uint32(&state_ptr->bb_config.validate_timeout,
"ValidateTimeout", bb_hashtbl);
s_p_hashtbl_destroy(bb_hashtbl);
xfree(bb_conf);
if (state_ptr->bb_config.debug_flag) {
value = _print_users(state_ptr->bb_config.allow_users);
info("%s: AllowUsers:%s", __func__, value);
xfree(value);
info("%s: CreateBuffer:%s", __func__,
state_ptr->bb_config.create_buffer);
info("%s: DefaultPool:%s", __func__,
state_ptr->bb_config.default_pool);
value = _print_users(state_ptr->bb_config.deny_users);
info("%s: DenyUsers:%s", __func__, value);
xfree(value);
info("%s: DestroyBuffer:%s", __func__,
state_ptr->bb_config.destroy_buffer);
info("%s: GetSysState:%s", __func__,
state_ptr->bb_config.get_sys_state);
info("%s: Granularity:%"PRIu64"", __func__,
state_ptr->bb_config.granularity);
for (i = 0; i < state_ptr->bb_config.pool_cnt; i++) {
info("%s: AltPoolName[%d]:%s:%"PRIu64"", __func__, i,
state_ptr->bb_config.pool_ptr[i].name,
state_ptr->bb_config.pool_ptr[i].total_space);
}
info("%s: OtherTimeout:%u", __func__,
state_ptr->bb_config.other_timeout);
info("%s: StageInTimeout:%u", __func__,
state_ptr->bb_config.stage_in_timeout);
info("%s: StageOutTimeout:%u", __func__,
state_ptr->bb_config.stage_out_timeout);
info("%s: StartStageIn:%s", __func__,
state_ptr->bb_config.start_stage_in);
info("%s: StartStageOut:%s", __func__,
state_ptr->bb_config.start_stage_out);
info("%s: StopStageIn:%s", __func__,
state_ptr->bb_config.stop_stage_in);
info("%s: StopStageOut:%s", __func__,
state_ptr->bb_config.stop_stage_out);
info("%s: ValidateTimeout:%u", __func__,
state_ptr->bb_config.validate_timeout);
}
}
