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;
}
/*
* 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;
}
/*
* 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;
}
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;
}
/* ************************************************************************ */
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;
}