/*
* Check if server sent a BYE response (connection is closed immediately).
*/
int
check_bye(char *buf)
{
if (xstrcasestr(buf, "* BYE") &&
!xstrcasestr(buf, " LOGOUT "))
return 1;
else
return 0;
}
/*
* Add, remove or replace the specified flags of the messages.
*/
int
request_store(const char *server, const char *port, const char *user,
const char *mesg, const char *mode, const char *flags)
{
int t, r;
session *s;
if (!(s = session_find(server, port, user)))
return -1;
t = imap_store(s, mesg, mode, flags);
if ((r = response_generic(s, t)) == -1)
goto fail;
if (xstrcasestr(flags, "\\Deleted") && get_option_boolean("expunge"))
if (response_generic(s, imap_expunge(s)) == -1)
goto fail;
return r;
fail:
close_connection(s);
session_destroy(s);
return -1;
}
static uint32_t _str_2_cluster_flags(char *flags_in)
{
if (xstrcasestr(flags_in, "AlpsCray")
|| xstrcasestr(flags_in, "CrayXT"))
return CLUSTER_FLAG_CRAY_A;
if (xstrcasestr(flags_in, "FrontEnd"))
return CLUSTER_FLAG_FE;
if (xstrcasestr(flags_in, "MultipleSlurmd"))
return CLUSTER_FLAG_MULTSD;
if (xstrcasestr(flags_in, "Cray"))
return CLUSTER_FLAG_CRAY_N;
return (uint32_t) 0;
}
static int _slurm_mcs_check_and_load_select(char *params)
{
select_value = MCS_SELECT_ONDEMANDSELECT;
if (params == NULL) {
return SLURM_SUCCESS;
}
if (xstrcasestr(params, "noselect")) {
select_value = MCS_SELECT_NOSELECT;
} else if (xstrcasestr(params, "ondemandselect")) {
select_value = MCS_SELECT_ONDEMANDSELECT;
} else if (xstrcasestr(params, "select")) {
select_value = MCS_SELECT_SELECT;
} else {
info("mcs: MCSParameters = %s. ondemandselect set.", params);
}
return SLURM_SUCCESS;
}
/*
* Check if server sent a PREAUTH response (connection already authenticated
* by external means).
*/
int
check_preauth(char *buf)
{
if (xstrcasestr(ibuf.data, "* PREAUTH"))
return 1;
else
return 0;
}
static int _slurm_mcs_check_and_load_enforced(char *params)
{
label_strict_enforced = false;
if ((params != NULL) && xstrcasestr(params, "enforced"))
label_strict_enforced = true;
else
info("mcs: MCSParameters = %s. ondemand set.", params);
return SLURM_SUCCESS;
}
/*
* Check if the server sent a TRYCREATE response.
*/
int
check_trycreate(char *buf)
{
if (xstrcasestr(buf, "[TRYCREATE]"))
return 1;
else
return 0;
}
/*
* Check if the server sent a continuation request.
*/
int
check_continuation(char *buf)
{
if ((buf[0] == '+' && buf[1] == ' ') || xstrcasestr(buf, "\r\n+ "))
return 1;
else
return 0;
}
extern int init(void)
{
char *sched_params;
verbose("preempt/partition_prio loaded");
sched_params = slurm_get_sched_params();
if (xstrcasestr(sched_params, "preempt_youngest_first"))
youngest_order = true;
xfree(sched_params);
return SLURM_SUCCESS;
}
/*
* Process the data that server sent due to IMAP SELECT client request.
*/
int
response_select(session *ssn, int tag)
{
int r;
if ((r = response_generic(ssn, tag)) == -1)
return -1;
if (xstrcasestr(ibuf.data, "[READ-ONLY]"))
return STATUS_RESPONSE_READONLY;
return r;
}
static int _slurm_mcs_check_and_load_privatedata(char *params)
{
if (params == NULL) {
private_data = false;
return SLURM_SUCCESS;
}
if (xstrcasestr(params, "privatedata")) {
private_data = true;
} else {
private_data = false;
}
return SLURM_SUCCESS;
}
extern int acct_gather_parse_freq(int type, char *freq)
{
int freq_int = -1;
char *sub_str = NULL;
if (!freq)
return freq_int;
switch (type) {
case PROFILE_ENERGY:
if ((sub_str = xstrcasestr(freq, "energy=")))
freq_int = _get_int(sub_str + 7);
break;
case PROFILE_TASK:
/* backwards compatibility for when the freq was only
for task.
*/
freq_int = _get_int(freq);
if ((freq_int == -1)
&& (sub_str = xstrcasestr(freq, "task=")))
freq_int = _get_int(sub_str + 5);
break;
case PROFILE_FILESYSTEM:
if ((sub_str = xstrcasestr(freq, "filesystem=")))
freq_int = _get_int(sub_str + 11);
break;
case PROFILE_NETWORK:
if ((sub_str = xstrcasestr(freq, "network=")))
freq_int = _get_int(sub_str + 8);
break;
default:
fatal("Unhandled profile option %d please update "
"slurm_acct_gather.c "
"(acct_gather_parse_freq)", type);
}
return freq_int;
}
/*
* Process the data that server sent due to IMAP SELECT client request.
*/
int
response_select(session *ssn, int tag)
{
int r;
r = response_generic(ssn, tag);
if (r == -1 || r == STATUS_BYE)
return r;
if (xstrcasestr(ibuf.data, "[READ-ONLY]"))
return STATUS_READONLY;
return r;
}
/*
* Process the data that server sent due to IMAP CAPABILITY client request.
*/
int
response_capability(session *ssn, int tag)
{
int r;
char *s;
regexp *re;
r = response_generic(ssn, tag);
if (r == -1 || r == STATUS_BYE)
return r;
ssn->protocol = PROTOCOL_NONE;
re = &responses[RESPONSE_CAPABILITY];
if (!regexec(re->preg, ibuf.data, re->nmatch, re->pmatch, 0)) {
s = xstrndup(ibuf.data + re->pmatch[1].rm_so,
re->pmatch[1].rm_eo - re->pmatch[1].rm_so);
if (xstrcasestr(s, "IMAP4rev1"))
ssn->protocol = PROTOCOL_IMAP4REV1;
else if (xstrcasestr(s, "IMAP4"))
ssn->protocol = PROTOCOL_IMAP4;
else {
error("server supports neither the IMAP4rev1 nor the "
"IMAP4 protocol\n");
return -1;
}
ssn->capabilities = CAPABILITY_NONE;
if (xstrcasestr(s, "NAMESPACE"))
ssn->capabilities |= CAPABILITY_NAMESPACE;
if (xstrcasestr(s, "AUTH=CRAM-MD5"))
ssn->capabilities |= CAPABILITY_CRAMMD5;
if (xstrcasestr(s, "STARTTLS"))
ssn->capabilities |= CAPABILITY_STARTTLS;
if (xstrcasestr(s, "CHILDREN"))
ssn->capabilities |= CAPABILITY_CHILDREN;
if (xstrcasestr(s, "IDLE"))
ssn->capabilities |= CAPABILITY_IDLE;
xfree(s);
}
return r;
}
/*
* Add, remove or replace the specified flags of the messages.
*/
int
request_store(session *ssn, const char *mesg, const char *mode, const char
*flags)
{
int t, r;
TRY(t = send_request(ssn, "UID STORE %s %sFLAGS.SILENT (%s)", mesg,
(!strncasecmp(mode, "add", 3) ? "+" :
!strncasecmp(mode, "remove", 6) ? "-" : ""), flags));
TRY(r = response_generic(ssn, t));
if (xstrcasestr(flags, "\\Deleted") && get_option_boolean("expunge")) {
TRY(t = send_request(ssn, "EXPUNGE"));
TRY(response_generic(ssn, t));
}
return r;
}
/*
* Process the greeting that server sends during connection.
*/
int
response_greeting(session *ssn)
{
buffer_reset(&ibuf);
if (receive_response(ssn, ibuf.data) == -1)
return -1;
if (check_bye(ibuf.data))
return -1;
verbose("S (%d): %s", ssn->socket, ibuf.data);
if (xstrcasestr(ibuf.data, "* PREAUTH"))
return STATUS_RESPONSE_PREAUTH;
return STATUS_RESPONSE_NONE;
}
static void _set_inv_interval(void)
{
char *tmp_ptr, *sched_params = slurm_get_sched_params();
int i;
if (sched_params) {
if (sched_params &&
(tmp_ptr = xstrcasestr(sched_params,
"inventory_interval="))) {
/* 0123456789012345 */
i = atoi(tmp_ptr + 19);
if (i < 0)
error("ignoring SchedulerParameters: "
"inventory_interval of %d", i);
else
inv_interval = i;
}
xfree(sched_params);
}
}
extern uint32_t acct_gather_profile_from_string(char *profile_str)
{
uint32_t profile = ACCT_GATHER_PROFILE_NOT_SET;
if (!profile_str) {
} else if (xstrcasestr(profile_str, "none"))
profile = ACCT_GATHER_PROFILE_NONE;
else if (xstrcasestr(profile_str, "all"))
profile = ACCT_GATHER_PROFILE_ALL;
else {
if (xstrcasestr(profile_str, "energy"))
profile |= ACCT_GATHER_PROFILE_ENERGY;
if (xstrcasestr(profile_str, "task"))
profile |= ACCT_GATHER_PROFILE_TASK;
if (xstrcasestr(profile_str, "lustre"))
profile |= ACCT_GATHER_PROFILE_LUSTRE;
if (xstrcasestr(profile_str, "network"))
profile |= ACCT_GATHER_PROFILE_NETWORK;
}
return profile;
}
static void _handle_stats(List prec_list, char *proc_stat_file,
char *proc_io_file, char *proc_smaps_file,
jag_callbacks_t *callbacks,
int tres_count)
{
static int no_share_data = -1;
static int use_pss = -1;
FILE *stat_fp = NULL;
FILE *io_fp = NULL;
int fd, fd2, i;
jag_prec_t *prec = NULL;
if (no_share_data == -1) {
char *acct_params = slurm_get_jobacct_gather_params();
if (acct_params && xstrcasestr(acct_params, "NoShare"))
no_share_data = 1;
else
no_share_data = 0;
if (acct_params && xstrcasestr(acct_params, "UsePss"))
use_pss = 1;
else
use_pss = 0;
xfree(acct_params);
}
if (!(stat_fp = fopen(proc_stat_file, "r")))
return; /* Assume the process went away */
/*
* Close the file on exec() of user tasks.
*
* NOTE: If we fork() slurmstepd after the
* fopen() above and before the fcntl() below,
* then the user task may have this extra file
* open, which can cause problems for
* checkpoint/restart, but this should be a very rare
* problem in practice.
*/
fd = fileno(stat_fp);
if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
error("%s: fcntl(%s): %m", __func__, proc_stat_file);
prec = xmalloc(sizeof(jag_prec_t));
if (!tres_count) {
assoc_mgr_lock_t locks = {
NO_LOCK, NO_LOCK, NO_LOCK, NO_LOCK,
READ_LOCK, NO_LOCK, NO_LOCK };
assoc_mgr_lock(&locks);
tres_count = g_tres_count;
assoc_mgr_unlock(&locks);
}
prec->tres_count = tres_count;
prec->tres_data = xmalloc(prec->tres_count *
sizeof(acct_gather_data_t));
/* Initialize read/writes */
for (i = 0; i < prec->tres_count; i++) {
prec->tres_data[i].num_reads = INFINITE64;
prec->tres_data[i].num_writes = INFINITE64;
prec->tres_data[i].size_read = INFINITE64;
prec->tres_data[i].size_write = INFINITE64;
}
if (!_get_process_data_line(fd, prec)) {
xfree(prec->tres_data);
xfree(prec);
fclose(stat_fp);
return;
}
fclose(stat_fp);
if (acct_gather_filesystem_g_get_data(prec->tres_data) < 0) {
debug2("problem retrieving filesystem data");
}
if (acct_gather_interconnect_g_get_data(prec->tres_data) < 0) {
debug2("problem retrieving interconnect data");
}
/* Remove shared data from rss */
if (no_share_data)
_remove_share_data(proc_stat_file, prec);
/* Use PSS instead if RSS */
if (use_pss) {
if (_get_pss(proc_smaps_file, prec) == -1) {
xfree(prec->tres_data);
xfree(prec);
return;
}
}
list_append(prec_list, prec);
if ((io_fp = fopen(proc_io_file, "r"))) {
fd2 = fileno(io_fp);
if (fcntl(fd2, F_SETFD, FD_CLOEXEC) == -1)
error("%s: fcntl: %m", __func__);
_get_process_io_data_line(fd2, prec);
fclose(io_fp);
}
}
extern void jag_common_poll_data(
List task_list, bool pgid_plugin, uint64_t cont_id,
jag_callbacks_t *callbacks, bool profile)
{
/* Update the data */
List prec_list = NULL;
uint64_t total_job_mem = 0, total_job_vsize = 0;
ListIterator itr;
jag_prec_t *prec = NULL;
struct jobacctinfo *jobacct = NULL;
static int processing = 0;
char sbuf[72];
int energy_counted = 0;
time_t ct;
static int no_over_memory_kill = -1;
xassert(callbacks);
if (!pgid_plugin && (cont_id == NO_VAL64)) {
debug("cont_id hasn't been set yet not running poll");
return;
}
if (processing) {
debug("already running, returning");
return;
}
processing = 1;
if (no_over_memory_kill == -1) {
char *acct_params = slurm_get_jobacct_gather_params();
if (acct_params && xstrcasestr(acct_params, "NoOverMemoryKill"))
no_over_memory_kill = 1;
else
no_over_memory_kill = 0;
xfree(acct_params);
}
if (!callbacks->get_precs)
callbacks->get_precs = _get_precs;
ct = time(NULL);
prec_list = (*(callbacks->get_precs))(task_list, pgid_plugin, cont_id,
callbacks);
if (!list_count(prec_list) || !task_list || !list_count(task_list))
goto finished; /* We have no business being here! */
itr = list_iterator_create(task_list);
while ((jobacct = list_next(itr))) {
double cpu_calc;
double last_total_cputime;
if (!(prec = list_find_first(prec_list, _find_prec, jobacct)))
continue;
#if _DEBUG
info("pid:%u ppid:%u rss:%d KB",
prec->pid, prec->ppid, prec->rss);
#endif
/* find all my descendents */
if (callbacks->get_offspring_data)
(*(callbacks->get_offspring_data))
(prec_list, prec, prec->pid);
last_total_cputime = jobacct->tot_cpu;
cpu_calc = (double)(prec->ssec + prec->usec)/(double)hertz;
/* tally their usage */
jobacct->max_rss =
MAX(jobacct->max_rss, prec->rss);
jobacct->tot_rss = prec->rss;
total_job_mem += prec->rss;
jobacct->max_vsize =
MAX(jobacct->max_vsize, prec->vsize);
jobacct->tot_vsize = prec->vsize;
total_job_vsize += prec->vsize;
jobacct->max_pages =
MAX(jobacct->max_pages, prec->pages);
jobacct->tot_pages = prec->pages;
jobacct->max_disk_read = MAX(
jobacct->max_disk_read,
prec->disk_read);
jobacct->tot_disk_read = prec->disk_read;
jobacct->max_disk_write = MAX(
jobacct->max_disk_write,
prec->disk_write);
jobacct->tot_disk_write = prec->disk_write;
jobacct->min_cpu =
MAX((double)jobacct->min_cpu, cpu_calc);
/* Update the cpu times
*/
jobacct->tot_cpu = cpu_calc;
jobacct->user_cpu_sec = prec->usec/hertz;
jobacct->sys_cpu_sec = prec->ssec/hertz;
debug2("%s: %d mem size %"PRIu64" %"PRIu64" "
"time %f(%u+%u)", __func__,
jobacct->pid, jobacct->max_rss,
jobacct->max_vsize, jobacct->tot_cpu,
jobacct->user_cpu_sec,
jobacct->sys_cpu_sec);
/* compute frequency */
jobacct->this_sampled_cputime =
cpu_calc - last_total_cputime;
_get_sys_interface_freq_line(
prec->last_cpu,
"cpuinfo_cur_freq", sbuf);
jobacct->act_cpufreq =
_update_weighted_freq(jobacct, sbuf);
debug("%s: Task average frequency = %u "
"pid %d mem size %"PRIu64" %"PRIu64" "
"time %f(%u+%u)", __func__,
jobacct->act_cpufreq,
jobacct->pid, jobacct->max_rss,
jobacct->max_vsize, jobacct->tot_cpu,
jobacct->user_cpu_sec,
jobacct->sys_cpu_sec);
/* get energy consumption
* only once is enough since we
* report per node energy consumption */
debug2("energycounted = %d", energy_counted);
if (energy_counted == 0) {
acct_gather_energy_g_get_data(
energy_profile,
&jobacct->energy);
debug2("getjoules_task energy = %"PRIu64,
jobacct->energy.consumed_energy);
energy_counted = 1;
}
if (profile &&
acct_gather_profile_g_is_active(ACCT_GATHER_PROFILE_TASK)) {
jobacct->cur_time = ct;
_record_profile(jobacct);
jobacct->last_tot_disk_read = jobacct->tot_disk_read;
jobacct->last_tot_disk_write = jobacct->tot_disk_write;
jobacct->last_total_cputime = jobacct->tot_cpu;
jobacct->last_time = jobacct->cur_time;
}
}
list_iterator_destroy(itr);
if (!no_over_memory_kill)
jobacct_gather_handle_mem_limit(total_job_mem, total_job_vsize);
finished:
FREE_NULL_LIST(prec_list);
processing = 0;
}
/*
* 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;
}
/*
* Process the data that server sent due to IMAP LIST or IMAP LSUB client
* request.
*/
int
response_list(session *ssn, int tag, char **mboxs, char **folders)
{
int r, n;
char *b, *a, *s, *m, *f;
const char *v;
regexp *re;
r = response_generic(ssn, tag);
if (r == -1 || r == STATUS_BYE)
return r;
m = *mboxs = (char *)xmalloc((ibuf.len + 1) * sizeof(char));
f = *folders = (char *)xmalloc((ibuf.len + 1) * sizeof(char));
*m = *f = '\0';
re = &responses[RESPONSE_LIST];
b = ibuf.data;
while (!regexec(re->preg, b, re->nmatch, re->pmatch, 0)) {
a = xstrndup(b + re->pmatch[2].rm_so,
re->pmatch[2].rm_eo - re->pmatch[2].rm_so);
if (re->pmatch[5].rm_so != -1 && re->pmatch[5].rm_so != -1)
s = xstrndup(b + re->pmatch[5].rm_so,
re->pmatch[5].rm_eo - re->pmatch[5].rm_so);
else if (re->pmatch[6].rm_so != -1 &&
re->pmatch[6].rm_so != -1)
s = xstrndup(b + re->pmatch[6].rm_so,
re->pmatch[6].rm_eo - re->pmatch[6].rm_so);
else
s = xstrndup(b + re->pmatch[8].rm_so, strtoul(b +
re->pmatch[7].rm_so, NULL, 10));
v = reverse_namespace(s, ssn->ns.prefix, ssn->ns.delim);
n = strlen(v);
if (!xstrcasestr(a, "\\NoSelect")) {
xstrncpy(m, v, ibuf.len - (m - *mboxs));
m += n;
xstrncpy(m, "\n", ibuf.len - (m - *mboxs));
m += strlen("\n");
}
if (!xstrcasestr(a, "\\NoInferiors") &&
(!(ssn->capabilities & CAPABILITY_CHILDREN) ||
((ssn->capabilities & CAPABILITY_CHILDREN) &&
(xstrcasestr(a, "\\HasChildren")) &&
!xstrcasestr(a, "\\HasNoChildren")))) {
xstrncpy(f, v, ibuf.len - (f - *folders));
f += n;
xstrncpy(f, "\n", ibuf.len - (f - *folders));
f += strlen("\n");
}
b += re->pmatch[0].rm_eo;
xfree(a);
xfree(s);
}
return r;
}
static void _handle_stats(List prec_list, char *proc_stat_file, char *proc_io_file,
char *proc_smaps_file, jag_callbacks_t *callbacks)
{
static int no_share_data = -1;
static int use_pss = -1;
FILE *stat_fp = NULL;
FILE *io_fp = NULL;
int fd, fd2;
jag_prec_t *prec = NULL;
if (no_share_data == -1) {
char *acct_params = slurm_get_jobacct_gather_params();
if (acct_params && xstrcasestr(acct_params, "NoShare"))
no_share_data = 1;
else
no_share_data = 0;
if (acct_params && xstrcasestr(acct_params, "UsePss"))
use_pss = 1;
else
use_pss = 0;
xfree(acct_params);
}
if (!(stat_fp = fopen(proc_stat_file, "r")))
return; /* Assume the process went away */
/*
* Close the file on exec() of user tasks.
*
* NOTE: If we fork() slurmstepd after the
* fopen() above and before the fcntl() below,
* then the user task may have this extra file
* open, which can cause problems for
* checkpoint/restart, but this should be a very rare
* problem in practice.
*/
fd = fileno(stat_fp);
if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
error("%s: fcntl(%s): %m", __func__, proc_stat_file);
prec = try_xmalloc(sizeof(jag_prec_t));
if (prec == NULL) { /* Avoid killing slurmstepd on malloc failure */
fclose(stat_fp);
return;
}
if (!_get_process_data_line(fd, prec)) {
xfree(prec);
fclose(stat_fp);
return;
}
fclose(stat_fp);
/* Remove shared data from rss */
if (no_share_data)
_remove_share_data(proc_stat_file, prec);
/* Use PSS instead if RSS */
if (use_pss) {
if (_get_pss(proc_smaps_file, prec) == -1) {
xfree(prec);
return;
}
}
list_append(prec_list, prec);
if ((io_fp = fopen(proc_io_file, "r"))) {
fd2 = fileno(io_fp);
if (fcntl(fd2, F_SETFD, FD_CLOEXEC) == -1)
error("%s: fcntl: %m", __func__);
_get_process_io_data_line(fd2, prec);
fclose(io_fp);
}
if (callbacks->prec_extra)
(*(callbacks->prec_extra))(prec);
}
