/* main - slurmctld main function, start various threads and process RPCs */
int main(int argc, char *argv[])
{
pthread_attr_t thread_attr;
char node_name[128];
void *db_conn = NULL;
assoc_init_args_t assoc_init_arg;
_init_config();
log_init(argv[0], log_opts, LOG_DAEMON, NULL);
if (read_slurmdbd_conf())
exit(1);
_parse_commandline(argc, argv);
_update_logging(true);
_update_nice();
if (slurm_auth_init(NULL) != SLURM_SUCCESS) {
fatal("Unable to initialize %s authentication plugin",
slurmdbd_conf->auth_type);
}
if (slurm_acct_storage_init(NULL) != SLURM_SUCCESS) {
fatal("Unable to initialize %s accounting storage plugin",
slurmdbd_conf->storage_type);
}
_kill_old_slurmdbd();
if (foreground == 0)
_daemonize();
/*
* Need to create pidfile here in case we setuid() below
* (init_pidfile() exits if it can't initialize pid file).
* On Linux we also need to make this setuid job explicitly
* able to write a core dump.
* This also has to happen after daemon(), which closes all fd's,
* so we keep the write lock of the pidfile.
*/
_init_pidfile();
_become_slurm_user();
if (foreground == 0)
_set_work_dir();
log_config();
#ifdef PR_SET_DUMPABLE
if (prctl(PR_SET_DUMPABLE, 1) < 0)
debug ("Unable to set dumpable to 1");
#endif /* PR_SET_DUMPABLE */
if (xsignal_block(dbd_sigarray) < 0)
error("Unable to block signals");
/* Create attached thread for signal handling */
slurm_attr_init(&thread_attr);
if (pthread_create(&signal_handler_thread, &thread_attr,
_signal_handler, NULL))
fatal("pthread_create %m");
slurm_attr_destroy(&thread_attr);
registered_clusters = list_create(NULL);
slurm_attr_init(&thread_attr);
if (pthread_create(&commit_handler_thread, &thread_attr,
_commit_handler, NULL))
fatal("pthread_create %m");
slurm_attr_destroy(&thread_attr);
memset(&assoc_init_arg, 0, sizeof(assoc_init_args_t));
/* If we are tacking wckey we need to cache
wckeys, if we aren't only cache the users, qos */
assoc_init_arg.cache_level = ASSOC_MGR_CACHE_USER | ASSOC_MGR_CACHE_QOS;
if (slurmdbd_conf->track_wckey)
assoc_init_arg.cache_level |= ASSOC_MGR_CACHE_WCKEY;
db_conn = acct_storage_g_get_connection(NULL, 0, true, NULL);
if (assoc_mgr_init(db_conn, &assoc_init_arg, errno) == SLURM_ERROR) {
error("Problem getting cache of data");
acct_storage_g_close_connection(&db_conn);
goto end_it;
}
if (gethostname_short(node_name, sizeof(node_name)))
fatal("getnodename: %m");
while (1) {
if (slurmdbd_conf->dbd_backup &&
(!strcmp(node_name, slurmdbd_conf->dbd_backup) ||
!strcmp(slurmdbd_conf->dbd_backup, "localhost"))) {
info("slurmdbd running in background mode");
have_control = false;
backup = true;
/* make sure any locks are released */
acct_storage_g_commit(db_conn, 1);
run_dbd_backup();
if (!shutdown_time)
assoc_mgr_refresh_lists(db_conn);
} else if (slurmdbd_conf->dbd_host &&
(!strcmp(slurmdbd_conf->dbd_host, node_name) ||
!strcmp(slurmdbd_conf->dbd_host, "localhost"))) {
backup = false;
have_control = true;
} else {
fatal("This host not configured to run SlurmDBD "
"(%s != %s | (backup) %s)",
node_name, slurmdbd_conf->dbd_host,
slurmdbd_conf->dbd_backup);
}
if (!shutdown_time) {
/* Create attached thread to process incoming RPCs */
slurm_attr_init(&thread_attr);
if (pthread_create(&rpc_handler_thread, &thread_attr,
rpc_mgr, NULL))
fatal("pthread_create error %m");
slurm_attr_destroy(&thread_attr);
}
if (!shutdown_time) {
/* Create attached thread to do usage rollup */
slurm_attr_init(&thread_attr);
if (pthread_create(&rollup_handler_thread,
&thread_attr,
_rollup_handler, db_conn))
fatal("pthread_create error %m");
slurm_attr_destroy(&thread_attr);
}
/* Daemon is fully operational here */
if (!shutdown_time || primary_resumed) {
shutdown_time = 0;
info("slurmdbd version %s started",
SLURM_VERSION_STRING);
if (backup)
run_dbd_backup();
}
_request_registrations(db_conn);
acct_storage_g_commit(db_conn, 1);
/* this is only ran if not backup */
if (rollup_handler_thread)
pthread_join(rollup_handler_thread, NULL);
if (rpc_handler_thread)
pthread_join(rpc_handler_thread, NULL);
if (backup && primary_resumed) {
shutdown_time = 0;
info("Backup has given up control");
}
if (shutdown_time)
break;
}
/* Daemon termination handled here */
end_it:
if (signal_handler_thread)
pthread_join(signal_handler_thread, NULL);
if (commit_handler_thread)
pthread_join(commit_handler_thread, NULL);
acct_storage_g_commit(db_conn, 1);
acct_storage_g_close_connection(&db_conn);
if (slurmdbd_conf->pid_file &&
(unlink(slurmdbd_conf->pid_file) < 0)) {
verbose("Unable to remove pidfile '%s': %m",
slurmdbd_conf->pid_file);
}
FREE_NULL_LIST(registered_clusters);
assoc_mgr_fini(NULL);
slurm_acct_storage_fini();
slurm_auth_fini();
log_fini();
free_slurmdbd_conf();
exit(0);
}
/*
* Read the slurm configuration file (slurm.conf) and substitute some
* values into the slurmd configuration in preference of the defaults.
*/
static void
_read_config(void)
{
char *path_pubkey = NULL;
slurm_ctl_conf_t *cf = NULL;
uint16_t tmp16 = 0;
#ifndef HAVE_FRONT_END
bool cr_flag = false, gang_flag = false;
#endif
cf = slurm_conf_lock();
slurm_mutex_lock(&conf->config_mutex);
if (conf->conffile == NULL)
conf->conffile = xstrdup(cf->slurm_conf);
conf->slurm_user_id = cf->slurm_user_id;
conf->cr_type = cf->select_type_param;
path_pubkey = xstrdup(cf->job_credential_public_certificate);
if (!conf->logfile)
conf->logfile = xstrdup(cf->slurmd_logfile);
#ifndef HAVE_FRONT_END
if (!strcmp(cf->select_type, "select/cons_res"))
cr_flag = true;
if (cf->preempt_mode & PREEMPT_MODE_GANG)
gang_flag = true;
#endif
slurm_conf_unlock();
/* node_name may already be set from a command line parameter */
if (conf->node_name == NULL)
conf->node_name = slurm_conf_get_nodename(conf->hostname);
/* if we didn't match the form of the hostname already
* stored in conf->hostname, check to see if we match any
* valid aliases */
if (conf->node_name == NULL)
conf->node_name = slurm_conf_get_aliased_nodename();
if (conf->node_name == NULL)
conf->node_name = slurm_conf_get_nodename("localhost");
if (conf->node_name == NULL)
fatal("Unable to determine this slurmd's NodeName");
_massage_pathname(&conf->logfile);
/* set node_addr if relevant */
if ((conf->node_addr == NULL) &&
(conf->node_addr = slurm_conf_get_nodeaddr(conf->hostname)) &&
(strcmp(conf->node_addr, conf->hostname) == 0)) {
xfree(conf->node_addr); /* Sets to NULL */
}
conf->port = slurm_conf_get_port(conf->node_name);
slurm_conf_get_cpus_bsct(conf->node_name,
&conf->conf_cpus, &conf->conf_boards,
&conf->conf_sockets, &conf->conf_cores,
&conf->conf_threads);
/* store hardware properties in slurmd_config */
xfree(conf->block_map);
xfree(conf->block_map_inv);
_update_logging();
_update_nice();
get_cpuinfo(&conf->actual_cpus,
&conf->actual_boards,
&conf->actual_sockets,
&conf->actual_cores,
&conf->actual_threads,
&conf->block_map_size,
&conf->block_map, &conf->block_map_inv);
#ifdef HAVE_FRONT_END
/*
* When running with multiple frontends, the slurmd S:C:T values are not
* relevant, hence ignored by both _register_front_ends (sets all to 1)
* and validate_nodes_via_front_end (uses slurm.conf values).
* Report actual hardware configuration, irrespective of FastSchedule.
*/
conf->cpus = conf->actual_cpus;
conf->boards = conf->actual_boards;
conf->sockets = conf->actual_sockets;
conf->cores = conf->actual_cores;
conf->threads = conf->actual_threads;
#else
/* If the actual resources on a node differ than what is in
* the configuration file and we are using
* cons_res or gang scheduling we have to use what is in the
* configuration file because the slurmctld creates bitmaps
* for scheduling before these nodes check in.
*/
if (((cf->fast_schedule == 0) && !cr_flag && !gang_flag) ||
((cf->fast_schedule == 1) &&
(conf->actual_cpus < conf->conf_cpus))) {
conf->cpus = conf->actual_cpus;
conf->boards = conf->actual_boards;
conf->sockets = conf->actual_sockets;
conf->cores = conf->actual_cores;
conf->threads = conf->actual_threads;
} else {
conf->cpus = conf->conf_cpus;
conf->boards = conf->conf_boards;
conf->sockets = conf->conf_sockets;
conf->cores = conf->conf_cores;
conf->threads = conf->conf_threads;
}
if ((conf->cpus != conf->actual_cpus) ||
(conf->sockets != conf->actual_sockets) ||
(conf->cores != conf->actual_cores) ||
(conf->threads != conf->actual_threads)) {
if (cf->fast_schedule) {
info("Node configuration differs from hardware: "
"CPUs=%u:%u(hw) Boards=%u:%u(hw) "
"SocketsPerBoard=%u:%u(hw) CoresPerSocket=%u:%u(hw) "
"ThreadsPerCore=%u:%u(hw)",
conf->cpus, conf->actual_cpus,
conf->boards, conf->actual_boards,
conf->sockets, conf->actual_sockets,
conf->cores, conf->actual_cores,
conf->threads, conf->actual_threads);
} else if ((cf->fast_schedule == 0) && (cr_flag || gang_flag)) {
error("You are using cons_res or gang scheduling with "
"Fastschedule=0 and node configuration differs "
"from hardware. The node configuration used "
"will be what is in the slurm.conf because of "
"the bitmaps the slurmctld must create before "
"the slurmd registers.\n"
" CPUs=%u:%u(hw) Boards=%u:%u(hw) "
"SocketsPerBoard=%u:%u(hw) CoresPerSocket=%u:%u(hw) "
"ThreadsPerCore=%u:%u(hw)",
conf->cpus, conf->actual_cpus,
conf->boards, conf->actual_boards,
conf->sockets, conf->actual_sockets,
conf->cores, conf->actual_cores,
conf->threads, conf->actual_threads);
}
}
#endif
get_memory(&conf->real_memory_size);
get_up_time(&conf->up_time);
cf = slurm_conf_lock();
get_tmp_disk(&conf->tmp_disk_space, cf->tmp_fs);
_free_and_set(&conf->epilog, xstrdup(cf->epilog));
_free_and_set(&conf->prolog, xstrdup(cf->prolog));
_free_and_set(&conf->tmpfs, xstrdup(cf->tmp_fs));
_free_and_set(&conf->health_check_program,
xstrdup(cf->health_check_program));
_free_and_set(&conf->spooldir, xstrdup(cf->slurmd_spooldir));
_massage_pathname(&conf->spooldir);
_free_and_set(&conf->pidfile, xstrdup(cf->slurmd_pidfile));
_massage_pathname(&conf->pidfile);
_free_and_set(&conf->select_type, xstrdup(cf->select_type));
_free_and_set(&conf->task_prolog, xstrdup(cf->task_prolog));
_free_and_set(&conf->task_epilog, xstrdup(cf->task_epilog));
_free_and_set(&conf->pubkey, path_pubkey);
conf->debug_flags = cf->debug_flags;
conf->propagate_prio = cf->propagate_prio_process;
_free_and_set(&conf->job_acct_gather_freq,
xstrdup(cf->job_acct_gather_freq));
conf->acct_freq_task = (uint16_t)NO_VAL;
tmp16 = acct_gather_parse_freq(PROFILE_TASK,
conf->job_acct_gather_freq);
if (tmp16 != -1)
conf->acct_freq_task = tmp16;
_free_and_set(&conf->acct_gather_energy_type,
xstrdup(cf->acct_gather_energy_type));
_free_and_set(&conf->acct_gather_filesystem_type,
xstrdup(cf->acct_gather_filesystem_type));
_free_and_set(&conf->acct_gather_infiniband_type,
xstrdup(cf->acct_gather_infiniband_type));
_free_and_set(&conf->acct_gather_profile_type,
xstrdup(cf->acct_gather_profile_type));
_free_and_set(&conf->job_acct_gather_type,
xstrdup(cf->job_acct_gather_type));
if ( (conf->node_name == NULL) ||
(conf->node_name[0] == '\0') )
fatal("Node name lookup failure");
if (cf->control_addr == NULL)
fatal("Unable to establish controller machine");
if (cf->slurmctld_port == 0)
fatal("Unable to establish controller port");
conf->slurmd_timeout = cf->slurmd_timeout;
conf->use_pam = cf->use_pam;
conf->task_plugin_param = cf->task_plugin_param;
slurm_mutex_unlock(&conf->config_mutex);
slurm_conf_unlock();
}
