/* 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; }
/* * Return true if fake_gpus.conf does exist. Used for testing */ static bool _test_gpu_list_fake(void) { struct stat config_stat; char *fake_gpus_file = NULL; bool have_fake_gpus = false; fake_gpus_file = get_extra_conf_path("fake_gpus.conf"); if (stat(fake_gpus_file, &config_stat) >= 0) { have_fake_gpus = true; } xfree(fake_gpus_file); return have_fake_gpus; }
static void _read_config(void) { char *knl_conf_file; s_p_hashtbl_t *tbl; 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_timeout, "CapmcTimeout", tbl); (void) s_p_get_string(&log_file, "LogFile", tbl); (void) s_p_get_string(&syscfg_path, "SyscfgPath", 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, 500); if (!log_file) log_file = slurm_get_job_slurmctld_logfile(); }
/* 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); }
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; }
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; }
/* Dump the configuration in name,value pairs for output to * "statsmgr show config", caller must call list_destroy() */ extern List dump_config(void) { config_key_pair_t *key_pair; char time_str[32]; List my_list = list_create(destroy_config_key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("ArchiveDir"); key_pair->value = xstrdup(slurmdbd_conf->archive_dir); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("ArchiveEvents"); key_pair->value = xstrdup( SLURMDB_PURGE_ARCHIVE_SET( slurmdbd_conf->purge_event) ? "Yes" : "No"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("ArchiveJobs"); key_pair->value = xstrdup( SLURMDB_PURGE_ARCHIVE_SET( slurmdbd_conf->purge_job) ? "Yes" : "No"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("ArchiveResvs"); key_pair->value = xstrdup( SLURMDB_PURGE_ARCHIVE_SET( slurmdbd_conf->purge_resv) ? "Yes" : "No"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("ArchiveScript"); key_pair->value = xstrdup(slurmdbd_conf->archive_script); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("ArchiveSteps"); key_pair->value = xstrdup( SLURMDB_PURGE_ARCHIVE_SET( slurmdbd_conf->purge_step) ? "Yes" : "No"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("ArchiveSuspend"); key_pair->value = xstrdup( SLURMDB_PURGE_ARCHIVE_SET( slurmdbd_conf->purge_suspend) ? "Yes" : "No"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("ArchiveTXN"); key_pair->value = xstrdup( SLURMDB_PURGE_ARCHIVE_SET( slurmdbd_conf->purge_txn) ? "Yes" : "No"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("ArchiveUsage"); key_pair->value = xstrdup( SLURMDB_PURGE_ARCHIVE_SET( slurmdbd_conf->purge_usage) ? "Yes" : "No"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("AuthInfo"); key_pair->value = xstrdup(slurmdbd_conf->auth_info); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("AuthType"); key_pair->value = xstrdup(slurmdbd_conf->auth_type); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("BOOT_TIME"); key_pair->value = xmalloc(128); slurm_make_time_str ((time_t *)&boot_time, key_pair->value, 128); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("CommitDelay"); key_pair->value = xstrdup(slurmdbd_conf->commit_delay ? "Yes" : "No"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("DbdAddr"); key_pair->value = xstrdup(slurmdbd_conf->dbd_addr); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("DbdBackupHost"); key_pair->value = xstrdup(slurmdbd_conf->dbd_backup); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("DbdHost"); key_pair->value = xstrdup(slurmdbd_conf->dbd_host); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("DbdPort"); key_pair->value = xstrdup_printf("%u", slurmdbd_conf->dbd_port); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("DebugFlags"); key_pair->value = debug_flags2str(slurmdbd_conf->debug_flags); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("DebugLevel"); key_pair->value = xstrdup(log_num2string(slurmdbd_conf->debug_level)); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("DebugLevelSyslog"); key_pair->value = xstrdup(log_num2string(slurmdbd_conf->syslog_debug)); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("DefaultQOS"); key_pair->value = xstrdup(slurmdbd_conf->default_qos); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("LogFile"); key_pair->value = xstrdup(slurmdbd_conf->log_file); list_append(my_list, key_pair); secs2time_str(slurmdbd_conf->max_time_range, time_str, sizeof(time_str)); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("MaxQueryTimeRange"); key_pair->value = xstrdup_printf("%s", time_str); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("MessageTimeout"); key_pair->value = xstrdup_printf("%u secs", slurmdbd_conf->msg_timeout); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("PidFile"); key_pair->value = xstrdup(slurmdbd_conf->pid_file); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("PluginDir"); key_pair->value = xstrdup(slurmdbd_conf->plugindir); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("PrivateData"); key_pair->value = xmalloc(128); private_data_string(slurmdbd_conf->private_data, key_pair->value, 128); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("PurgeEventAfter"); if (slurmdbd_conf->purge_event != NO_VAL) { key_pair->value = xmalloc(32); slurmdb_purge_string(slurmdbd_conf->purge_event, key_pair->value, 32, 1); } else key_pair->value = xstrdup("NONE"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("PurgeJobAfter"); if (slurmdbd_conf->purge_job != NO_VAL) { key_pair->value = xmalloc(32); slurmdb_purge_string(slurmdbd_conf->purge_job, key_pair->value, 32, 1); } else key_pair->value = xstrdup("NONE"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("PurgeResvAfter"); if (slurmdbd_conf->purge_resv != NO_VAL) { key_pair->value = xmalloc(32); slurmdb_purge_string(slurmdbd_conf->purge_resv, key_pair->value, 32, 1); } else key_pair->value = xstrdup("NONE"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("PurgeStepAfter"); if (slurmdbd_conf->purge_step != NO_VAL) { key_pair->value = xmalloc(32); slurmdb_purge_string(slurmdbd_conf->purge_step, key_pair->value, 32, 1); } else key_pair->value = xstrdup("NONE"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("PurgeSuspendAfter"); if (slurmdbd_conf->purge_suspend != NO_VAL) { key_pair->value = xmalloc(32); slurmdb_purge_string(slurmdbd_conf->purge_suspend, key_pair->value, 32, 1); } else key_pair->value = xstrdup("NONE"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("PurgeTXNAfter"); if (slurmdbd_conf->purge_txn != NO_VAL) { key_pair->value = xmalloc(32); slurmdb_purge_string(slurmdbd_conf->purge_txn, key_pair->value, 32, 1); } else key_pair->value = xstrdup("NONE"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("PurgeUsageAfter"); if (slurmdbd_conf->purge_usage != NO_VAL) { key_pair->value = xmalloc(32); slurmdb_purge_string(slurmdbd_conf->purge_usage, key_pair->value, 32, 1); } else key_pair->value = xstrdup("NONE"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("SLURMDBD_CONF"); key_pair->value = get_extra_conf_path("slurmdbd.conf"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("SLURMDBD_VERSION"); key_pair->value = xstrdup(SLURM_VERSION_STRING); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("SlurmUser"); key_pair->value = xstrdup_printf("%s(%u)", slurmdbd_conf->slurm_user_name, slurmdbd_conf->slurm_user_id); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("StorageBackupHost"); key_pair->value = xstrdup(slurmdbd_conf->storage_backup_host); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("StorageHost"); key_pair->value = xstrdup(slurmdbd_conf->storage_host); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("StorageLoc"); key_pair->value = xstrdup(slurmdbd_conf->storage_loc); list_append(my_list, key_pair); /* StoragePass should NOT be passed due to security reasons */ key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("StoragePort"); key_pair->value = xstrdup_printf("%u", slurmdbd_conf->storage_port); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("StorageType"); key_pair->value = xstrdup(slurmdbd_conf->storage_type); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("StorageUser"); key_pair->value = xstrdup(slurmdbd_conf->storage_user); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("TCPTimeout"); key_pair->value = xstrdup_printf("%u secs", slurmdbd_conf->tcp_timeout); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("TrackWCKey"); key_pair->value = xstrdup(slurmdbd_conf->track_wckey ? "Yes" : "No"); list_append(my_list, key_pair); key_pair = xmalloc(sizeof(config_key_pair_t)); key_pair->name = xstrdup("TrackSlurmctldDown"); key_pair->value = xstrdup(slurmdbd_conf->track_ctld ? "Yes" : "No"); list_append(my_list, key_pair); return my_list; }
/* * 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; }
/*****************************************************************************\ * 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; }
/* * Read and process the bluegene.conf configuration file so to interpret what * blocks are static/dynamic, torus/mesh, etc. */ extern int read_bg_conf(void) { int i; bool tmp_bool = 0; int count = 0; s_p_hashtbl_t *tbl = NULL; char *tmp_char = NULL; select_ba_request_t **blockreq_array = NULL; image_t **image_array = NULL; image_t *image = NULL; static time_t last_config_update = (time_t) 0; struct stat config_stat; ListIterator itr = NULL; char* bg_conf_file = NULL; static int *dims = NULL; if (!dims) dims = select_g_ba_get_dims(); if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("Reading the bluegene.conf file"); /* check if config file has changed */ bg_conf_file = get_extra_conf_path("bluegene.conf"); if (stat(bg_conf_file, &config_stat) < 0) fatal("can't stat bluegene.conf file %s: %m", bg_conf_file); if (last_config_update) { _reopen_bridge_log(); if (last_config_update == config_stat.st_mtime) { if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("%s unchanged", bg_conf_file); } else { info("Restart slurmctld for %s changes " "to take effect", bg_conf_file); } last_config_update = config_stat.st_mtime; xfree(bg_conf_file); return SLURM_SUCCESS; } last_config_update = config_stat.st_mtime; /* initialization */ /* bg_conf defined in bg_node_alloc.h */ if (!(tbl = config_make_tbl(bg_conf_file))) fatal("something wrong with opening/reading bluegene " "conf file"); xfree(bg_conf_file); #ifdef HAVE_BGL if (s_p_get_array((void ***)&image_array, &count, "AltBlrtsImage", tbl)) { for (i = 0; i < count; i++) { list_append(bg_conf->blrts_list, image_array[i]); image_array[i] = NULL; } } if (!s_p_get_string(&bg_conf->default_blrtsimage, "BlrtsImage", tbl)) { if (!list_count(bg_conf->blrts_list)) fatal("BlrtsImage not configured " "in bluegene.conf"); itr = list_iterator_create(bg_conf->blrts_list); image = list_next(itr); image->def = true; list_iterator_destroy(itr); bg_conf->default_blrtsimage = xstrdup(image->name); info("Warning: using %s as the default BlrtsImage. " "If this isn't correct please set BlrtsImage", bg_conf->default_blrtsimage); } else { if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("default BlrtsImage %s", bg_conf->default_blrtsimage); image = xmalloc(sizeof(image_t)); image->name = xstrdup(bg_conf->default_blrtsimage); image->def = true; image->groups = NULL; /* we want it to be first */ list_push(bg_conf->blrts_list, image); } if (s_p_get_array((void ***)&image_array, &count, "AltLinuxImage", tbl)) { for (i = 0; i < count; i++) { list_append(bg_conf->linux_list, image_array[i]); image_array[i] = NULL; } } if (!s_p_get_string(&bg_conf->default_linuximage, "LinuxImage", tbl)) { if (!list_count(bg_conf->linux_list)) fatal("LinuxImage not configured " "in bluegene.conf"); itr = list_iterator_create(bg_conf->linux_list); image = list_next(itr); image->def = true; list_iterator_destroy(itr); bg_conf->default_linuximage = xstrdup(image->name); info("Warning: using %s as the default LinuxImage. " "If this isn't correct please set LinuxImage", bg_conf->default_linuximage); } else { if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("default LinuxImage %s", bg_conf->default_linuximage); image = xmalloc(sizeof(image_t)); image->name = xstrdup(bg_conf->default_linuximage); image->def = true; image->groups = NULL; /* we want it to be first */ list_push(bg_conf->linux_list, image); } if (s_p_get_array((void ***)&image_array, &count, "AltRamDiskImage", tbl)) { for (i = 0; i < count; i++) { list_append(bg_conf->ramdisk_list, image_array[i]); image_array[i] = NULL; } } if (!s_p_get_string(&bg_conf->default_ramdiskimage, "RamDiskImage", tbl)) { if (!list_count(bg_conf->ramdisk_list)) fatal("RamDiskImage not configured " "in bluegene.conf"); itr = list_iterator_create(bg_conf->ramdisk_list); image = list_next(itr); image->def = true; list_iterator_destroy(itr); bg_conf->default_ramdiskimage = xstrdup(image->name); info("Warning: using %s as the default RamDiskImage. " "If this isn't correct please set RamDiskImage", bg_conf->default_ramdiskimage); } else { if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("default RamDiskImage %s", bg_conf->default_ramdiskimage); image = xmalloc(sizeof(image_t)); image->name = xstrdup(bg_conf->default_ramdiskimage); image->def = true; image->groups = NULL; /* we want it to be first */ list_push(bg_conf->ramdisk_list, image); } #elif defined HAVE_BGP if (s_p_get_array((void ***)&image_array, &count, "AltCnloadImage", tbl)) { for (i = 0; i < count; i++) { list_append(bg_conf->linux_list, image_array[i]); image_array[i] = NULL; } } if (!s_p_get_string(&bg_conf->default_linuximage, "CnloadImage", tbl)) { if (!list_count(bg_conf->linux_list)) fatal("CnloadImage not configured " "in bluegene.conf"); itr = list_iterator_create(bg_conf->linux_list); image = list_next(itr); image->def = true; list_iterator_destroy(itr); bg_conf->default_linuximage = xstrdup(image->name); info("Warning: using %s as the default CnloadImage. " "If this isn't correct please set CnloadImage", bg_conf->default_linuximage); } else { if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("default CnloadImage %s", bg_conf->default_linuximage); image = xmalloc(sizeof(image_t)); image->name = xstrdup(bg_conf->default_linuximage); image->def = true; image->groups = NULL; /* we want it to be first */ list_push(bg_conf->linux_list, image); } if (s_p_get_array((void ***)&image_array, &count, "AltIoloadImage", tbl)) { for (i = 0; i < count; i++) { list_append(bg_conf->ramdisk_list, image_array[i]); image_array[i] = NULL; } } if (!s_p_get_string(&bg_conf->default_ramdiskimage, "IoloadImage", tbl)) { if (!list_count(bg_conf->ramdisk_list)) fatal("IoloadImage not configured " "in bluegene.conf"); itr = list_iterator_create(bg_conf->ramdisk_list); image = list_next(itr); image->def = true; list_iterator_destroy(itr); bg_conf->default_ramdiskimage = xstrdup(image->name); info("Warning: using %s as the default IoloadImage. " "If this isn't correct please set IoloadImage", bg_conf->default_ramdiskimage); } else { if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("default IoloadImage %s", bg_conf->default_ramdiskimage); image = xmalloc(sizeof(image_t)); image->name = xstrdup(bg_conf->default_ramdiskimage); image->def = true; image->groups = NULL; /* we want it to be first */ list_push(bg_conf->ramdisk_list, image); } #endif if (s_p_get_array((void ***)&image_array, &count, "AltMloaderImage", tbl)) { for (i = 0; i < count; i++) { list_append(bg_conf->mloader_list, image_array[i]); image_array[i] = NULL; } } if (!s_p_get_string(&bg_conf->default_mloaderimage, "MloaderImage", tbl)) { if (!list_count(bg_conf->mloader_list)) fatal("MloaderImage not configured " "in bluegene.conf"); itr = list_iterator_create(bg_conf->mloader_list); image = list_next(itr); image->def = true; list_iterator_destroy(itr); bg_conf->default_mloaderimage = xstrdup(image->name); info("Warning: using %s as the default MloaderImage. " "If this isn't correct please set MloaderImage", bg_conf->default_mloaderimage); } else { if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("default MloaderImage %s", bg_conf->default_mloaderimage); image = xmalloc(sizeof(image_t)); image->name = xstrdup(bg_conf->default_mloaderimage); image->def = true; image->groups = NULL; /* we want it to be first */ list_push(bg_conf->mloader_list, image); } if (!s_p_get_uint16(&bg_conf->mp_cnode_cnt, "MidplaneNodeCnt", tbl)) { if (!s_p_get_uint16(&bg_conf->mp_cnode_cnt, "BasePartitionNodeCnt", tbl)) { error("MidplaneNodeCnt not configured in bluegene.conf " "defaulting to 512 as MidplaneNodeCnt"); bg_conf->mp_cnode_cnt = 512; } } if (bg_conf->mp_cnode_cnt <= 0) fatal("You should have more than 0 nodes " "per midplane"); bg_conf->actual_cnodes_per_mp = bg_conf->mp_cnode_cnt; bg_conf->quarter_cnode_cnt = bg_conf->mp_cnode_cnt/4; /* bg_conf->cpus_per_mp should had already been set from the * node_init */ if (bg_conf->cpus_per_mp < bg_conf->mp_cnode_cnt) { fatal("For some reason we have only %u cpus per mp, but " "have %u cnodes per mp. You need at least the same " "number of cpus as you have cnodes per mp. " "Check the NodeName CPUs= " "definition in the slurm.conf.", bg_conf->cpus_per_mp, bg_conf->mp_cnode_cnt); } bg_conf->cpu_ratio = bg_conf->cpus_per_mp/bg_conf->mp_cnode_cnt; if (!bg_conf->cpu_ratio) fatal("We appear to have less than 1 cpu on a cnode. " "You specified %u for MidplaneNodeCnt " "in the blugene.conf and %u cpus " "for each node in the slurm.conf", bg_conf->mp_cnode_cnt, bg_conf->cpus_per_mp); num_unused_cpus = 1; for (i = 0; i<SYSTEM_DIMENSIONS; i++) num_unused_cpus *= dims[i]; num_unused_cpus *= bg_conf->cpus_per_mp; num_possible_unused_cpus = num_unused_cpus; if (!s_p_get_uint16(&bg_conf->nodecard_cnode_cnt, "NodeBoardNodeCnt", tbl)) { if (!s_p_get_uint16(&bg_conf->nodecard_cnode_cnt, "NodeCardNodeCnt", tbl)) { error("NodeCardNodeCnt not configured in bluegene.conf " "defaulting to 32 as NodeCardNodeCnt"); bg_conf->nodecard_cnode_cnt = 32; } } if (bg_conf->nodecard_cnode_cnt <= 0) fatal("You should have more than 0 nodes per nodecard"); bg_conf->mp_nodecard_cnt = bg_conf->mp_cnode_cnt / bg_conf->nodecard_cnode_cnt; if (!s_p_get_uint16(&bg_conf->ionodes_per_mp, "IONodesPerMP", tbl)) if (!s_p_get_uint16(&bg_conf->ionodes_per_mp, "Numpsets", tbl)) fatal("Warning: IONodesPerMP not configured " "in bluegene.conf"); s_p_get_uint16(&bg_conf->max_block_err, "MaxBlockInError", tbl); tmp_bool = 0; s_p_get_boolean(&tmp_bool, "SubMidplaneSystem", tbl); bg_conf->sub_mp_sys = tmp_bool; #ifdef HAVE_BGQ tmp_bool = 0; s_p_get_boolean(&tmp_bool, "AllowSubBlockAllocations", tbl); bg_conf->sub_blocks = tmp_bool; /* You can only have 16 ionodes per midplane */ if (bg_conf->ionodes_per_mp > bg_conf->mp_nodecard_cnt) bg_conf->ionodes_per_mp = bg_conf->mp_nodecard_cnt; #endif for (i=0; i<SYSTEM_DIMENSIONS; i++) bg_conf->default_conn_type[i] = (uint16_t)NO_VAL; s_p_get_string(&tmp_char, "DefaultConnType", tbl); if (tmp_char) { verify_conn_type(tmp_char, bg_conf->default_conn_type); if ((bg_conf->default_conn_type[0] != SELECT_MESH) && (bg_conf->default_conn_type[0] != SELECT_TORUS)) fatal("Can't have a DefaultConnType of %s " "(only Mesh or Torus values are valid).", tmp_char); xfree(tmp_char); } else bg_conf->default_conn_type[0] = SELECT_TORUS; #ifndef HAVE_BG_L_P int first_conn_type = bg_conf->default_conn_type[0]; for (i=1; i<SYSTEM_DIMENSIONS; i++) { if (bg_conf->default_conn_type[i] == (uint16_t)NO_VAL) bg_conf->default_conn_type[i] = first_conn_type; else if (bg_conf->default_conn_type[i] >= SELECT_SMALL) fatal("Can't have a DefaultConnType of %s " "(only Mesh or Torus values are valid).", tmp_char); } #endif if (bg_conf->ionodes_per_mp) { bitstr_t *tmp_bitmap = NULL; int small_size = 1; /* THIS IS A HACK TO MAKE A 1 NODECARD SYSTEM WORK, * Sometime on a Q system the nodecard isn't in the 0 * spot so only do this if you know it is in that * spot. Otherwise say the whole midplane is there * and just make blocks over the whole thing. They * you can error out the blocks that aren't usable. */ if (bg_conf->sub_mp_sys && bg_conf->mp_cnode_cnt == bg_conf->nodecard_cnode_cnt) { #ifdef HAVE_BGQ bg_conf->quarter_ionode_cnt = 1; bg_conf->nodecard_ionode_cnt = 1; #else bg_conf->quarter_ionode_cnt = 2; bg_conf->nodecard_ionode_cnt = 2; #endif } else { bg_conf->quarter_ionode_cnt = bg_conf->ionodes_per_mp/4; bg_conf->nodecard_ionode_cnt = bg_conf->quarter_ionode_cnt/4; } /* How many nodecards per ionode */ bg_conf->nc_ratio = ((double)bg_conf->mp_cnode_cnt / (double)bg_conf->nodecard_cnode_cnt) / (double)bg_conf->ionodes_per_mp; /* How many ionodes per nodecard */ bg_conf->io_ratio = (double)bg_conf->ionodes_per_mp / ((double)bg_conf->mp_cnode_cnt / (double)bg_conf->nodecard_cnode_cnt); /* How many cnodes per ionode */ bg_conf->ionode_cnode_cnt = bg_conf->nodecard_cnode_cnt * bg_conf->nc_ratio; //info("got %f %f", bg_conf->nc_ratio, bg_conf->io_ratio); /* figure out the smallest block we can have on the system */ #ifdef HAVE_BGL if (bg_conf->io_ratio >= 1) bg_conf->smallest_block=32; else bg_conf->smallest_block=128; #else if (bg_conf->io_ratio >= 2) bg_conf->smallest_block=16; else if (bg_conf->io_ratio == 1) bg_conf->smallest_block=32; else if (bg_conf->io_ratio == .5) bg_conf->smallest_block=64; else if (bg_conf->io_ratio == .25) bg_conf->smallest_block=128; else if (bg_conf->io_ratio == .125) bg_conf->smallest_block=256; else { error("unknown ioratio %f. Can't figure out " "smallest block size, setting it to midplane", bg_conf->io_ratio); bg_conf->smallest_block = 512; } #endif if (bg_conf->slurm_debug_flags & DEBUG_FLAG_SELECT_TYPE) info("Smallest block possible on this system is %u", bg_conf->smallest_block); /* below we are creating all the possible bitmaps for * each size of small block */ if ((int)bg_conf->nodecard_ionode_cnt < 1) { bg_conf->nodecard_ionode_cnt = 0; } else { bg_lists->valid_small32 = list_create(_destroy_bitmap); /* This is suppose to be = and not ==, we only want to decrement when small_size equals something. */ if ((small_size = bg_conf->nodecard_ionode_cnt)) small_size--; i = 0; while (i<bg_conf->ionodes_per_mp) { tmp_bitmap = bit_alloc(bg_conf->ionodes_per_mp); bit_nset(tmp_bitmap, i, i+small_size); i += small_size+1; list_append(bg_lists->valid_small32, tmp_bitmap); } } /* If we only have 1 nodecard just jump to the end since this will never need to happen below. Pretty much a hack to avoid seg fault;). */ if (bg_conf->mp_cnode_cnt == bg_conf->nodecard_cnode_cnt) goto no_calc; bg_lists->valid_small128 = list_create(_destroy_bitmap); if ((small_size = bg_conf->quarter_ionode_cnt)) small_size--; i = 0; while (i<bg_conf->ionodes_per_mp) { tmp_bitmap = bit_alloc(bg_conf->ionodes_per_mp); bit_nset(tmp_bitmap, i, i+small_size); i += small_size+1; list_append(bg_lists->valid_small128, tmp_bitmap); } #ifndef HAVE_BGL bg_lists->valid_small64 = list_create(_destroy_bitmap); if ((small_size = bg_conf->nodecard_ionode_cnt * 2)) small_size--; i = 0; while (i<bg_conf->ionodes_per_mp) { tmp_bitmap = bit_alloc(bg_conf->ionodes_per_mp); bit_nset(tmp_bitmap, i, i+small_size); i += small_size+1; list_append(bg_lists->valid_small64, tmp_bitmap); } bg_lists->valid_small256 = list_create(_destroy_bitmap); if ((small_size = bg_conf->quarter_ionode_cnt * 2)) small_size--; i = 0; while (i<bg_conf->ionodes_per_mp) { tmp_bitmap = bit_alloc(bg_conf->ionodes_per_mp); bit_nset(tmp_bitmap, i, i+small_size); i += small_size+1; list_append(bg_lists->valid_small256, tmp_bitmap); } #endif } else { fatal("your ionodes_per_mp is 0"); } no_calc: if (!s_p_get_uint16(&bg_conf->bridge_api_verb, "BridgeAPIVerbose", tbl)) info("Warning: BridgeAPIVerbose not configured " "in bluegene.conf"); if (!s_p_get_string(&bg_conf->bridge_api_file, "BridgeAPILogFile", tbl)) info("BridgeAPILogFile not configured in bluegene.conf"); else _reopen_bridge_log(); if (s_p_get_string(&tmp_char, "DenyPassthrough", tbl)) { if (strstr(tmp_char, "A")) ba_deny_pass |= PASS_DENY_A; if (strstr(tmp_char, "X")) ba_deny_pass |= PASS_DENY_X; if (strstr(tmp_char, "Y")) ba_deny_pass |= PASS_DENY_Y; if (strstr(tmp_char, "Z")) ba_deny_pass |= PASS_DENY_Z; if (!xstrcasecmp(tmp_char, "ALL")) ba_deny_pass |= PASS_DENY_ALL; bg_conf->deny_pass = ba_deny_pass; xfree(tmp_char); } if (!s_p_get_string(&tmp_char, "LayoutMode", tbl)) { info("Warning: LayoutMode was not specified in bluegene.conf " "defaulting to STATIC partitioning"); bg_conf->layout_mode = LAYOUT_STATIC; } else { if (!xstrcasecmp(tmp_char,"STATIC")) bg_conf->layout_mode = LAYOUT_STATIC; else if (!xstrcasecmp(tmp_char,"OVERLAP")) bg_conf->layout_mode = LAYOUT_OVERLAP; else if (!xstrcasecmp(tmp_char,"DYNAMIC")) bg_conf->layout_mode = LAYOUT_DYNAMIC; else { fatal("I don't understand this LayoutMode = %s", tmp_char); } xfree(tmp_char); } /* add blocks defined in file */ if (bg_conf->layout_mode != LAYOUT_DYNAMIC) { if (!s_p_get_array((void ***)&blockreq_array, &count, "MPs", tbl)) { if (!s_p_get_array((void ***)&blockreq_array, &count, "BPs", tbl)) { info("WARNING: no blocks defined in " "bluegene.conf, " "only making full system block"); /* create_full_system_block(NULL); */ if (bg_conf->sub_mp_sys || (bg_conf->mp_cnode_cnt == bg_conf->nodecard_cnode_cnt)) fatal("On a sub-midplane system you " "need to define the blocks you " "want on your system."); } } for (i = 0; i < count; i++) { add_bg_record(bg_lists->main, NULL, blockreq_array[i], 0, 0); } } else if (bg_conf->sub_mp_sys || (bg_conf->mp_cnode_cnt == bg_conf->nodecard_cnode_cnt)) /* we can't do dynamic here on a sub-midplane system */ fatal("On a sub-midplane system we can only do OVERLAP or " "STATIC LayoutMode. Please update your bluegene.conf."); #ifdef HAVE_BGQ if ((bg_recover != NOT_FROM_CONTROLLER) && assoc_mgr_qos_list && s_p_get_string(&tmp_char, "RebootQOSList", tbl)) { bool valid; char *token, *last = NULL; slurmdb_qos_rec_t *qos = NULL; assoc_mgr_lock_t locks = { NO_LOCK, NO_LOCK, NO_LOCK, READ_LOCK, NO_LOCK, NO_LOCK, NO_LOCK }; /* Lock here to avoid g_qos_count changing under us */ assoc_mgr_lock(&locks); bg_conf->reboot_qos_bitmap = bit_alloc(g_qos_count); itr = list_iterator_create(assoc_mgr_qos_list); token = strtok_r(tmp_char, ",", &last); while (token) { valid = false; while((qos = list_next(itr))) { if (!xstrcasecmp(token, qos->name)) { bit_set(bg_conf->reboot_qos_bitmap, qos->id); valid = true; break; } } if (!valid) error("Invalid RebootQOSList value: %s", token); list_iterator_reset(itr); token = strtok_r(NULL, ",", &last); } list_iterator_destroy(itr); xfree(tmp_char); assoc_mgr_unlock(&locks); } #endif s_p_hashtbl_destroy(tbl); return SLURM_SUCCESS; }
/* * read_slurm_cgroup_conf - load the Slurm cgroup configuration from the * cgroup.conf file. * RET SLURM_SUCCESS if no error, otherwise an error code */ extern int read_slurm_cgroup_conf(slurm_cgroup_conf_t *slurm_cgroup_conf) { s_p_options_t options[] = { {"CgroupAutomount", S_P_BOOLEAN}, {"CgroupMountpoint", S_P_STRING}, {"CgroupSubsystems", S_P_STRING}, {"CgroupReleaseAgentDir", S_P_STRING}, {"ConstrainCores", S_P_BOOLEAN}, {"TaskAffinity", S_P_BOOLEAN}, {"ConstrainRAMSpace", S_P_BOOLEAN}, {"AllowedRAMSpace", S_P_STRING}, {"MaxRAMPercent", S_P_STRING}, {"MinRAMSpace", S_P_UINT32}, {"ConstrainSwapSpace", S_P_BOOLEAN}, {"AllowedSwapSpace", S_P_STRING}, {"MaxSwapPercent", S_P_STRING}, {"ConstrainCores", S_P_BOOLEAN}, {"MemoryLimitEnforcement", S_P_BOOLEAN}, {"MemoryLimitThreshold", S_P_STRING}, {"ConstrainDevices", S_P_BOOLEAN}, {"AllowedDevicesFile", S_P_STRING}, {NULL} }; s_p_hashtbl_t *tbl = NULL; char *conf_path = NULL; struct stat buf; /* Set initial values */ if (slurm_cgroup_conf == NULL) { return SLURM_ERROR; } _clear_slurm_cgroup_conf(slurm_cgroup_conf); /* Get the cgroup.conf path and validate the file */ conf_path = get_extra_conf_path("cgroup.conf"); if ((conf_path == NULL) || (stat(conf_path, &buf) == -1)) { debug2("%s: No cgroup.conf file (%s)", __func__, conf_path); } else { debug("Reading cgroup.conf file %s", conf_path); tbl = s_p_hashtbl_create(options); if (s_p_parse_file(tbl, NULL, conf_path, false) == SLURM_ERROR) { fatal("Could not open/read/parse cgroup.conf file %s", conf_path); } /* cgroup initialisation parameters */ if (!s_p_get_boolean(&slurm_cgroup_conf->cgroup_automount, "CgroupAutomount", tbl)) slurm_cgroup_conf->cgroup_automount = false; if (!s_p_get_string(&slurm_cgroup_conf->cgroup_mountpoint, "CgroupMountpoint", tbl)) slurm_cgroup_conf->cgroup_mountpoint = xstrdup(DEFAULT_CGROUP_BASEDIR); s_p_get_string(&slurm_cgroup_conf->cgroup_subsystems, "CgroupSubsystems", tbl); s_p_get_string(&slurm_cgroup_conf->cgroup_release_agent, "CgroupReleaseAgentDir", tbl); if (! slurm_cgroup_conf->cgroup_release_agent) slurm_cgroup_conf->cgroup_release_agent = xstrdup("/etc/slurm/cgroup"); /* cgroup prepend directory */ #ifndef MULTIPLE_SLURMD slurm_cgroup_conf->cgroup_prepend = xstrdup("/slurm"); #else slurm_cgroup_conf->cgroup_prepend = xstrdup("/slurm_%n"); #endif /* Cores constraints related conf items */ if (!s_p_get_boolean(&slurm_cgroup_conf->constrain_cores, "ConstrainCores", tbl)) slurm_cgroup_conf->constrain_cores = false; if (!s_p_get_boolean(&slurm_cgroup_conf->task_affinity, "TaskAffinity", tbl)) slurm_cgroup_conf->task_affinity = false; /* RAM and Swap constraints related conf items */ if (!s_p_get_boolean(&slurm_cgroup_conf->constrain_ram_space, "ConstrainRAMSpace", tbl)) slurm_cgroup_conf->constrain_ram_space = false; conf_get_float (tbl, "AllowedRAMSpace", &slurm_cgroup_conf->allowed_ram_space); conf_get_float (tbl, "MaxRAMPercent", &slurm_cgroup_conf->max_ram_percent); if (!s_p_get_boolean(&slurm_cgroup_conf->constrain_swap_space, "ConstrainSwapSpace", tbl)) slurm_cgroup_conf->constrain_swap_space = false; conf_get_float (tbl, "AllowedSwapSpace", &slurm_cgroup_conf->allowed_swap_space); conf_get_float (tbl, "MaxSwapPercent", &slurm_cgroup_conf->max_swap_percent); s_p_get_uint32 (&slurm_cgroup_conf->min_ram_space, "MinRAMSpace", tbl); /* Memory limits */ if (!s_p_get_boolean(&slurm_cgroup_conf->memlimit_enforcement, "MemoryLimitEnforcement", tbl)) slurm_cgroup_conf->memlimit_enforcement = false; conf_get_float (tbl, "MemoryLimitThreshold", &slurm_cgroup_conf->memlimit_threshold); /* Devices constraint related conf items */ if (!s_p_get_boolean(&slurm_cgroup_conf->constrain_devices, "ConstrainDevices", tbl)) slurm_cgroup_conf->constrain_devices = false; s_p_get_string(&slurm_cgroup_conf->allowed_devices_file, "AllowedDevicesFile", tbl); if (! slurm_cgroup_conf->allowed_devices_file) slurm_cgroup_conf->allowed_devices_file = xstrdup("/etc/slurm/cgroup_allowed_devices_file.conf"); s_p_hashtbl_destroy(tbl); } xfree(conf_path); return SLURM_SUCCESS; }
/* 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); } }
/* 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); } }
int init() { int i,number_of_lines=0; char *config,*tmp=NULL; char line[LINE_SIZE],feature[50],keyword[50]; FILE * fr; int number_of_features=0,number_of_users=0; config=get_extra_conf_path("job_sane.conf"); info("job_sane:Trying to read configuration file %s",config); fr = fopen (config, "r"); if(fr==NULL) fatal("job_sane:Cannot open configuration file"); info("job_sane:counting lines"); while (fgets(line,LINE_SIZE,fr)!=NULL) number_of_lines++; info("job_sane:count:%d",number_of_lines); fseek(fr, 0, SEEK_SET); //TODO //This is very ugly solution and obviously it's waisting memory //number_of_lines=number_of_users+number_of_features // // tags=(char**)xmalloc(sizeof(char *) * (number_of_lines+1)); cores=xmalloc(sizeof(int)*number_of_lines); users=xmalloc(sizeof(int) * (number_of_lines+1)); for (i=0;i<number_of_lines;i++) { fgets(line,LINE_SIZE,fr); sscanf(line,"%s",&keyword); if(!strcmp(keyword,"feature")) { sscanf(line,"%*s %s %d",&feature,&cores[i]); debug("job_sane:feature=%s cores=%d",feature,cores[i]); tags[number_of_features]=xmalloc(sizeof(char)*(strlen(feature)+1)); strcpy(tags[number_of_features],feature); number_of_features++; } else if(!strcmp(keyword,"user")) { struct passwd* userData; sscanf(line,"%*s %s",feature); int uid=getpwnam(feature)->pw_uid; if ( uid==0 ) { debug("job_sane: user_name=root cannot be added to the accepted users - root is always accepted."); continue; } users[number_of_users]=uid; debug("job_sane:user_name=%s adding to accepted users with uid=%d",feature,users[number_of_users]); number_of_users++; } else { error("job_sane:Unknown option in configuration file :%s",keyword); } } tags[number_of_features]=NULL; users[number_of_users]=0; fclose(fr); info("job_sane initialization finished"); return SLURM_SUCCESS; }