/*
* Replace first "%h" in path string with actual hostname.
* Replace first "%n" in path string with NodeName.
*/
static void
_massage_pathname(char **path)
{
if (path && *path) {
if (conf->hostname)
xstrsubstitute(*path, "%h", conf->hostname);
if (conf->node_name)
xstrsubstitute(*path, "%n", conf->node_name);
}
}
extern char* jobacct_cgroup_create_slurm_cg(xcgroup_ns_t* ns)
{
/* we do it here as we do not have access to the conf structure */
/* in libslurm (src/common/xcgroup.c) */
xcgroup_t slurm_cg;
char* pre = (char*) xstrdup(slurm_cgroup_conf.cgroup_prepend);
#ifdef MULTIPLE_SLURMD
if (conf->node_name != NULL)
xstrsubstitute(pre,"%n", conf->node_name);
else {
xfree(pre);
pre = (char*) xstrdup("/slurm");
}
#endif
/* create slurm cgroup in the ns (it could already exist) */
if (xcgroup_create(ns,&slurm_cg,pre,
getuid(), getgid()) != XCGROUP_SUCCESS) {
return pre;
}
if (xcgroup_instanciate(&slurm_cg) != XCGROUP_SUCCESS) {
error("unable to build slurm cgroup for ns %s: %m",
ns->subsystems);
xcgroup_destroy(&slurm_cg);
return pre;
} else {
debug3("slurm cgroup %s successfully created for ns %s: %m",
pre,ns->subsystems);
xcgroup_destroy(&slurm_cg);
}
return pre;
}
static char* _system_cgroup_create_slurm_cg (xcgroup_ns_t* ns)
{
/* we do it here as we do not have access to the conf structure */
/* in libslurm (src/common/xcgroup.c) */
xcgroup_t slurm_cg;
char* pre = (char*) xstrdup(slurm_cgroup_conf.cgroup_prepend);
#ifdef MULTIPLE_SLURMD
if ( conf->node_name != NULL )
xstrsubstitute(pre, "%n", conf->node_name);
else {
xfree(pre);
pre = (char*) xstrdup("/slurm");
}
#endif
/* create slurm cgroup in the ns
* disable notify_on_release to avoid the removal/creation
* of this cgroup for each last/first running job on the node */
if (xcgroup_create(ns, &slurm_cg, pre,
getuid(), getgid()) != XCGROUP_SUCCESS) {
xfree(pre);
return pre;
}
slurm_cg.notify = 0;
if (xcgroup_instantiate(&slurm_cg) != XCGROUP_SUCCESS) {
error("system cgroup: unable to build slurm cgroup for "
"ns %s: %m",
ns->subsystems);
xcgroup_destroy(&slurm_cg);
xfree(pre);
return pre;
}
else {
debug3("system cgroup: slurm cgroup %s successfully created "
"for ns %s: %m",
pre, ns->subsystems);
xcgroup_destroy(&slurm_cg);
}
return pre;
}
static char* _get_node_rrd_path(char* component_name,
enum ext_sensors_value_type sensor_type)
{
char *p;
char *rrd_file;
struct stat buf;
switch (sensor_type) {
case EXT_SENSORS_VALUE_ENERGY:
rrd_file = ext_sensors_cnf->energy_rrd_file;
break;
case EXT_SENSORS_VALUE_TEMPERATURE:
rrd_file = ext_sensors_cnf->temp_rrd_file;
break;
default:
error("ext_sensors: _get_node_rrd_path: unknown enum %d",
sensor_type);
return NULL;
}
if (!component_name || !strlen(component_name) || !rrd_file)
return NULL;
p = xstrdup(rrd_file);
xstrsubstitute(p, "%n", component_name);
if (!strcmp(p, rrd_file)) {
xfree(p);
return NULL;
}
if (stat(p, &buf) == -1) {
xfree(p);
return NULL;
}
return p;
}
extern void attach_system_cgroup_pid(pid_t pid)
{
char* slurm_cgpath;
if (read_slurm_cgroup_conf(&slurm_cgroup_conf))
return;
slurm_cgpath = (char*) xstrdup(slurm_cgroup_conf.cgroup_prepend);
#ifdef MULTIPLE_SLURMD
if ( conf->node_name != NULL )
xstrsubstitute(slurm_cgpath,"%n", conf->node_name);
else {
xfree(slurm_cgpath);
slurm_cgpath = (char*) xstrdup("/slurm");
}
#endif
xstrcat(slurm_cgpath,"/system");
if (xcgroup_ns_load(&slurm_cgroup_conf, &cpuset_ns, "cpuset")
== XCGROUP_SUCCESS) {
if (xcgroup_load(&cpuset_ns, &system_cpuset_cg, slurm_cgpath)
== XCGROUP_SUCCESS)
if (attach_system_cpuset_pid(pid) != SLURM_SUCCESS)
debug2("system cgroup: unable to attach pid to "
"system cpuset cgroup");
}
if (xcgroup_ns_load(&slurm_cgroup_conf, &memory_ns, "memory")
== XCGROUP_SUCCESS) {
if (xcgroup_load(&memory_ns, &system_memory_cg, slurm_cgpath)
== XCGROUP_SUCCESS)
if (attach_system_memory_pid(pid) != SLURM_SUCCESS)
debug2("system cgroup: unable to attach pid to "
"system memory cgroup");
}
xfree(slurm_cgpath);
free_slurm_cgroup_conf(&slurm_cgroup_conf);
return;
}
static uint32_t _rrd_get_last_one(char* filename, char* rra_name)
{
/* RRD library usage notes:
* do not use the following lines for compatibility:
* 1.3.8-6 : (argv={lastupdate, filename}
* status = rrd_lastupdate(argc, argv, &time, &ds_count,
* &ds_names, &last_ds);
* 1.4.7 :
* status = rrd_lastupdate_r(filename, &time, &ds_count,
* &ds_names, &last_ds);
*/
rrd_info_t *data, *data_p;
char line[] = "ds[%s].last_ds", *p, *rra = NULL;
char *argv[] = {"info", filename, NULL};
uint32_t temperature = NO_VAL;
p = xstrdup(line);
data = rrd_info(2, argv);
data_p = data;
if (rra_name == NULL) {
while (data_p) {
if (!strncmp(line, data_p->key, 3)) {
rra = xstrdup(data_p->key + 3);
xstrsubstitute(rra, strchr(rra, ']'), "");
break;
}
data_p = data_p->next;
}
} else
rra = rra_name;
if (rra != NULL) {
xstrsubstitute(p, "%s", rra_name);
if (rra_name == NULL)
xfree(rra);
if (strcmp(p,line) == 0) {
xfree(p);
rrd_info_free(data);
return temperature;
}
} else {
xfree(p);
rrd_info_free(data);
return temperature;
}
while (data_p) {
if (!strcmp(p, data_p->key)) {
if (!sscanf(data_p->value.u_str, "%d", &temperature))
temperature = 1;
break;
}
data_p = data_p->next;
}
xfree(p);
rrd_info_free(data);
return temperature;
}
int _slurm_cgroup_create(stepd_step_rec_t *job, uint64_t id, uid_t uid, gid_t gid)
{
/* we do it here as we do not have access to the conf structure */
/* in libslurm (src/common/xcgroup.c) */
char *pre = (char *)xstrdup(slurm_cgroup_conf.cgroup_prepend);
#ifdef MULTIPLE_SLURMD
if ( conf->node_name != NULL )
xstrsubstitute(pre,"%n", conf->node_name);
else {
xfree(pre);
pre = (char*) xstrdup("/slurm");
}
#endif
if (xcgroup_create(&freezer_ns, &slurm_freezer_cg, pre,
getuid(), getgid()) != XCGROUP_SUCCESS) {
return SLURM_ERROR;
}
/*
* While creating the cgroup hierarchy of the step, lock the root
* cgroup directory. The same lock is hold during removal of the
* hierarchies of other jobs/steps. This helps to avoid the race
* condition with concurrent creation/removal of the intermediate
* shared directories that could result in the failure of the
* hierarchy setup
*/
xcgroup_lock(&freezer_cg);
/* create slurm cgroup in the freezer ns (it could already exist) */
if (xcgroup_instanciate(&slurm_freezer_cg) != XCGROUP_SUCCESS)
goto bail;
/* build user cgroup relative path if not set (should not be) */
if (*user_cgroup_path == '\0') {
if (snprintf(user_cgroup_path, PATH_MAX,
"%s/uid_%u", pre, uid) >= PATH_MAX) {
error("unable to build uid %u cgroup relative "
"path : %m", uid);
xfree(pre);
goto bail;
}
}
xfree(pre);
/* build job cgroup relative path if no set (should not be) */
if (*job_cgroup_path == '\0') {
if (snprintf(job_cgroup_path, PATH_MAX, "%s/job_%u",
user_cgroup_path, job->jobid) >= PATH_MAX) {
error("unable to build job %u cgroup relative "
"path : %m", job->jobid);
goto bail;
}
}
/* build job step cgroup relative path (should not be) */
if (*jobstep_cgroup_path == '\0') {
if (job->stepid == NO_VAL) {
if (snprintf(jobstep_cgroup_path, PATH_MAX,
"%s/step_batch", job_cgroup_path)
>= PATH_MAX) {
error("proctrack/cgroup unable to build job step"
" %u.batch freezer cg relative path: %m",
job->jobid);
goto bail;
}
} else {
if (snprintf(jobstep_cgroup_path, PATH_MAX, "%s/step_%u",
job_cgroup_path, job->stepid) >= PATH_MAX) {
error("proctrack/cgroup unable to build job step"
" %u.%u freezer cg relative path: %m",
job->jobid, job->stepid);
goto bail;
}
}
}
/* create user cgroup in the freezer ns (it could already exist) */
if (xcgroup_create(&freezer_ns, &user_freezer_cg,
user_cgroup_path,
getuid(), getgid()) != XCGROUP_SUCCESS) {
xcgroup_destroy(&slurm_freezer_cg);
goto bail;
}
/* create job cgroup in the freezer ns (it could already exist) */
if (xcgroup_create(&freezer_ns, &job_freezer_cg,
job_cgroup_path,
getuid(), getgid()) != XCGROUP_SUCCESS) {
xcgroup_destroy(&slurm_freezer_cg);
xcgroup_destroy(&user_freezer_cg);
goto bail;
}
/* create step cgroup in the freezer ns (it should not exists) */
if (xcgroup_create(&freezer_ns, &step_freezer_cg,
jobstep_cgroup_path,
getuid(), getgid()) != XCGROUP_SUCCESS) {
xcgroup_destroy(&slurm_freezer_cg);
xcgroup_destroy(&user_freezer_cg);
xcgroup_destroy(&job_freezer_cg);
goto bail;
}
if ((xcgroup_instanciate(&user_freezer_cg) != XCGROUP_SUCCESS) ||
(xcgroup_instanciate(&job_freezer_cg) != XCGROUP_SUCCESS) ||
(xcgroup_instanciate(&step_freezer_cg) != XCGROUP_SUCCESS)) {
xcgroup_destroy(&user_freezer_cg);
xcgroup_destroy(&job_freezer_cg);
xcgroup_destroy(&step_freezer_cg);
goto bail;
}
/* inhibit release agent for the step cgroup thus letting
* slurmstepd being able to add new pids to the container
* when the job ends (TaskEpilog,...) */
xcgroup_set_param(&step_freezer_cg,"notify_on_release","0");
slurm_freezer_init = true;
xcgroup_unlock(&freezer_cg);
return SLURM_SUCCESS;
bail:
xcgroup_destroy(&slurm_freezer_cg);
xcgroup_unlock(&freezer_cg);
xcgroup_destroy(&freezer_cg);
return SLURM_ERROR;
}
int _slurm_cgroup_create(stepd_step_rec_t *job, uint64_t id, uid_t uid, gid_t gid)
{
/* we do it here as we do not have access to the conf structure */
/* in libslurm (src/common/xcgroup.c) */
xcgroup_t slurm_cg;
char* pre = (char*) xstrdup(slurm_cgroup_conf.cgroup_prepend);
#ifdef MULTIPLE_SLURMD
if ( conf->node_name != NULL )
xstrsubstitute(pre,"%n", conf->node_name);
else {
xfree(pre);
pre = (char*) xstrdup("/slurm");
}
#endif
/* create slurm cgroup in the freezer ns (it could already exist) */
if (xcgroup_create(&freezer_ns, &slurm_cg,pre,
getuid(), getgid()) != XCGROUP_SUCCESS) {
return SLURM_ERROR;
}
if (xcgroup_instanciate(&slurm_cg) != XCGROUP_SUCCESS) {
xcgroup_destroy(&slurm_cg);
return SLURM_ERROR;
}
else
xcgroup_destroy(&slurm_cg);
/* build user cgroup relative path if not set (should not be) */
if (*user_cgroup_path == '\0') {
if (snprintf(user_cgroup_path, PATH_MAX,
"%s/uid_%u", pre, uid) >= PATH_MAX) {
error("unable to build uid %u cgroup relative "
"path : %m", uid);
xfree(pre);
return SLURM_ERROR;
}
}
xfree(pre);
/* build job cgroup relative path if no set (should not be) */
if (*job_cgroup_path == '\0') {
if (snprintf(job_cgroup_path, PATH_MAX, "%s/job_%u",
user_cgroup_path, job->jobid) >= PATH_MAX) {
error("unable to build job %u cgroup relative "
"path : %m", job->jobid);
return SLURM_ERROR;
}
}
/* build job step cgroup relative path (should not be) */
if (*jobstep_cgroup_path == '\0') {
if (job->stepid == NO_VAL) {
if (snprintf(jobstep_cgroup_path, PATH_MAX,
"%s/step_batch", job_cgroup_path)
>= PATH_MAX) {
error("proctrack/cgroup unable to build job step"
" %u.batch freezer cg relative path: %m",
job->jobid);
return SLURM_ERROR;
}
} else {
if (snprintf(jobstep_cgroup_path, PATH_MAX, "%s/step_%u",
job_cgroup_path, job->stepid) >= PATH_MAX) {
error("proctrack/cgroup unable to build job step"
" %u.%u freezer cg relative path: %m",
job->jobid, job->stepid);
return SLURM_ERROR;
}
}
}
/* create user cgroup in the freezer ns (it could already exist) */
if (xcgroup_create(&freezer_ns, &user_freezer_cg,
user_cgroup_path,
getuid(), getgid()) != XCGROUP_SUCCESS) {
return SLURM_ERROR;
}
if (xcgroup_instanciate(&user_freezer_cg) != XCGROUP_SUCCESS) {
xcgroup_destroy(&user_freezer_cg);
return SLURM_ERROR;
}
/* create job cgroup in the freezer ns (it could already exist) */
if (xcgroup_create(&freezer_ns, &job_freezer_cg,
job_cgroup_path,
getuid(), getgid()) != XCGROUP_SUCCESS) {
xcgroup_destroy(&user_freezer_cg);
return SLURM_ERROR;
}
if (xcgroup_instanciate(&job_freezer_cg) != XCGROUP_SUCCESS) {
xcgroup_destroy(&user_freezer_cg);
xcgroup_destroy(&job_freezer_cg);
return SLURM_ERROR;
}
/* create step cgroup in the freezer ns (it should not exists) */
if (xcgroup_create(&freezer_ns, &step_freezer_cg,
jobstep_cgroup_path,
getuid(), getgid()) != XCGROUP_SUCCESS) {
xcgroup_destroy(&user_freezer_cg);
xcgroup_destroy(&job_freezer_cg);
return SLURM_ERROR;
}
if (xcgroup_instanciate(&step_freezer_cg) != XCGROUP_SUCCESS) {
xcgroup_destroy(&user_freezer_cg);
xcgroup_destroy(&job_freezer_cg);
xcgroup_destroy(&step_freezer_cg);
return SLURM_ERROR;
}
/* inhibit release agent for the step cgroup thus letting
* slurmstepd being able to add new pids to the container
* when the job ends (TaskEpilog,...) */
xcgroup_set_param(&step_freezer_cg,"notify_on_release","0");
return SLURM_SUCCESS;
}