static void _load_slurm_config(void)
{
acct_storage_backup_host = slurm_get_accounting_storage_backup_host();
acct_storage_host = slurm_get_accounting_storage_host();
acct_storage_loc = slurm_get_accounting_storage_loc();
acct_storage_pass = slurm_get_accounting_storage_pass();
acct_storage_port = slurm_get_accounting_storage_port();
acct_storage_type = slurm_get_accounting_storage_type();
acct_storage_user = slurm_get_accounting_storage_user();
auth_type = slurm_get_auth_type();
msg_timeout = slurm_get_msg_timeout();
plugin_dir = slurm_get_plugin_dir();
private_data = slurm_get_private_data();
slurm_user_id = slurm_get_slurm_user_id();
track_wckey = slurm_get_track_wckey();
}
static void _layout_conf_dbd(GtkTreeStore *treestore)
{
ListIterator itr = NULL;
GtkTreeIter iter;
config_key_pair_t *key_pair;
int update = 0;
time_t now = time(NULL);
char tmp_str[128], *user_name = NULL;
List dbd_config_list = NULL;
/* first load accounting parms from slurm.conf */
char *acct_storage_backup_host =
slurm_get_accounting_storage_backup_host();
char *acct_storage_host = slurm_get_accounting_storage_host();
char *acct_storage_loc = slurm_get_accounting_storage_loc();
char *acct_storage_pass = slurm_get_accounting_storage_pass();
uint32_t acct_storage_port = slurm_get_accounting_storage_port();
char *acct_storage_type = slurm_get_accounting_storage_type();
char *acct_storage_user = slurm_get_accounting_storage_user();
char *auth_type = slurm_get_auth_type();
uint16_t msg_timeout = slurm_get_msg_timeout();
char *plugin_dir = slurm_get_plugin_dir();
uint16_t private_data = slurm_get_private_data();
uint32_t slurm_user_id = slurm_get_slurm_user_id();
uint16_t track_wckey = slurm_get_track_wckey();
slurm_make_time_str(&now, tmp_str, sizeof(tmp_str));
add_display_treestore_line_with_font(
update, treestore, &iter,
"SLURM Configuration data as of", tmp_str, "bold");
add_display_treestore_line(update, treestore, &iter,
"AccountingStorageBackupHost",
acct_storage_backup_host);
add_display_treestore_line(update, treestore, &iter,
"AccountingStorageHost", acct_storage_host);
add_display_treestore_line(update, treestore, &iter,
"AccountingStorageLoc", acct_storage_loc);
add_display_treestore_line(update, treestore, &iter,
"AccountingStoragePass", acct_storage_pass);
sprintf(tmp_str, "%u", acct_storage_port);
add_display_treestore_line(update, treestore, &iter,
"AccountingStoragePort", tmp_str);
add_display_treestore_line(update, treestore, &iter,
"AccountingStorageType", acct_storage_type);
add_display_treestore_line(update, treestore, &iter,
"AccountingStorageUser", acct_storage_user);
add_display_treestore_line(update, treestore, &iter,
"AuthType", auth_type);
sprintf(tmp_str, "%u sec", msg_timeout);
add_display_treestore_line(update, treestore, &iter,
"MessageTimeout", tmp_str);
add_display_treestore_line(update, treestore, &iter,
"PluginDir", plugin_dir);
private_data_string(private_data, tmp_str, sizeof(tmp_str));
add_display_treestore_line(update, treestore, &iter,
"PrivateData", tmp_str);
user_name = uid_to_string(slurm_user_id);
sprintf(tmp_str, "%s(%u)", user_name, slurm_user_id);
xfree(user_name);
add_display_treestore_line(update, treestore, &iter,
"SlurmUserId", tmp_str);
add_display_treestore_line(update, treestore, &iter,
"SLURM_CONF", default_slurm_config_file);
add_display_treestore_line(update, treestore, &iter,
"SLURM_VERSION", SLURM_VERSION_STRING);
sprintf(tmp_str, "%u", track_wckey);
add_display_treestore_line(update, treestore, &iter,
"TrackWCKey", tmp_str);
xfree(acct_storage_backup_host);
xfree(acct_storage_host);
xfree(acct_storage_loc);
xfree(acct_storage_pass);
xfree(acct_storage_type);
xfree(acct_storage_user);
xfree(auth_type);
xfree(plugin_dir);
/* now load accounting parms from slurmdbd.conf */
/* second load slurmdbd.conf parms */
if (!(dbd_config_list = slurmdb_config_get(NULL)))
return;
add_display_treestore_line_with_font(
update, treestore, &iter,
"\nSlurmDBD Configuration:", NULL, "bold");
itr = list_iterator_create(dbd_config_list);
while ((key_pair = list_next(itr))) {
add_display_treestore_line(update, treestore, &iter,
key_pair->name,
key_pair->value);
}
list_iterator_destroy(itr);
}
/*
* Initialize context for node selection plugin
*/
extern int slurm_select_init(bool only_default)
{
int retval = SLURM_SUCCESS;
char *type = NULL;
int i, j, len;
DIR *dirp;
struct dirent *e;
char *dir_array = NULL, *head = NULL;
char *plugin_type = "select";
if ( init_run && select_context )
return retval;
slurm_mutex_lock( &select_context_lock );
if ( select_context )
goto done;
type = slurm_get_select_type();
if (working_cluster_rec) {
/* just ignore warnings here */
} else {
#ifdef HAVE_XCPU
if (strcasecmp(type, "select/linear")) {
error("%s is incompatible with XCPU use", type);
fatal("Use SelectType=select/linear");
}
#endif
if (!strcasecmp(type, "select/linear")) {
uint16_t cr_type = slurm_get_select_type_param();
if ((cr_type & CR_SOCKET) || (cr_type & CR_CORE) ||
(cr_type & CR_CPU))
fatal("Invalid SelectTypeParameter "
"for select/linear");
}
#ifdef HAVE_BG
if (strcasecmp(type, "select/bluegene")) {
error("%s is incompatible with BlueGene", type);
fatal("Use SelectType=select/bluegene");
}
#else
if (!strcasecmp(type, "select/bluegene")) {
fatal("Requested SelectType=select/bluegene "
"in slurm.conf, but not running on a BG[L|P|Q] "
"system. If looking to emulate a BG[L|P|Q] "
"system use --enable-bgl-emulation or "
"--enable-bgp-emulation respectively.");
}
#endif
#ifdef HAVE_ALPS_CRAY
if (strcasecmp(type, "select/alps")) {
error("%s is incompatible with Cray system "
"running alps", type);
fatal("Use SelectType=select/alps");
}
#else
if (!strcasecmp(type, "select/alps")) {
fatal("Requested SelectType=select/alps "
"in slurm.conf, but not running on a ALPS Cray "
"system. If looking to emulate a Alps Cray "
"system use --enable-alps-cray-emulation.");
}
#endif
}
select_context_cnt = 0;
if (only_default) {
ops = xmalloc(sizeof(slurm_select_ops_t));
select_context = xmalloc(sizeof(plugin_context_t));
if ((select_context[0] = plugin_context_create(
plugin_type, type, (void **)&ops[0],
node_select_syms, sizeof(node_select_syms)))) {
select_context_default = 0;
select_context_cnt++;
}
goto skip_load_all;
}
if (!(dir_array = slurm_get_plugin_dir())) {
error("plugin_load_and_link: No plugin dir given");
goto done;
}
head = dir_array;
for (i=0; ; i++) {
bool got_colon = 0;
if (dir_array[i] == ':') {
dir_array[i] = '\0';
got_colon = 1;
} else if (dir_array[i] != '\0')
continue;
/* Open the directory. */
if (!(dirp = opendir(head))) {
error("cannot open plugin directory %s", head);
goto done;
}
while (1) {
char full_name[128];
if (!(e = readdir( dirp )))
break;
/* Check only files with select_ in them. */
if (strncmp(e->d_name, "select_", 7))
continue;
len = strlen(e->d_name);
#if defined(__CYGWIN__)
len -= 4;
#else
len -= 3;
#endif
/* Check only shared object files */
if (strcmp(e->d_name+len,
#if defined(__CYGWIN__)
".dll"
#else
".so"
#endif
))
continue;
/* add one for the / */
len++;
xassert(len<sizeof(full_name));
snprintf(full_name, len, "select/%s", e->d_name+7);
for (j=0; j<select_context_cnt; j++) {
if (!strcmp(full_name,
select_context[j]->type))
break;
}
if (j >= select_context_cnt) {
xrealloc(ops,
(sizeof(slurm_select_ops_t) *
(select_context_cnt + 1)));
xrealloc(select_context,
(sizeof(plugin_context_t) *
(select_context_cnt + 1)));
select_context[select_context_cnt] =
plugin_context_create(
plugin_type, full_name,
(void **)&ops[
select_context_cnt],
node_select_syms,
sizeof(node_select_syms));
if (select_context[select_context_cnt]) {
/* set the default */
if (!strcmp(full_name, type))
select_context_default =
select_context_cnt;
select_context_cnt++;
}
}
}
closedir(dirp);
if (got_colon) {
head = dir_array + i + 1;
} else
break;
}
skip_load_all:
if (select_context_default == -1)
fatal("Can't find plugin for %s", type);
/* Insure that plugin_id is valid and unique */
for (i=0; i<select_context_cnt; i++) {
for (j=i+1; j<select_context_cnt; j++) {
if (*(ops[i].plugin_id) !=
*(ops[j].plugin_id))
continue;
fatal("SelectPlugins: Duplicate plugin_id %u for "
"%s and %s",
*(ops[i].plugin_id),
select_context[i]->type,
select_context[j]->type);
}
if (*(ops[i].plugin_id) < 100) {
fatal("SelectPlugins: Invalid plugin_id %u (<100) %s",
*(ops[i].plugin_id),
select_context[i]->type);
}
}
init_run = true;
done:
slurm_mutex_unlock( &select_context_lock );
xfree(type);
xfree(dir_array);
return retval;
}
/*
* Return a list of plugin names that match the given type.
*
* IN plugin_type - Type of plugin to search for in the plugin_dir.
* RET list of plugin names, NULL if none found.
*/
extern List plugin_get_plugins_of_type(char *plugin_type)
{
List plugin_names = NULL;
char *plugin_dir = NULL, *dir = NULL, *save_ptr = NULL;
char *type_under = NULL, *type_slash = NULL;
DIR *dirp;
struct dirent *e;
int len;
if (!(plugin_dir = slurm_get_plugin_dir())) {
error("%s: No plugin dir given", __func__);
goto done;
}
type_under = xstrdup_printf("%s_", plugin_type);
type_slash = xstrdup_printf("%s/", plugin_type);
dir = strtok_r(plugin_dir, ":", &save_ptr);
while (dir) {
/* Open the directory. */
if (!(dirp = opendir(dir))) {
error("cannot open plugin directory %s", dir);
goto done;
}
while (1) {
char full_name[128];
if (!(e = readdir( dirp )))
break;
/* Check only files with "plugintype_" in them. */
if (xstrncmp(e->d_name, type_under, strlen(type_under)))
continue;
len = strlen(e->d_name);
len -= 3;
/* Check only shared object files */
if (xstrcmp(e->d_name+len, ".so"))
continue;
/* add one for the / */
len++;
xassert(len < sizeof(full_name));
snprintf(full_name, len, "%s%s",
type_slash, e->d_name + strlen(type_slash));
if (!plugin_names)
plugin_names = list_create(slurm_destroy_char);
if (!list_find_first(plugin_names,
slurm_find_char_in_list,
full_name))
list_append(plugin_names, xstrdup(full_name));
}
closedir(dirp);
dir = strtok_r(NULL, ":", &save_ptr);
}
done:
xfree(plugin_dir);
xfree(type_under);
xfree(type_slash);
return plugin_names;
}
/*
* Create a priority context
*/
extern plugin_context_t *plugin_context_create(
const char *plugin_type, const char *uler_type,
void *ptrs[], const char *names[], size_t names_size)
{
plugin_context_t *c;
int n_names;
if (!uler_type) {
debug3("plugin_context_create: no uler type");
return NULL;
} else if (!plugin_type) {
debug3("plugin_context_create: no plugin type");
return NULL;
} else if (!names) {
error("plugin_context_create: no symbols given for plugin %s",
plugin_type);
return NULL;
} else if (!ptrs) {
error("plugin_context_create: no ptrs given for plugin %s",
plugin_type);
return NULL;
}
c = xmalloc(sizeof(plugin_context_t));
c->type = xstrdup(uler_type);
c->cur_plugin = PLUGIN_INVALID_HANDLE;
n_names = names_size / sizeof(char *);
/* Find the correct plugin. */
c->cur_plugin = plugin_load_and_link(c->type, n_names, names, ptrs);
if (c->cur_plugin != PLUGIN_INVALID_HANDLE)
return c;
if (errno != EPLUGIN_NOTFOUND) {
error("Couldn't load specified plugin name for %s: %s",
c->type, plugin_strerror(errno));
goto fail;
}
error("Couldn't find the specified plugin name for %s "
"looking at all files",
c->type);
/* Get plugin list. */
if (!c->plugin_list) {
char *plugin_dir;
c->plugin_list = plugrack_create();
if (!c->plugin_list) {
error("cannot create plugin manager");
goto fail;
}
plugrack_set_major_type(c->plugin_list, plugin_type);
plugrack_set_paranoia(
c->plugin_list, PLUGRACK_PARANOIA_NONE, 0);
plugin_dir = slurm_get_plugin_dir();
plugrack_read_dir(c->plugin_list, plugin_dir);
xfree(plugin_dir);
}
c->cur_plugin = plugrack_use_by_type(c->plugin_list, c->type);
if (c->cur_plugin == PLUGIN_INVALID_HANDLE) {
error("cannot find %s plugin for %s", plugin_type, c->type);
goto fail;
}
/* Dereference the API. */
if (plugin_get_syms(c->cur_plugin, n_names, names, ptrs) < n_names) {
error("incomplete %s plugin detected", plugin_type);
goto fail;
}
return c;
fail:
plugin_context_destroy(c);
return NULL;
}
plugin_handle_t
plugin_load_and_link(const char *type_name, int n_syms,
const char *names[], void *ptrs[])
{
plugin_handle_t plug = PLUGIN_INVALID_HANDLE;
struct stat st;
char *head = NULL, *dir_array = NULL, *so_name = NULL;
char *file_name = NULL;
int i = 0;
plugin_err_t err = EPLUGIN_NOTFOUND;
if (!type_name)
return plug;
so_name = xstrdup_printf("%s.so", type_name);
while (so_name[i]) {
if (so_name[i] == '/')
so_name[i] = '_';
i++;
}
if (!(dir_array = slurm_get_plugin_dir())) {
error("plugin_load_and_link: No plugin dir given");
xfree(so_name);
return plug;
}
head = dir_array;
for (i = 0; ; i++) {
bool got_colon = 0;
if (dir_array[i] == ':') {
dir_array[i] = '\0';
got_colon = 1;
} else if (dir_array[i] != '\0')
continue;
file_name = xstrdup_printf("%s/%s", head, so_name);
debug3("Trying to load plugin %s", file_name);
if ((stat(file_name, &st) < 0) || (!S_ISREG(st.st_mode))) {
debug4("%s: Does not exist or not a regular file.",
file_name);
xfree(file_name);
err = EPLUGIN_NOTFOUND;
} else {
if ((err = plugin_load_from_file(&plug, file_name))
== EPLUGIN_SUCCESS) {
if (plugin_get_syms(plug, n_syms,
names, ptrs) >= n_syms) {
debug3("Success.");
xfree(file_name);
break;
} else {
(void) dlclose(plug);
err = EPLUGIN_MISSING_SYMBOL;
plug = PLUGIN_INVALID_HANDLE;
}
} else
plug = PLUGIN_INVALID_HANDLE;
xfree(file_name);
}
if (got_colon) {
head = dir_array + i + 1;
} else
break;
}
xfree(dir_array);
xfree(so_name);
errno = err;
return plug;
}
static slurmd_task_ops_t *
_slurmd_task_get_ops(slurmd_task_context_t *c)
{
/*
* Must be synchronized with slurmd_task_ops_t above.
*/
static const char *syms[] = {
"task_slurmd_batch_request",
"task_slurmd_launch_request",
"task_slurmd_reserve_resources",
"task_slurmd_suspend_job",
"task_slurmd_resume_job",
"task_slurmd_release_resources",
"task_pre_setuid",
"task_pre_launch",
"task_post_term",
"task_post_step",
};
int n_syms = sizeof( syms ) / sizeof( char * );
/* Find the correct plugin. */
c->cur_plugin = plugin_load_and_link(c->task_type, n_syms, syms,
(void **) &c->ops);
if ( c->cur_plugin != PLUGIN_INVALID_HANDLE )
return &c->ops;
if(errno != EPLUGIN_NOTFOUND) {
error("Couldn't load specified plugin name for %s: %s",
c->task_type, plugin_strerror(errno));
return NULL;
}
error("Couldn't find the specified plugin name for %s "
"looking at all files",
c->task_type);
/* Get plugin list. */
if ( c->plugin_list == NULL ) {
char *plugin_dir;
c->plugin_list = plugrack_create();
if ( c->plugin_list == NULL ) {
error( "cannot create plugin manager" );
return NULL;
}
plugrack_set_major_type( c->plugin_list, "task" );
plugrack_set_paranoia( c->plugin_list,
PLUGRACK_PARANOIA_NONE,
0 );
plugin_dir = slurm_get_plugin_dir();
plugrack_read_dir( c->plugin_list, plugin_dir );
xfree(plugin_dir);
}
c->cur_plugin = plugrack_use_by_type( c->plugin_list, c->task_type );
if ( c->cur_plugin == PLUGIN_INVALID_HANDLE ) {
error( "cannot find task plugin for %s", c->task_type );
return NULL;
}
/* Dereference the API. */
if ( plugin_get_syms( c->cur_plugin, n_syms, syms,
(void **) &c->ops ) < n_syms ) {
error( "incomplete task plugin detected" );
return NULL;
}
return &c->ops;
}
int _mpi_init (char *mpi_type)
{
int retval = SLURM_SUCCESS;
char *plugin_type = "mpi";
char *type = NULL;
int got_default = 0;
if (init_run && g_context)
return retval;
slurm_mutex_lock( &context_lock );
if ( g_context )
goto done;
if (mpi_type == NULL) {
mpi_type = slurm_get_mpi_default();
got_default = 1;
}
if (mpi_type == NULL) {
error("No MPI default set.");
retval = SLURM_ERROR;
goto done;
}
if (!strcmp(mpi_type, "list")) {
char *plugin_dir;
plugrack_t mpi_rack;
mpi_rack = plugrack_create();
if (!mpi_rack) {
error("Unable to create a plugin manager");
exit(0);
}
plugrack_set_major_type(mpi_rack, "mpi");
plugin_dir = slurm_get_plugin_dir();
plugrack_read_dir(mpi_rack, plugin_dir);
plugrack_print_all_plugin(mpi_rack);
exit(0);
}
setenvf(NULL, "SLURM_MPI_TYPE", "%s", mpi_type);
type = xstrdup_printf("mpi/%s", mpi_type);
g_context = plugin_context_create(
plugin_type, type, (void **)&ops, syms, sizeof(syms));
if (!g_context) {
error("cannot create %s context for %s", plugin_type, type);
retval = SLURM_ERROR;
goto done;
}
init_run = true;
done:
xfree(type);
if (got_default)
xfree(mpi_type);
slurm_mutex_unlock( &context_lock );
return retval;
}
/*
* Locate and load the appropriate plugin
*/
static int _select_get_ops(char *select_type,
slurm_select_context_t *c)
{
/*
* Must be synchronized with slurm_select_ops_t in node_select.h.
* Also must be synchronized with the other_plugin.[c|h] in
* the select/cray plugin.
*/
static const char *syms[] = {
"plugin_id",
"select_p_state_save",
"select_p_state_restore",
"select_p_job_init",
"select_p_node_ranking",
"select_p_node_init",
"select_p_block_init",
"select_p_job_test",
"select_p_job_begin",
"select_p_job_ready",
"select_p_job_expand_allow",
"select_p_job_expand",
"select_p_job_resized",
"select_p_job_signal",
"select_p_job_fini",
"select_p_job_suspend",
"select_p_job_resume",
"select_p_step_pick_nodes",
"select_p_step_finish",
"select_p_pack_select_info",
"select_p_select_nodeinfo_pack",
"select_p_select_nodeinfo_unpack",
"select_p_select_nodeinfo_alloc",
"select_p_select_nodeinfo_free",
"select_p_select_nodeinfo_set_all",
"select_p_select_nodeinfo_set",
"select_p_select_nodeinfo_get",
"select_p_select_jobinfo_alloc",
"select_p_select_jobinfo_free",
"select_p_select_jobinfo_set",
"select_p_select_jobinfo_get",
"select_p_select_jobinfo_copy",
"select_p_select_jobinfo_pack",
"select_p_select_jobinfo_unpack",
"select_p_select_jobinfo_sprint",
"select_p_select_jobinfo_xstrdup",
"select_p_update_block",
"select_p_update_sub_node",
"select_p_get_info_from_plugin",
"select_p_update_node_config",
"select_p_update_node_state",
"select_p_alter_node_cnt",
"select_p_reconfigure",
"select_p_resv_test",
"select_p_ba_init",
"select_p_ba_fini",
"select_p_ba_get_dims",
};
int n_syms = sizeof( syms ) / sizeof( char * );
c->select_type = xstrdup(select_type);
c->plugin_list = NULL;
c->cur_plugin = PLUGIN_INVALID_HANDLE;
c->select_errno = SLURM_SUCCESS;
/* Find the correct plugin. */
c->cur_plugin = plugin_load_and_link(c->select_type, n_syms, syms,
(void **) &c->ops);
if ( c->cur_plugin != PLUGIN_INVALID_HANDLE )
return SLURM_SUCCESS;
if(errno != EPLUGIN_NOTFOUND) {
error("Couldn't load specified plugin name for %s: %s",
c->select_type, plugin_strerror(errno));
return SLURM_ERROR;
}
error("Couldn't find the specified plugin name for %s "
"looking at all files",
c->select_type);
/* Get plugin list. */
if ( c->plugin_list == NULL ) {
char *plugin_dir;
c->plugin_list = plugrack_create();
if ( c->plugin_list == NULL ) {
error( "cannot create plugin manager" );
return SLURM_ERROR;
}
plugrack_set_major_type( c->plugin_list, "select" );
plugrack_set_paranoia( c->plugin_list,
PLUGRACK_PARANOIA_NONE,
0 );
plugin_dir = slurm_get_plugin_dir();
plugrack_read_dir( c->plugin_list, plugin_dir );
xfree(plugin_dir);
}
c->cur_plugin = plugrack_use_by_type( c->plugin_list, c->select_type );
if ( c->cur_plugin == PLUGIN_INVALID_HANDLE ) {
error( "cannot find node selection plugin for %s",
c->select_type );
return SLURM_ERROR;
}
/* Dereference the API. */
if ( plugin_get_syms( c->cur_plugin,
n_syms,
syms,
(void **) &c->ops ) < n_syms ) {
error( "incomplete node selection plugin detected" );
return SLURM_ERROR;
}
return SLURM_SUCCESS;
}
/*
* Initialize context for node selection plugin
*/
extern int slurm_select_init(bool only_default)
{
int retval = SLURM_SUCCESS;
char *select_type = NULL;
int i, j, rc, len;
DIR *dirp;
struct dirent *e;
char *dir_array = NULL, *head = NULL;
slurm_mutex_lock( &select_context_lock );
if ( select_context )
goto done;
select_type = slurm_get_select_type();
if (working_cluster_rec) {
/* just ignore warnings here */
} else {
#ifdef HAVE_XCPU
if (strcasecmp(select_type, "select/linear")) {
error("%s is incompatible with XCPU use", select_type);
fatal("Use SelectType=select/linear");
}
#endif
#ifdef HAVE_BG
if (strcasecmp(select_type, "select/bluegene")) {
error("%s is incompatible with BlueGene", select_type);
fatal("Use SelectType=select/bluegene");
}
#else
if (!strcasecmp(select_type, "select/bluegene")) {
fatal("Requested SelectType=select/bluegene "
"in slurm.conf, but not running on a BG[L|P|Q] "
"system. If looking to emulate a BG[L|P|Q] "
"system use --enable-bgl-emulation or "
"--enable-bgp-emulation respectively.");
}
#endif
#ifdef HAVE_CRAY
if (strcasecmp(select_type, "select/cray")) {
error("%s is incompatible with Cray", select_type);
fatal("Use SelectType=select/cray");
}
#else
if (!strcasecmp(select_type, "select/cray")) {
fatal("Requested SelectType=select/cray "
"in slurm.conf, but not running on a Cray "
"system. If looking to emulate a Cray "
"system use --enable-cray-emulation.");
}
#endif
}
select_context_cnt = 0;
if(only_default) {
select_context = xmalloc(sizeof(slurm_select_context_t));
rc = _select_get_ops(select_type, select_context);
if (rc == SLURM_SUCCESS) {
select_context_default = 0;
select_context_cnt++;
}
goto skip_load_all;
}
if(!(dir_array = slurm_get_plugin_dir())) {
error("plugin_load_and_link: No plugin dir given");
goto done;
}
head = dir_array;
for (i=0; ; i++) {
bool got_colon = 0;
if (dir_array[i] == ':') {
dir_array[i] = '\0';
got_colon = 1;
} else if(dir_array[i] != '\0')
continue;
/* Open the directory. */
if(!(dirp = opendir(head))) {
error("cannot open plugin directory %s", head);
goto done;
}
while (1) {
char full_name[128];
if(!(e = readdir( dirp )))
break;
/* Check only files with select_ in them. */
if (strncmp(e->d_name, "select_", 7))
continue;
len = strlen(e->d_name);
#if defined(__CYGWIN__)
len -= 4;
#else
len -= 3;
#endif
/* Check only shared object files */
if (strcmp(e->d_name+len,
#if defined(__CYGWIN__)
".dll"
#else
".so"
#endif
))
continue;
/* add one for the / */
len++;
xassert(len<sizeof(full_name));
snprintf(full_name, len, "select/%s", e->d_name+7);
for (j=0; j<select_context_cnt; j++) {
if (!strcmp(full_name,
select_context[j].select_type))
break;
}
if (j < select_context_cnt) {
error("Duplicate plugin %s ignored",
select_context[j].select_type);
} else {
xrealloc(select_context,
(sizeof(slurm_select_context_t) *
(select_context_cnt + 1)));
rc = _select_get_ops(
full_name,
select_context + select_context_cnt);
/* only add the ones this system has */
if (rc == SLURM_SUCCESS) {
/* set the default */
if (!strcmp(full_name, select_type))
select_context_default =
select_context_cnt;
select_context_cnt++;
}
}
}
closedir(dirp);
if (got_colon) {
head = dir_array + i + 1;
} else
break;
}
skip_load_all:
if(select_context_default == -1)
fatal("Can't find plugin for %s", select_type);
/* Insure that plugin_id is valid and unique */
for (i=0; i<select_context_cnt; i++) {
for (j=i+1; j<select_context_cnt; j++) {
if (*(select_context[i].ops.plugin_id) !=
*(select_context[j].ops.plugin_id))
continue;
fatal("SelectPlugins: Duplicate plugin_id %u for "
"%s and %s",
*(select_context[i].ops.plugin_id),
select_context[i].select_type,
select_context[j].select_type);
}
if (*(select_context[i].ops.plugin_id) < 100) {
fatal("SelectPlugins: Invalid plugin_id %u (<100) %s",
*(select_context[i].ops.plugin_id),
select_context[i].select_type);
}
}
done:
slurm_mutex_unlock( &select_context_lock );
xfree(select_type);
xfree(dir_array);
return retval;
}
/* ************************************************************************ */
static slurm_sched_ops_t *
slurm_sched_get_ops( slurm_sched_context_t *c )
{
/*
* Must be synchronized with slurm_sched_ops_t above.
*/
static const char *syms[] = {
"slurm_sched_plugin_schedule",
"slurm_sched_plugin_newalloc",
"slurm_sched_plugin_freealloc",
"slurm_sched_plugin_initial_priority",
"slurm_sched_plugin_job_is_pending",
"slurm_sched_plugin_reconfig",
"slurm_sched_plugin_partition_change",
"slurm_sched_get_errno",
"slurm_sched_strerror",
"slurm_sched_plugin_requeue",
"slurm_sched_get_conf"
};
int n_syms = sizeof( syms ) / sizeof( char * );
/* Find the correct plugin. */
c->cur_plugin = plugin_load_and_link(c->sched_type, n_syms, syms,
(void **) &c->ops);
if ( c->cur_plugin != PLUGIN_INVALID_HANDLE )
return &c->ops;
if(errno != EPLUGIN_NOTFOUND) {
error("Couldn't load specified plugin name for %s: %s",
c->sched_type, plugin_strerror(errno));
return NULL;
}
error("sched: Couldn't find the specified plugin name for %s "
"looking at all files",
c->sched_type);
/* Get plugin list. */
if ( c->plugin_list == NULL ) {
char *plugin_dir;
c->plugin_list = plugrack_create();
if ( c->plugin_list == NULL ) {
error( "sched: cannot create plugin manager" );
return NULL;
}
plugrack_set_major_type( c->plugin_list, "sched" );
plugrack_set_paranoia( c->plugin_list,
PLUGRACK_PARANOIA_NONE,
0 );
plugin_dir = slurm_get_plugin_dir();
plugrack_read_dir( c->plugin_list, plugin_dir );
xfree(plugin_dir);
}
c->cur_plugin = plugrack_use_by_type( c->plugin_list, c->sched_type );
if ( c->cur_plugin == PLUGIN_INVALID_HANDLE ) {
error( "sched: cannot find scheduler plugin for %s",
c->sched_type );
return NULL;
}
/* Dereference the API. */
if ( plugin_get_syms( c->cur_plugin,
n_syms,
syms,
(void **) &c->ops ) < n_syms ) {
error( "sched: incomplete scheduling plugin detected" );
return NULL;
}
return &c->ops;
}
/* ************************************************************************ */
static slurm_topo_ops_t *
slurm_topo_get_ops( slurm_topo_context_t *c )
{
/*
* Must be synchronized with slurm_topo_ops_t above.
*/
static const char *syms[] = {
"topo_build_config",
"topo_generate_node_ranking",
"topo_get_node_addr",
};
int n_syms = sizeof( syms ) / sizeof( char * );
/* Find the correct plugin. */
c->cur_plugin = plugin_load_and_link(c->topo_type, n_syms, syms,
(void **) &c->ops);
if ( c->cur_plugin != PLUGIN_INVALID_HANDLE )
return &c->ops;
if(errno != EPLUGIN_NOTFOUND) {
error("Couldn't load specified plugin name for %s: %s",
c->topo_type, plugin_strerror(errno));
return NULL;
}
error("Couldn't find the specified plugin name for %s "
"looking at all files",
c->topo_type);
/* Get plugin list. */
if ( c->plugin_list == NULL ) {
char *plugin_dir;
c->plugin_list = plugrack_create();
if ( c->plugin_list == NULL ) {
error( "cannot create plugin manager" );
return NULL;
}
plugrack_set_major_type( c->plugin_list, "topo" );
plugrack_set_paranoia( c->plugin_list,
PLUGRACK_PARANOIA_NONE,
0 );
plugin_dir = slurm_get_plugin_dir();
plugrack_read_dir( c->plugin_list, plugin_dir );
xfree(plugin_dir);
}
c->cur_plugin = plugrack_use_by_type( c->plugin_list, c->topo_type );
if ( c->cur_plugin == PLUGIN_INVALID_HANDLE ) {
error( "cannot find topology plugin for %s", c->topo_type );
return NULL;
}
/* Dereference the API. */
if ( plugin_get_syms( c->cur_plugin,
n_syms,
syms,
(void **) &c->ops ) < n_syms ) {
error( "incomplete topology plugin detected" );
return NULL;
}
return &c->ops;
}
/*
* Resolve the operations from the plugin.
*/
static slurm_mpi_ops_t *
_slurm_mpi_get_ops( slurm_mpi_context_t c )
{
/*
* These strings must be kept in the same order as the fields
* declared for slurm_mpi_ops_t.
*/
static const char *syms[] = {
"p_mpi_hook_slurmstepd_task",
"p_mpi_hook_client_prelaunch",
"p_mpi_hook_client_single_task_per_node",
"p_mpi_hook_client_fini"
};
int n_syms = sizeof( syms ) / sizeof( char * );
char *plugin_dir = NULL;
/* Find the correct plugin. */
c->cur_plugin = plugin_load_and_link(c->mpi_type, n_syms, syms,
(void **) &c->ops);
if ( c->cur_plugin != PLUGIN_INVALID_HANDLE )
return &c->ops;
error("Couldn't find the specified plugin name for %s "
"looking at all files",
c->mpi_type);
/* Get the plugin list, if needed. */
if ( c->plugin_list == NULL ) {
c->plugin_list = plugrack_create();
if ( c->plugin_list == NULL ) {
error("Unable to create a plugin manager");
return NULL;
}
plugrack_set_major_type(c->plugin_list, "mpi");
plugrack_set_paranoia(c->plugin_list,
PLUGRACK_PARANOIA_NONE,
0);
plugin_dir = slurm_get_plugin_dir();
plugrack_read_dir(c->plugin_list, plugin_dir);
xfree(plugin_dir);
}
if (strcasecmp (c->mpi_type, "mpi/list") == 0) {
plugrack_print_all_plugin(c->plugin_list);
exit(0);
} else {
/* Find the correct plugin. */
c->cur_plugin = plugrack_use_by_type(c->plugin_list,
c->mpi_type);
if ( c->cur_plugin == PLUGIN_INVALID_HANDLE ) {
error("can't find a valid plugin for type %s",
c->mpi_type);
return NULL;
}
}
/* Dereference the API. */
if ( plugin_get_syms( c->cur_plugin,
n_syms,
syms,
(void **) &c->ops ) < n_syms ) {
error( "incomplete mpi plugin detected" );
return NULL;
}
return &c->ops;
}
/*
* Resolve the operations from the plugin.
*/
static slurm_checkpoint_ops_t *
_slurm_checkpoint_get_ops( slurm_checkpoint_context_t c )
{
/*
* These strings must be kept in the same order as the fields
* declared for slurm_checkpoint_ops_t.
*/
static const char *syms[] = {
"slurm_ckpt_op",
"slurm_ckpt_comp",
"slurm_ckpt_task_comp",
"slurm_ckpt_alloc_job",
"slurm_ckpt_free_job",
"slurm_ckpt_pack_job",
"slurm_ckpt_unpack_job",
"slurm_ckpt_stepd_prefork",
"slurm_ckpt_signal_tasks",
"slurm_ckpt_restart_task"
};
int n_syms = sizeof( syms ) / sizeof( char * );
/* Find the correct plugin. */
c->cur_plugin = plugin_load_and_link(c->checkpoint_type, n_syms, syms,
(void **) &c->ops);
if ( c->cur_plugin != PLUGIN_INVALID_HANDLE )
return &c->ops;
if(errno != EPLUGIN_NOTFOUND) {
error("Couldn't load specified plugin name for %s: %s",
c->checkpoint_type, plugin_strerror(errno));
return NULL;
}
error("Couldn't find the specified plugin name for %s "
"looking at all files",
c->checkpoint_type);
/* Get the plugin list, if needed. */
if ( c->plugin_list == NULL ) {
char *plugin_dir;
c->plugin_list = plugrack_create();
if ( c->plugin_list == NULL ) {
error( "Unable to create a plugin manager" );
return NULL;
}
plugrack_set_major_type( c->plugin_list, "checkpoint" );
plugrack_set_paranoia( c->plugin_list,
PLUGRACK_PARANOIA_NONE,
0 );
plugin_dir = slurm_get_plugin_dir();
plugrack_read_dir( c->plugin_list, plugin_dir );
xfree(plugin_dir);
}
/* Find the correct plugin. */
c->cur_plugin =
plugrack_use_by_type( c->plugin_list, c->checkpoint_type );
if ( c->cur_plugin == PLUGIN_INVALID_HANDLE ) {
error( "can't find a plugin for type %s", c->checkpoint_type );
return NULL;
}
/* Dereference the API. */
if ( plugin_get_syms( c->cur_plugin,
n_syms,
syms,
(void **) &c->ops ) < n_syms ) {
error( "incomplete checkpoint plugin detected" );
return NULL;
}
return &c->ops;
}
/*
* Locate and load the appropriate plugin
*/
static slurm_acct_storage_ops_t * _acct_storage_get_ops(
slurm_acct_storage_context_t *c)
{
/*
* Must be synchronized with slurm_acct_storage_ops_t above.
*/
static const char *syms[] = {
"acct_storage_p_get_connection",
"acct_storage_p_close_connection",
"acct_storage_p_commit",
"acct_storage_p_add_users",
"acct_storage_p_add_coord",
"acct_storage_p_add_accts",
"acct_storage_p_add_clusters",
"acct_storage_p_add_associations",
"acct_storage_p_add_qos",
"acct_storage_p_add_wckeys",
"acct_storage_p_add_reservation",
"acct_storage_p_modify_users",
"acct_storage_p_modify_accts",
"acct_storage_p_modify_clusters",
"acct_storage_p_modify_associations",
"acct_storage_p_modify_job",
"acct_storage_p_modify_qos",
"acct_storage_p_modify_wckeys",
"acct_storage_p_modify_reservation",
"acct_storage_p_remove_users",
"acct_storage_p_remove_coord",
"acct_storage_p_remove_accts",
"acct_storage_p_remove_clusters",
"acct_storage_p_remove_associations",
"acct_storage_p_remove_qos",
"acct_storage_p_remove_wckeys",
"acct_storage_p_remove_reservation",
"acct_storage_p_get_users",
"acct_storage_p_get_accts",
"acct_storage_p_get_clusters",
"acct_storage_p_get_config",
"acct_storage_p_get_associations",
"acct_storage_p_get_events",
"acct_storage_p_get_problems",
"acct_storage_p_get_qos",
"acct_storage_p_get_wckeys",
"acct_storage_p_get_reservations",
"acct_storage_p_get_txn",
"acct_storage_p_get_usage",
"acct_storage_p_roll_usage",
"clusteracct_storage_p_node_down",
"clusteracct_storage_p_node_up",
"clusteracct_storage_p_cluster_cpus",
"clusteracct_storage_p_register_ctld",
"clusteracct_storage_p_fini_ctld",
"jobacct_storage_p_job_start",
"jobacct_storage_p_job_complete",
"jobacct_storage_p_step_start",
"jobacct_storage_p_step_complete",
"jobacct_storage_p_suspend",
"jobacct_storage_p_get_jobs_cond",
"jobacct_storage_p_archive",
"jobacct_storage_p_archive_load",
"acct_storage_p_update_shares_used",
"acct_storage_p_flush_jobs_on_cluster"
};
int n_syms = sizeof( syms ) / sizeof( char * );
/* Find the correct plugin. */
c->cur_plugin = plugin_load_and_link(c->acct_storage_type, n_syms, syms,
(void **) &c->ops);
if ( c->cur_plugin != PLUGIN_INVALID_HANDLE )
return &c->ops;
if(errno != EPLUGIN_NOTFOUND) {
error("Couldn't load specified plugin name for %s: %s",
c->acct_storage_type, plugin_strerror(errno));
return NULL;
}
error("Couldn't find the specified plugin name for %s "
"looking at all files",
c->acct_storage_type);
/* Get plugin list. */
if ( c->plugin_list == NULL ) {
char *plugin_dir;
c->plugin_list = plugrack_create();
if ( c->plugin_list == NULL ) {
error( "cannot create plugin manager" );
return NULL;
}
plugrack_set_major_type( c->plugin_list, "accounting_storage" );
plugrack_set_paranoia( c->plugin_list,
PLUGRACK_PARANOIA_NONE,
0 );
plugin_dir = slurm_get_plugin_dir();
plugrack_read_dir( c->plugin_list, plugin_dir );
xfree(plugin_dir);
}
c->cur_plugin = plugrack_use_by_type( c->plugin_list,
c->acct_storage_type );
if ( c->cur_plugin == PLUGIN_INVALID_HANDLE ) {
error( "cannot find accounting_storage plugin for %s",
c->acct_storage_type );
return NULL;
}
/* Dereference the API. */
if ( plugin_get_syms( c->cur_plugin,
n_syms,
syms,
(void **) &c->ops ) < n_syms ) {
error( "incomplete acct_storage plugin detected" );
return NULL;
}
return &c->ops;
}