/* Return count of switch configuration entries read */
extern int _read_topo_file(slurm_conf_switches_t **ptr_array[])
{
static s_p_options_t switch_options[] = {
{"SwitchName", S_P_ARRAY, _parse_switches, _destroy_switches},
{NULL}
};
int count;
slurm_conf_switches_t **ptr;
debug("Reading the topology.conf file");
if (!topo_conf)
topo_conf = get_extra_conf_path("topology.conf");
conf_hashtbl = s_p_hashtbl_create(switch_options);
if (s_p_parse_file(conf_hashtbl, NULL, topo_conf, false) ==
SLURM_ERROR) {
s_p_hashtbl_destroy(conf_hashtbl);
fatal("something wrong with opening/reading %s: %m",
topo_conf);
}
if (s_p_get_array((void ***)&ptr, &count, "SwitchName", conf_hashtbl))
*ptr_array = ptr;
else {
*ptr_array = NULL;
count = 0;
}
return count;
}
extern int parse_image(void **dest, slurm_parser_enum_t type,
const char *key, const char *value,
const char *line, char **leftover)
{
s_p_options_t image_options[] = {
{(char *)"GROUPS", S_P_STRING},
{NULL}
};
s_p_hashtbl_t *tbl = NULL;
char *tmp = NULL;
image_t *n = NULL;
image_group_t *image_group = NULL;
int i = 0, j = 0;
tbl = s_p_hashtbl_create(image_options);
s_p_parse_line(tbl, *leftover, leftover);
n = (image_t *)xmalloc(sizeof(image_t));
n->name = xstrdup(value);
n->def = false;
n->groups = list_create(destroy_image_group_list);
s_p_get_string(&tmp, "Groups", tbl);
if (tmp) {
for(i=0; i<(int)strlen(tmp); i++) {
if ((tmp[i] == ':') || (tmp[i] == ',')) {
image_group = (image_group_t *)
xmalloc(sizeof(image_group_t));
image_group->name = (char *)xmalloc(i-j+2);
snprintf(image_group->name,
(i-j)+1, "%s", tmp+j);
gid_from_string (image_group->name,
&image_group->gid);
list_append(n->groups, image_group);
j=i;
j++;
}
}
if (j != i) {
image_group = (image_group_t *)
xmalloc(sizeof(image_group_t));
image_group->name = (char *)xmalloc(i-j+2);
snprintf(image_group->name, (i-j)+1, "%s", tmp+j);
if (gid_from_string (image_group->name,
&image_group->gid) < 0)
fatal("Invalid bluegene.conf parameter "
"Groups=%s",
image_group->name);
list_append(n->groups, image_group);
}
xfree(tmp);
}
s_p_hashtbl_destroy(tbl);
*dest = (void *)n;
return 1;
}
extern s_p_hashtbl_t *config_make_tbl(char *filename)
{
s_p_hashtbl_t *tbl = NULL;
xassert(filename);
tbl = s_p_hashtbl_create(bg_conf_file_options);
if (s_p_parse_file(tbl, NULL, filename, false) == SLURM_ERROR) {
s_p_hashtbl_destroy(tbl);
tbl = NULL;
}
return tbl;
}
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;
}
static s_p_hashtbl_t *_config_make_tbl(char *filename)
{
s_p_hashtbl_t *tbl = NULL;
xassert(filename);
if (!(tbl = s_p_hashtbl_create(knl_conf_file_options))) {
error("%s: s_p_hashtbl_create error: %s", prog_name,
slurm_strerror(slurm_get_errno()));
return tbl;
}
if (s_p_parse_file(tbl, NULL, filename, false) == SLURM_ERROR) {
error("%s: s_p_parse_file error: %s", prog_name,
slurm_strerror(slurm_get_errno()));
s_p_hashtbl_destroy(tbl);
tbl = NULL;
}
return tbl;
}
/* Determine the current actual burst buffer state.
* Run the program "get_sys_state" and parse stdout for details. */
static void _load_state(void)
{
static uint32_t last_total_space = 0;
char *save_ptr = NULL, *tok, *leftover = NULL, *resp, *tmp = NULL;
char *script_args[3] = { NULL, "get_sys", NULL };
s_p_hashtbl_t *state_hashtbl = NULL;
static s_p_options_t state_options[] = {
{"ENOENT", S_P_STRING},
{"UserID", S_P_ARRAY, _parse_job_info, _destroy_job_info},
{"TotalSize", S_P_STRING},
{NULL}
};
tok = strrchr(get_sys_state, '/');
if (tok)
script_args[0] = tok + 1;
else
script_args[0] = get_sys_state;
resp = _run_script("GetSysState", get_sys_state, script_args, 10);
if (resp == NULL)
return;
state_hashtbl = s_p_hashtbl_create(state_options);
tok = strtok_r(resp, "\n", &save_ptr);
while (tok) {
s_p_parse_line(state_hashtbl, tok, &leftover);
tok = strtok_r(NULL, "\n", &save_ptr);
}
if (s_p_get_string(&tmp, "TotalSize", state_hashtbl)) {
total_space = _get_size_num(tmp);
xfree(tmp);
} else {
error("%s: GetSysState failed to respond with TotalSize",
plugin_type);
}
s_p_hashtbl_destroy(state_hashtbl);
if (debug_flag && (total_space != last_total_space))
info("%s: total_space:%u", __func__, total_space);
last_total_space = total_space;
}
/* 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);
}
/*
* Determine the current actual burst buffer state.
* Run the program "get_sys_state" and parse stdout for details.
* job_id IN - specific job to get information about, or 0 for all jobs
*/
static void _load_state(uint32_t job_id)
{
static uint64_t last_total_space = 0;
char *save_ptr = NULL, *tok, *leftover = NULL, *resp, *tmp = NULL;
char *script_args[4], job_id_str[32];
s_p_hashtbl_t *state_hashtbl = NULL;
static s_p_options_t state_options[] = {
{"ENOENT", S_P_STRING},
{"UserID", S_P_ARRAY, _parse_job_info, _destroy_job_info},
{"TotalSize", S_P_STRING},
{NULL}
};
int status = 0;
DEF_TIMERS;
if (!bb_state.bb_config.get_sys_state)
return;
bb_state.last_load_time = time(NULL);
tok = strrchr(bb_state.bb_config.get_sys_state, '/');
if (tok)
script_args[0] = tok + 1;
else
script_args[0] = bb_state.bb_config.get_sys_state;
if (job_id) {
script_args[1] = "get_job";
snprintf(job_id_str, sizeof(job_id_str), "%u", job_id);
script_args[3] = NULL;
} else {
script_args[1] = "get_sys";
script_args[2] = NULL;
}
START_TIMER;
resp = bb_run_script("GetSysState", bb_state.bb_config.get_sys_state,
script_args, 2000, &status);
if (resp == NULL)
return;
END_TIMER;
if (DELTA_TIMER > 200000) /* 0.2 secs */
info("%s: GetSysState ran for %s", __func__, TIME_STR);
else if (bb_state.bb_config.debug_flag)
debug("%s: GetSysState ran for %s", __func__, TIME_STR);
state_hashtbl = s_p_hashtbl_create(state_options);
tok = strtok_r(resp, "\n", &save_ptr);
while (tok) {
s_p_parse_line(state_hashtbl, tok, &leftover);
tok = strtok_r(NULL, "\n", &save_ptr);
}
if (s_p_get_string(&tmp, "TotalSize", state_hashtbl)) {
bb_state.total_space = bb_get_size_num(tmp,
bb_state.bb_config.granularity);
xfree(tmp);
if (bb_state.bb_config.debug_flag &&
(bb_state.total_space != last_total_space)) {
info("%s: total_space:%"PRIu64"", __func__,
bb_state.total_space);
}
last_total_space = bb_state.total_space;
} else if (job_id == 0) {
error("%s: GetSysState failed to respond with TotalSize",
plugin_type);
}
s_p_hashtbl_destroy(state_hashtbl);
xfree(resp);
}
static int _parse_job_info(void **dest, slurm_parser_enum_t type,
const char *key, const char *value,
const char *line, char **leftover)
{
s_p_hashtbl_t *job_tbl;
char *name = NULL, *tmp = NULL, local_name[64] = "";
uint64_t size = 0;
uint32_t job_id = 0, user_id = 0;
uint16_t state = 0;
bb_alloc_t *bb_ptr;
struct job_record *job_ptr = NULL;
bb_job_t *bb_spec;
static s_p_options_t _job_options[] = {
{"JobID",S_P_STRING},
{"Name", S_P_STRING},
{"Size", S_P_STRING},
{"State", S_P_STRING},
{NULL}
};
*dest = NULL;
user_id = strtol(value, NULL, 10);
job_tbl = s_p_hashtbl_create(_job_options);
s_p_parse_line(job_tbl, *leftover, leftover);
if (s_p_get_string(&tmp, "JobID", job_tbl)) {
job_id = strtol(tmp, NULL, 10);
xfree(tmp);
}
if (s_p_get_string(&name, "Name", job_tbl)) {
snprintf(local_name, sizeof(local_name), "%s", name);
xfree(name);
}
if (s_p_get_string(&tmp, "Size", job_tbl)) {
size = bb_get_size_num(tmp, bb_state.bb_config.granularity);
xfree(tmp);
}
if (s_p_get_string(&tmp, "State", job_tbl)) {
state = bb_state_num(tmp);
xfree(tmp);
}
s_p_hashtbl_destroy(job_tbl);
#if 0
info("%s: JobID:%u Name:%s Size:%"PRIu64" State:%u UserID:%u",
__func__, job_id, local_name, size, state, user_id);
#endif
if (job_id) {
job_ptr = find_job_record(job_id);
if (!job_ptr && (state == BB_STATE_STAGED_OUT)) {
struct job_record job_rec;
job_rec.job_id = job_id;
job_rec.user_id = user_id;
bb_ptr = bb_find_alloc_rec(&bb_state, &job_rec);
_stop_stage_out(job_id); /* Purge buffer */
if (bb_ptr) {
bb_ptr->cancelled = true;
bb_ptr->end_time = 0;
} else {
/* Slurm knows nothing about this job,
* may be result of slurmctld cold start */
error("%s: Vestigial buffer for purged job %u",
plugin_type, job_id);
}
return SLURM_SUCCESS;
} else if (!job_ptr &&
((state == BB_STATE_STAGING_IN) ||
(state == BB_STATE_STAGED_IN))) {
struct job_record job_rec;
job_rec.job_id = job_id;
job_rec.user_id = user_id;
bb_ptr = bb_find_alloc_rec(&bb_state, &job_rec);
_stop_stage_in(job_id); /* Purge buffer */
if (bb_ptr) {
bb_ptr->cancelled = true;
bb_ptr->end_time = 0;
} else {
/* Slurm knows nothing about this job,
* may be result of slurmctld cold start */
error("%s: Vestigial buffer for purged job %u",
plugin_type, job_id);
}
return SLURM_SUCCESS;
} else if (!job_ptr) {
error("%s: Vestigial buffer for job ID %u. "
"Clear manually",
plugin_type, job_id);
}
snprintf(local_name, sizeof(local_name), "VestigialJob%u",
job_id);
}
if (job_ptr) {
bb_ptr = bb_find_alloc_rec(&bb_state, job_ptr);
if (bb_ptr == NULL) {
bb_spec = xmalloc(sizeof(bb_job_t));
bb_spec->total_size = _get_bb_size(job_ptr);
bb_ptr = bb_alloc_job_rec(&bb_state, job_ptr, bb_spec);
xfree(bb_spec);
bb_ptr->state = state;
/* bb_ptr->state_time set in bb_alloc_job_rec() */
}
} else {
if ((bb_ptr = _find_bb_name_rec(local_name, user_id)) == NULL) {
bb_ptr = bb_alloc_name_rec(&bb_state, local_name,
user_id);
bb_ptr->size = size;
bb_ptr->state = state;
//FIXME: VESTIGIAL: Use bb_limit_add
// bb_add_user_load(bb_ptr, &bb_state);
return SLURM_SUCCESS;
}
}
bb_ptr->seen_time = time(NULL); /* used to purge defunct recs */
/* UserID set to 0 on some failure modes */
if ((bb_ptr->user_id != user_id) && (user_id != 0)) {
error("%s: User ID mismatch (%u != %u). "
"BB UserID=%u JobID=%u Name=%s",
plugin_type, bb_ptr->user_id, user_id,
bb_ptr->user_id, bb_ptr->job_id, bb_ptr->name);
}
if ((bb_ptr->state == BB_STATE_RUNNING) &&
(state == BB_STATE_STAGED_IN))
state = BB_STATE_RUNNING; /* More precise state info */
if (bb_ptr->state != state) {
/* State is subject to real-time changes */
debug("%s: State changed (%s to %s). "
"BB UserID=%u JobID=%u Name=%s",
plugin_type, bb_state_string(bb_ptr->state),
bb_state_string(state),
bb_ptr->user_id, bb_ptr->job_id, bb_ptr->name);
bb_ptr->state = state;
bb_ptr->state_time = time(NULL);
if (bb_ptr->state == BB_STATE_STAGED_OUT) {
if (bb_ptr->size != 0) {
//FIXME: VESTIGIAL: Use bb_limit_rem
// bb_remove_user_load(bb_ptr, &bb_state);
bb_ptr->size = 0;
}
}
if (bb_ptr->state == BB_STATE_STAGED_IN)
queue_job_scheduler();
}
if ((bb_ptr->state != BB_STATE_STAGED_OUT) && (bb_ptr->size != size)) {
//FIXME: VESTIGIAL: Use bb_limit_rem
// bb_remove_user_load(bb_ptr, &bb_state);
if (size != 0) {
error("%s: Size mismatch (%"PRIu64" != %"PRIu64"). "
"BB UserID=%u JobID=%u Name=%s",
plugin_type, bb_ptr->size, size,
bb_ptr->user_id, bb_ptr->job_id, bb_ptr->name);
}
bb_ptr->size = MAX(bb_ptr->size, size);
//FIXME: VESTIGIAL: Use bb_limit_add
// bb_add_user_load(bb_ptr, &bb_state);
}
return SLURM_SUCCESS;
}
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 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;
int count = 0;
s_p_hashtbl_t *tbl = NULL;
char *layout = 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_bg_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 */
tbl = s_p_hashtbl_create(bg_conf_file_options);
if (s_p_parse_file(tbl, NULL, bg_conf_file, false) == SLURM_ERROR)
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, "BasePartitionNodeCnt", tbl)) {
error("BasePartitionNodeCnt not configured in bluegene.conf "
"defaulting to 512 as BasePartitionNodeCnt");
bg_conf->mp_cnode_cnt = 512;
bg_conf->quarter_cnode_cnt = 128;
} else {
if (bg_conf->mp_cnode_cnt <= 0)
fatal("You should have more than 0 nodes "
"per base partition");
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 Procs= "
"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 BasePartitionNodeCnt "
"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;
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, "Numpsets", tbl))
fatal("Warning: Numpsets not configured in bluegene.conf");
if (!bg_conf->ionodes_per_mp) {
if (!s_p_get_uint16(&bg_conf->ionodes_per_mp,
"IONodesPerMP", tbl))
fatal("Warning: IONodesPerMP not configured "
"in bluegene.conf");
}
#ifdef HAVE_BGQ
/* 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
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 */
if (bg_conf->mp_cnode_cnt == bg_conf->nodecard_cnode_cnt) {
bg_conf->quarter_ionode_cnt = 2;
bg_conf->nodecard_ionode_cnt = 2;
} 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);
//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);
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(&layout, "DenyPassthrough", tbl)) {
if (strstr(layout, "A"))
ba_deny_pass |= PASS_DENY_A;
if (strstr(layout, "X"))
ba_deny_pass |= PASS_DENY_X;
if (strstr(layout, "Y"))
ba_deny_pass |= PASS_DENY_Y;
if (strstr(layout, "Z"))
ba_deny_pass |= PASS_DENY_Z;
if (!strcasecmp(layout, "ALL"))
ba_deny_pass |= PASS_DENY_ALL;
bg_conf->deny_pass = ba_deny_pass;
xfree(layout);
}
if (!s_p_get_string(&layout, "LayoutMode", tbl)) {
info("Warning: LayoutMode was not specified in bluegene.conf "
"defaulting to STATIC partitioning");
bg_conf->layout_mode = LAYOUT_STATIC;
} else {
if (!strcasecmp(layout,"STATIC"))
bg_conf->layout_mode = LAYOUT_STATIC;
else if (!strcasecmp(layout,"OVERLAP"))
bg_conf->layout_mode = LAYOUT_OVERLAP;
else if (!strcasecmp(layout,"DYNAMIC"))
bg_conf->layout_mode = LAYOUT_DYNAMIC;
else {
fatal("I don't understand this LayoutMode = %s",
layout);
}
xfree(layout);
}
/* add blocks defined in file */
if (bg_conf->layout_mode != LAYOUT_DYNAMIC) {
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); */
}
for (i = 0; i < count; i++) {
add_bg_record(bg_lists->main, NULL,
blockreq_array[i], 0, 0);
}
}
s_p_hashtbl_destroy(tbl);
return SLURM_SUCCESS;
}
/* 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);
}
}
extern int parse_blockreq(void **dest, slurm_parser_enum_t type,
const char *key, const char *value,
const char *line, char **leftover)
{
s_p_options_t block_options[] = {
{"Type", S_P_STRING},
{"32CNBlocks", S_P_UINT16},
{"128CNBlocks", S_P_UINT16},
#ifdef HAVE_BGL
{"Nodecards", S_P_UINT16},
{"Quarters", S_P_UINT16},
{"BlrtsImage", S_P_STRING},
{"LinuxImage", S_P_STRING},
{"RamDiskImage", S_P_STRING},
#else
{"16CNBlocks", S_P_UINT16},
{"64CNBlocks", S_P_UINT16},
{"256CNBlocks", S_P_UINT16},
{"CnloadImage", S_P_STRING},
{"IoloadImage", S_P_STRING},
#endif
{"MloaderImage", S_P_STRING},
{NULL}
};
s_p_hashtbl_t *tbl;
char *tmp = NULL;
select_ba_request_t *n = NULL;
hostlist_t hl = NULL;
tbl = s_p_hashtbl_create(block_options);
s_p_parse_line(tbl, *leftover, leftover);
if (!value) {
return 0;
}
n = xmalloc(sizeof(select_ba_request_t));
hl = hostlist_create(value);
n->save_name = hostlist_ranged_string_xmalloc(hl);
hostlist_destroy(hl);
#ifdef HAVE_BGL
s_p_get_string(&n->blrtsimage, "BlrtsImage", tbl);
s_p_get_string(&n->linuximage, "LinuxImage", tbl);
s_p_get_string(&n->ramdiskimage, "RamDiskImage", tbl);
#else
s_p_get_string(&n->linuximage, "CnloadImage", tbl);
s_p_get_string(&n->ramdiskimage, "IoloadImage", tbl);
#endif
s_p_get_string(&n->mloaderimage, "MloaderImage", tbl);
s_p_get_string(&tmp, "Type", tbl);
if (!tmp || !strcasecmp(tmp,"TORUS"))
n->conn_type[0] = SELECT_TORUS;
else if (!strcasecmp(tmp,"MESH"))
n->conn_type[0] = SELECT_MESH;
else
n->conn_type[0] = SELECT_SMALL;
xfree(tmp);
if (!s_p_get_uint16(&n->small32, "32CNBlocks", tbl)) {
#ifdef HAVE_BGL
s_p_get_uint16(&n->small32, "Nodecards", tbl);
#else
;
#endif
}
if (!s_p_get_uint16(&n->small128, "128CNBlocks", tbl)) {
#ifdef HAVE_BGL
s_p_get_uint16(&n->small128, "Quarters", tbl);
#else
;
#endif
}
#ifndef HAVE_BGL
s_p_get_uint16(&n->small16, "16CNBlocks", tbl);
s_p_get_uint16(&n->small64, "64CNBlocks", tbl);
s_p_get_uint16(&n->small256, "256CNBlocks", tbl);
#endif
s_p_hashtbl_destroy(tbl);
*dest = (void *)n;
return 1;
}
/*
* 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 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 parse_blockreq(void **dest, slurm_parser_enum_t type,
const char *key, const char *value,
const char *line, char **leftover)
{
s_p_options_t block_options[] = {
{"Type", S_P_STRING},
{"32CNBlocks", S_P_UINT16},
{"128CNBlocks", S_P_UINT16},
#ifdef HAVE_BGL
{"Nodecards", S_P_UINT16},
{"Quarters", S_P_UINT16},
{"BlrtsImage", S_P_STRING},
{"LinuxImage", S_P_STRING},
{"RamDiskImage", S_P_STRING},
#else
#ifdef HAVE_BGP
{"16CNBlocks", S_P_UINT16},
{"CnloadImage", S_P_STRING},
{"IoloadImage", S_P_STRING},
#endif
{"64CNBlocks", S_P_UINT16},
{"256CNBlocks", S_P_UINT16},
#endif
{"MloaderImage", S_P_STRING},
{NULL}
};
s_p_hashtbl_t *tbl;
char *tmp = NULL;
select_ba_request_t *n = NULL;
hostlist_t hl = NULL;
tbl = s_p_hashtbl_create(block_options);
s_p_parse_line(tbl, *leftover, leftover);
if (!value) {
return 0;
}
n = xmalloc(sizeof(select_ba_request_t));
hl = hostlist_create(value);
n->save_name = hostlist_ranged_string_xmalloc(hl);
hostlist_destroy(hl);
#ifdef HAVE_BGL
s_p_get_string(&n->blrtsimage, "BlrtsImage", tbl);
s_p_get_string(&n->linuximage, "LinuxImage", tbl);
s_p_get_string(&n->ramdiskimage, "RamDiskImage", tbl);
#elif defined HAVE_BGP
s_p_get_string(&n->linuximage, "CnloadImage", tbl);
s_p_get_string(&n->ramdiskimage, "IoloadImage", tbl);
#endif
s_p_get_string(&n->mloaderimage, "MloaderImage", tbl);
s_p_get_string(&tmp, "Type", tbl);
if (tmp) {
verify_conn_type(tmp, n->conn_type);
xfree(tmp);
}
if (!s_p_get_uint16(&n->small32, "32CNBlocks", tbl)) {
#ifdef HAVE_BGL
s_p_get_uint16(&n->small32, "Nodecards", tbl);
#else
;
#endif
}
if (!s_p_get_uint16(&n->small128, "128CNBlocks", tbl)) {
#ifdef HAVE_BGL
s_p_get_uint16(&n->small128, "Quarters", tbl);
#else
;
#endif
}
#ifndef HAVE_BGL
#ifdef HAVE_BGP
s_p_get_uint16(&n->small16, "16CNBlocks", tbl);
#endif
s_p_get_uint16(&n->small64, "64CNBlocks", tbl);
s_p_get_uint16(&n->small256, "256CNBlocks", tbl);
#endif
if (n->small16 || n->small32 || n->small64
|| n->small128 || n->small256) {
if (n->conn_type[0] < SELECT_SMALL) {
error("Block def on midplane(s) %s is "
"asking for small blocks but given "
"TYPE=%s, setting it to Small",
n->save_name, conn_type_string(n->conn_type[0]));
n->conn_type[0] = SELECT_SMALL;
}
} else {
if (n->conn_type[0] == (uint16_t)NO_VAL) {
n->conn_type[0] = bg_conf->default_conn_type[0];
} else if (n->conn_type[0] >= SELECT_SMALL) {
error("Block def on midplane(s) %s is given "
"TYPE=%s but isn't asking for any small "
"blocks. Giving it %s.",
n->save_name, conn_type_string(n->conn_type[0]),
conn_type_string(
bg_conf->default_conn_type[0]));
n->conn_type[0] = bg_conf->default_conn_type[0];
}
#ifndef HAVE_BG_L_P
int i;
for (i=1; i<SYSTEM_DIMENSIONS; i++) {
if (n->conn_type[i] == (uint16_t)NO_VAL)
n->conn_type[i] = bg_conf->default_conn_type[i];
else if (n->conn_type[i] >= SELECT_SMALL) {
error("Block def on midplane(s) %s dim %d "
"is given TYPE=%s but isn't asking "
"for any small blocks. Giving it %s.",
n->save_name, i,
conn_type_string(n->conn_type[i]),
conn_type_string(
bg_conf->default_conn_type[i]));
n->conn_type[i] = bg_conf->default_conn_type[i];
}
}
#endif
}
s_p_hashtbl_destroy(tbl);
*dest = (void *)n;
return 1;
}
/*
* 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;
}
static int _parse_job_info(void **dest, slurm_parser_enum_t type,
const char *key, const char *value,
const char *line, char **leftover)
{
s_p_hashtbl_t *job_tbl;
char *name = NULL, *tmp = NULL, tmp_name[64];
uint32_t job_id = 0, size = 0, user_id = 0;
uint16_t state = 0;
bb_alloc_t *bb_ptr;
struct job_record *job_ptr = NULL;
static s_p_options_t _job_options[] = {
{"JobID",S_P_STRING},
{"Name", S_P_STRING},
{"Size", S_P_STRING},
{"State", S_P_STRING},
{NULL}
};
*dest = NULL;
user_id = atoi(value);
job_tbl = s_p_hashtbl_create(_job_options);
s_p_parse_line(job_tbl, *leftover, leftover);
if (s_p_get_string(&tmp, "JobID", job_tbl))
job_id = atoi(tmp);
s_p_get_string(&name, "Name", job_tbl);
if (s_p_get_string(&tmp, "Size", job_tbl))
size = _get_size_num(tmp);
if (s_p_get_string(&tmp, "State", job_tbl))
state = bb_state_num(tmp);
#if 1
info("%s: JobID:%u Name:%s Size:%u State:%u UserID:%u",
__func__, job_id, name, size, state, user_id);
#endif
if (job_id) {
job_ptr = find_job_record(job_id);
if (!job_ptr) {
error("%s: Vestigial buffer for job ID %u. "
"Clear manually",
plugin_type, job_id);
}
snprintf(tmp_name, sizeof(tmp_name), "VestigialJob%u", job_id);
job_id = 0;
name = tmp_name;
}
if (job_ptr) {
if ((bb_ptr = _find_bb_job_rec(job_ptr)) == NULL) {
bb_ptr = _alloc_bb_job_rec(job_ptr);
bb_ptr->state = state;
}
} else {
if ((bb_ptr = _find_bb_name_rec(name, user_id)) == NULL) {
bb_ptr = _alloc_bb_name_rec(name, user_id);
bb_ptr->size = size;
bb_ptr->state = state;
return SLURM_SUCCESS;
}
}
if (bb_ptr->user_id != user_id) {
error("%s: User ID mismatch (%u != %u). "
"BB UserID=%u JobID=%u Name=%s",
plugin_type, bb_ptr->user_id, user_id,
bb_ptr->user_id, bb_ptr->job_id, bb_ptr->name);
}
if (bb_ptr->size != size) {
error("%s: Size mismatch (%u != %u). "
"BB UserID=%u JobID=%u Name=%s",
plugin_type, bb_ptr->size, size,
bb_ptr->user_id, bb_ptr->job_id, bb_ptr->name);
bb_ptr->size = MAX(bb_ptr->size, size);
}
if (bb_ptr->state != state) {
/* State is subject to real-time changes */
debug("%s: State mismatch (%s != %s). "
"BB UserID=%u JobID=%u Name=%s",
plugin_type, bb_state_string(bb_ptr->state),
bb_state_string(state),
bb_ptr->user_id, bb_ptr->job_id, bb_ptr->name);
}
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;
}
extern int acct_gather_conf_init(void)
{
s_p_hashtbl_t *tbl = NULL;
char *conf_path = NULL;
s_p_options_t *full_options = NULL;
int full_options_cnt = 0, i;
struct stat buf;
if (inited)
return SLURM_SUCCESS;
inited = 1;
/* get options from plugins using acct_gather.conf */
acct_gather_energy_g_conf_options(&full_options, &full_options_cnt);
acct_gather_profile_g_conf_options(&full_options, &full_options_cnt);
acct_gather_infiniband_g_conf_options(&full_options, &full_options_cnt);
acct_gather_filesystem_g_conf_options(&full_options, &full_options_cnt);
/* ADD MORE HERE */
/* for the NULL at the end */
xrealloc(full_options,
((full_options_cnt + 1) * sizeof(s_p_options_t)));
/**************************************************/
/* Get the acct_gather.conf path and validate the file */
conf_path = get_extra_conf_path("acct_gather.conf");
if ((conf_path == NULL) || (stat(conf_path, &buf) == -1)) {
debug2("No acct_gather.conf file (%s)", conf_path);
} else {
debug2("Reading acct_gather.conf file %s", conf_path);
tbl = s_p_hashtbl_create(full_options);
if (s_p_parse_file(tbl, NULL, conf_path, false) ==
SLURM_ERROR) {
fatal("Could not open/read/parse acct_gather.conf file "
"%s. Many times this is because you have "
"defined options for plugins that are not "
"loaded. Please check your slurm.conf file "
"and make sure the plugins for the options "
"listed are loaded.",
conf_path);
}
}
for (i=0; i<full_options_cnt; i++)
xfree(full_options[i].key);
xfree(full_options);
xfree(conf_path);
/* handle acct_gather.conf in each plugin */
acct_gather_energy_g_conf_set(tbl);
acct_gather_profile_g_conf_set(tbl);
acct_gather_infiniband_g_conf_set(tbl);
acct_gather_filesystem_g_conf_set(tbl);
/*********************************************************************/
/* ADD MORE HERE AND FREE MEMORY IN acct_gather_conf_destroy() BELOW */
/*********************************************************************/
s_p_hashtbl_destroy(tbl);
return SLURM_SUCCESS;
}
/*****************************************************************************\
* parse_wiki_config - Results go into global variables
* RET SLURM_SUCESS or error code
*
* wiki_conf options
* JobPriority=hold|run
* AuthKey=number
\*****************************************************************************/
extern int parse_wiki_config(void)
{
s_p_options_t options[] = {
{"AuthKey", S_P_STRING},
{"EHost", S_P_STRING},
{"EHostBackup", S_P_STRING},
{"EPort", S_P_UINT16},
{"ExcludePartitions", S_P_STRING},
{"HidePartitionJobs", S_P_STRING},
{"HidePartitionNodes", S_P_STRING},
{"HostFormat", S_P_UINT16},
{"JobAggregationTime", S_P_UINT16},
{"JobPriority", S_P_STRING},
{NULL} };
s_p_hashtbl_t *tbl;
char *exclude_partitions, *hide_partitions, *hide_part_nodes;
char *key = NULL, *priority_mode = NULL, *wiki_conf;
struct stat buf;
slurm_ctl_conf_t *conf;
int i;
/* Set default values */
for (i=0; i<EXC_PART_CNT; i++)
exclude_part_ptr[i] = NULL;
for (i=0; i<HIDE_PART_CNT; i++)
hide_part_ptr[i] = NULL;
for (i=0; i<HIDE_PART_CNT; i++)
hide_part_nodes_ptr[i] = NULL;
conf = slurm_conf_lock();
strncpy(e_host, conf->control_addr, sizeof(e_host));
if (conf->backup_addr) {
strncpy(e_host_bu, conf->backup_addr,
sizeof(e_host));
}
kill_wait = conf->kill_wait;
slurm_conf_unlock();
wiki_conf = get_extra_conf_path("wiki.conf");
if ((wiki_conf == NULL) || (stat(wiki_conf, &buf) == -1)) {
debug("No wiki.conf file (%s)", wiki_conf);
xfree(wiki_conf);
return SLURM_SUCCESS;
}
debug("Reading wiki.conf file (%s)",wiki_conf);
tbl = s_p_hashtbl_create(options);
if (s_p_parse_file(tbl, NULL, wiki_conf, false) == SLURM_ERROR)
fatal("something wrong with opening/reading wiki.conf file");
if (! s_p_get_string(&key, "AuthKey", tbl))
debug("Warning: No wiki_conf AuthKey specified");
else {
strncpy(auth_key, key, sizeof(auth_key));
xfree(key);
}
if ( s_p_get_string(&key, "EHost", tbl)) {
strncpy(e_host, key, sizeof(e_host));
xfree(key);
} else
debug("wiki: Using ControlAddr for EHost value");
if ( s_p_get_string(&key, "EHostBackup", tbl)) {
strncpy(e_host_bu, key, sizeof(e_host_bu));
xfree(key);
}
s_p_get_uint16(&e_port, "EPort", tbl);
if (s_p_get_uint16(&job_aggregation_time, "JobAggregationTime", tbl))
error("JobAggregationTime not used by sched/wiki");
if (s_p_get_uint16(&host_format, "HostFormat", tbl))
error("HostFormat not used by sched/wiki");
if (s_p_get_string(&exclude_partitions, "ExcludePartitions", tbl)) {
char *tok = NULL, *tok_p = NULL;
tok = strtok_r(exclude_partitions, ",", &tok_p);
i = 0;
while (tok) {
if (i >= EXC_PART_CNT) {
error("ExcludePartitions has too many entries "
"skipping %s and later entries", tok);
break;
}
exclude_part_ptr[i] = find_part_record(tok);
if (exclude_part_ptr[i])
i++;
else
error("ExcludePartitions %s not found", tok);
tok = strtok_r(NULL, ",", &tok_p);
}
}
if (s_p_get_string(&hide_partitions, "HidePartitionJobs", tbl)) {
char *tok = NULL, *tok_p = NULL;
tok = strtok_r(hide_partitions, ",", &tok_p);
i = 0;
while (tok) {
if (i >= HIDE_PART_CNT) {
error("HidePartitionJobs has too many entries "
"skipping %s and later entries", tok);
break;
}
hide_part_ptr[i] = find_part_record(tok);
if (hide_part_ptr[i])
i++;
else
error("HidePartitionJobs %s not found", tok);
tok = strtok_r(NULL, ",", &tok_p);
}
}
if (s_p_get_string(&hide_part_nodes, "HidePartitionNodes", tbl)) {
char *tok = NULL, *tok_p = NULL;
tok = strtok_r(hide_part_nodes, ",", &tok_p);
i = 0;
while (tok) {
if (i >= HIDE_PART_CNT) {
error("HidePartitionNodes has too many entries "
"skipping %s and later entries", tok);
break;
}
hide_part_nodes_ptr[i] = find_part_record(tok);
if (hide_part_nodes_ptr[i])
i++;
else
error("HidePartitionNodes %s not found", tok);
tok = strtok_r(NULL, ",", &tok_p);
}
}
if (s_p_get_string(&priority_mode, "JobPriority", tbl)) {
if (strcasecmp(priority_mode, "hold") == 0)
init_prio_mode = PRIO_HOLD;
else if (strcasecmp(priority_mode, "run") == 0)
init_prio_mode = PRIO_DECREMENT;
else
error("Invalid value for JobPriority in wiki.conf");
xfree(priority_mode);
}
s_p_hashtbl_destroy(tbl);
xfree(wiki_conf);
#if _DEBUG
info("AuthKey = %s", auth_key);
info("EHost = %s", e_host);
info("EHostBackup = %s", e_host_bu);
info("EPort = %u", e_port);
info("JobAggregationTime = %u sec", job_aggregation_time);
info("JobPriority = %s", init_prio_mode ? "run" : "hold");
info("KillWait = %u sec", kill_wait);
for (i=0; i<EXC_PART_CNT; i++) {
if (!exclude_part_ptr[i])
continue;
info("ExcludePartitions = %s", exclude_part_ptr[i]->name);
}
for (i=0; i<HIDE_PART_CNT; i++) {
if (!hide_part_ptr[i])
continue;
info("HidePartitionJobs = %s", hide_part_ptr[i]->name);
}
for (i=0; i<HIDE_PART_CNT; i++) {
if (!hide_part_nodes_ptr[i])
continue;
info("HidePartitionNodes = %s", hide_part_nodes_ptr[i]->name);
}
#endif
return SLURM_SUCCESS;
}
