uint64_t proctrack_p_find(pid_t pid)
{
jid_t jid;
if ((jid = job_getjid(pid)) == (jid_t) -1)
return ((uint64_t) 0);
return ((uint64_t) jid);
}
bool proctrack_p_has_pid (uint64_t cont_id, pid_t pid)
{
jid_t jid;
if ((jid = job_getjid(pid)) == (jid_t) -1)
return false;
if ((uint64_t)jid != cont_id)
return false;
return true;
}
uint64_t proctrack_p_find(pid_t pid)
{
jid_t jid;
DEF_TIMERS;
START_TIMER;
if ((jid = job_getjid(pid)) == (jid_t) -1)
return ((uint64_t) 0);
END_TIMER;
if (debug_flags & DEBUG_FLAG_TIME_CRAY)
INFO_LINE("call took: %s", TIME_STR);
return ((uint64_t) jid);
}
PAM_EXTERN int pam_sm_close_session(pam_handle_t *pamh, int flags, int argc,
const char **argv)
{
int retcode = PAM_SUCCESS;
char *username = NULL;
char *service = NULL;
jid_t jid = (jid_t)0;
parse_args(argc, argv);
/* Get the username of the user associated with this job */
retcode = pam_get_item(pamh, PAM_USER, (void *) &username);
if (username == NULL || retcode != PAM_SUCCESS) {
syslog(LOG_CRIT, "open_session - error recovering username");
return PAM_SESSION_ERR;
}
/* Get the service used to create this job */
retcode = pam_get_item(pamh, PAM_SERVICE, (void *) &service);
if (service == NULL || retcode != PAM_SUCCESS) {
syslog(LOG_CRIT, "open_session - error recovering service");
return PAM_SESSION_ERR;
}
if (!disabled) {
jid = job_getjid(getpid());
if (jid == (jid_t)-1) {
syslog(LOG_CRIT, "job_getjid(...) - error getting job ID");
}
else if (jid > (jid_t)0) {
vsyslog(LOG_INFO, "(%s) POE(pid=%d): job(jid=%0#18Lx) POE process is exiting\n",
service, getpid(), (unsigned long long)jid);
}
}
if (jid == (jid_t)0){
vsyslog(LOG_INFO, "(%s) POE(pid=%d): POE process is exiting. Not attached to any job\n",
service, getpid());
}
return PAM_SUCCESS;
}
/*
* Create job description structure based off srun options
* (see opt.h)
*/
job_desc_msg_t *
job_desc_msg_create_from_opts (void)
{
job_desc_msg_t *j = xmalloc(sizeof(*j));
hostlist_t hl = NULL;
slurm_init_job_desc_msg(j);
#if defined HAVE_ALPS_CRAY && defined HAVE_REAL_CRAY
uint64_t pagg_id = job_getjid(getpid());
/*
* Interactive sessions require pam_job.so in /etc/pam.d/common-session
* since creating sgi_job containers requires root permissions. This is
* the only exception where we allow the fallback of using the SID to
* confirm the reservation (caught later, in do_basil_confirm).
*/
if (pagg_id == (uint64_t)-1) {
error("No SGI job container ID detected - please enable the "
"Cray job service via /etc/init.d/job");
} else {
if (!j->select_jobinfo)
j->select_jobinfo = select_g_select_jobinfo_alloc();
select_g_select_jobinfo_set(j->select_jobinfo,
SELECT_JOBDATA_PAGG_ID, &pagg_id);
}
#endif
j->contiguous = opt.contiguous;
if (opt.core_spec)
j->core_spec = opt.core_spec;
j->features = opt.constraints;
j->gres = opt.gres;
if (opt.immediate == 1)
j->immediate = opt.immediate;
if (opt.job_name)
j->name = opt.job_name;
else
j->name = opt.cmd_name;
if (opt.argc > 0) {
j->argc = 1;
j->argv = (char **) xmalloc(sizeof(char *) * 2);
j->argv[0] = xstrdup(opt.argv[0]);
}
if (opt.acctg_freq)
j->acctg_freq = xstrdup(opt.acctg_freq);
j->reservation = opt.reservation;
j->wckey = opt.wckey;
j->req_nodes = xstrdup(opt.nodelist);
/* simplify the job allocation nodelist,
* not laying out tasks until step */
if (j->req_nodes) {
hl = hostlist_create(j->req_nodes);
xfree(opt.nodelist);
opt.nodelist = hostlist_ranged_string_xmalloc(hl);
hostlist_uniq(hl);
xfree(j->req_nodes);
j->req_nodes = hostlist_ranged_string_xmalloc(hl);
hostlist_destroy(hl);
}
if (opt.distribution == SLURM_DIST_ARBITRARY
&& !j->req_nodes) {
error("With Arbitrary distribution you need to "
"specify a nodelist or hostfile with the -w option");
return NULL;
}
j->exc_nodes = opt.exc_nodes;
j->partition = opt.partition;
j->min_nodes = opt.min_nodes;
if (opt.sockets_per_node != NO_VAL)
j->sockets_per_node = opt.sockets_per_node;
if (opt.cores_per_socket != NO_VAL)
j->cores_per_socket = opt.cores_per_socket;
if (opt.threads_per_core != NO_VAL)
j->threads_per_core = opt.threads_per_core;
j->user_id = opt.uid;
j->dependency = opt.dependency;
if (opt.nice)
j->nice = NICE_OFFSET + opt.nice;
if (opt.priority)
j->priority = opt.priority;
if (opt.cpu_bind)
j->cpu_bind = opt.cpu_bind;
if (opt.cpu_bind_type)
j->cpu_bind_type = opt.cpu_bind_type;
if (opt.mem_bind)
j->mem_bind = opt.mem_bind;
if (opt.mem_bind_type)
j->mem_bind_type = opt.mem_bind_type;
if (opt.plane_size != NO_VAL)
j->plane_size = opt.plane_size;
j->task_dist = opt.distribution;
j->group_id = opt.gid;
j->mail_type = opt.mail_type;
if (opt.ntasks_per_node != NO_VAL)
j->ntasks_per_node = opt.ntasks_per_node;
if (opt.ntasks_per_socket != NO_VAL)
j->ntasks_per_socket = opt.ntasks_per_socket;
if (opt.ntasks_per_core != NO_VAL)
j->ntasks_per_core = opt.ntasks_per_core;
if (opt.mail_user)
j->mail_user = opt.mail_user;
if (opt.begin)
j->begin_time = opt.begin;
if (opt.licenses)
j->licenses = opt.licenses;
if (opt.network)
j->network = opt.network;
if (opt.profile)
j->profile = opt.profile;
if (opt.account)
j->account = opt.account;
if (opt.comment)
j->comment = opt.comment;
if (opt.qos)
j->qos = opt.qos;
if (opt.cwd)
j->work_dir = opt.cwd;
if (opt.hold)
j->priority = 0;
if (opt.jobid != NO_VAL)
j->job_id = opt.jobid;
#ifdef HAVE_BG
if (opt.geometry[0] > 0) {
int i;
for (i = 0; i < SYSTEM_DIMENSIONS; i++)
j->geometry[i] = opt.geometry[i];
}
#endif
memcpy(j->conn_type, opt.conn_type, sizeof(j->conn_type));
if (opt.reboot)
j->reboot = 1;
if (opt.no_rotate)
j->rotate = 0;
if (opt.blrtsimage)
j->blrtsimage = opt.blrtsimage;
if (opt.linuximage)
j->linuximage = opt.linuximage;
if (opt.mloaderimage)
j->mloaderimage = opt.mloaderimage;
if (opt.ramdiskimage)
j->ramdiskimage = opt.ramdiskimage;
if (opt.max_nodes)
j->max_nodes = opt.max_nodes;
else if (opt.nodes_set) {
/* On an allocation if the max nodes isn't set set it
* to do the same behavior as with salloc or sbatch.
*/
j->max_nodes = opt.min_nodes;
}
if (opt.pn_min_cpus != NO_VAL)
j->pn_min_cpus = opt.pn_min_cpus;
if (opt.pn_min_memory != NO_VAL)
j->pn_min_memory = opt.pn_min_memory;
else if (opt.mem_per_cpu != NO_VAL)
j->pn_min_memory = opt.mem_per_cpu | MEM_PER_CPU;
if (opt.pn_min_tmp_disk != NO_VAL)
j->pn_min_tmp_disk = opt.pn_min_tmp_disk;
if (opt.overcommit) {
j->min_cpus = opt.min_nodes;
j->overcommit = opt.overcommit;
} else if (opt.cpus_set)
j->min_cpus = opt.ntasks * opt.cpus_per_task;
else
j->min_cpus = opt.ntasks;
if (opt.ntasks_set)
j->num_tasks = opt.ntasks;
if (opt.cpus_set)
j->cpus_per_task = opt.cpus_per_task;
if (opt.no_kill)
j->kill_on_node_fail = 0;
if (opt.time_limit != NO_VAL)
j->time_limit = opt.time_limit;
if (opt.time_min != NO_VAL)
j->time_min = opt.time_min;
j->shared = opt.shared;
if (opt.warn_signal)
j->warn_signal = opt.warn_signal;
if (opt.warn_time)
j->warn_time = opt.warn_time;
if (opt.req_switch >= 0)
j->req_switch = opt.req_switch;
if (opt.wait4switch >= 0)
j->wait4switch = opt.wait4switch;
/* srun uses the same listening port for the allocation response
* message as all other messages */
j->alloc_resp_port = slurmctld_comm_addr.port;
j->other_port = slurmctld_comm_addr.port;
if (opt.spank_job_env_size) {
j->spank_job_env = opt.spank_job_env;
j->spank_job_env_size = opt.spank_job_env_size;
}
return (j);
}
/*
* init() - initialize the program.
*/
int
init(int argc, char **argv)
{
int file_exists = 1;
extern int optind;
extern char *optarg;
Prg_name = argv[0];
/* Process command options. */
init_irix(argc, argv);
/* Process operands. */
if (optind + 1 == argc) {
fn = argv[optind];
} else if (optind != argc) {
usage();
}
/* Construct the job accounting file name, if not provided. */
if (fn == NULL) {
uint64_t myjid = 0; /* job ID of job ja is running in */
pid_t pid; /* PID of job */
int fnl; /* length of file name (bytes) */
char *dir; /* pointer to directory name for */
/* default job accounting file */
char tmp[] = "/tmp";
/* Make sure this process is part of a job by fetching it's job ID. */
pid = getpid();
myjid = job_getjid(pid);
if (myjid == 0) {
acct_err(ACCT_ABORT,
_("The process running does not have a valid Job ID."));
}
fn = fname;
if ((dir = getenv(ACCT_TMPDIR)) == NULL &&
(dir = getenv("TMPDIR")) == NULL) {
dir = tmp;
}
if ((fnl = sprintf(fn, "%s/.jacct%llx", dir, myjid)) < 0) {
acct_err(ACCT_ABORT,
_("Cannot build the file name from the TMPDIR environment variable and the Job ID.")
);
}
if (fnl >= MAX_FNAME) {
acct_err(ACCT_ABORT,
_("The file name exceeds the maximum length of 128 characters.")
);
}
temp_file = TRUE;
}
/* Get the parameters from the configuration file. */
init_config();
/* Initialize daemon pointers if necessary. */
#ifdef WKMG_HERE
if (d_opt) {
if ((nqhdr = (struct nqshdr *)malloc(sizeof(struct nqshdr))) ==
NULL) {
acct_perr(ACCT_ABORT, errno,
_("There was insufficient memory available when allocating '%s'."),
"nqshdr");
}
nqhdr->head = nqhdr->last = NULL;
/* add Workload Management code here */
}
#endif
return(file_exists);
}
/* Returns 0 on success, -1 on failure */
static int _fill_job_desc_from_opts(job_desc_msg_t *desc)
{
#ifdef HAVE_REAL_CRAY
uint64_t pagg_id = job_getjid(getpid());
/*
* Interactive sessions require pam_job.so in /etc/pam.d/common-session
* since creating sgi_job containers requires root permissions. This is
* the only exception where we allow the fallback of using the SID to
* confirm the reservation (caught later, in do_basil_confirm).
*/
if (pagg_id == (uint64_t)-1) {
error("No SGI job container ID detected - please enable the "
"Cray job service via /etc/init.d/job");
} else {
if (!desc->select_jobinfo)
desc->select_jobinfo = select_g_select_jobinfo_alloc();
select_g_select_jobinfo_set(desc->select_jobinfo,
SELECT_JOBDATA_PAGG_ID, &pagg_id);
}
#endif
desc->contiguous = opt.contiguous ? 1 : 0;
desc->features = opt.constraints;
desc->gres = opt.gres;
if (opt.immediate == 1)
desc->immediate = 1;
desc->name = xstrdup(opt.job_name);
desc->reservation = xstrdup(opt.reservation);
desc->wckey = xstrdup(opt.wckey);
desc->req_nodes = opt.nodelist;
desc->exc_nodes = opt.exc_nodes;
desc->partition = opt.partition;
desc->min_nodes = opt.min_nodes;
if (opt.max_nodes)
desc->max_nodes = opt.max_nodes;
desc->user_id = opt.uid;
desc->group_id = opt.gid;
if (opt.dependency)
desc->dependency = xstrdup(opt.dependency);
if (opt.cpu_bind)
desc->cpu_bind = opt.cpu_bind;
if (opt.cpu_bind_type)
desc->cpu_bind_type = opt.cpu_bind_type;
if (opt.mem_bind)
desc->mem_bind = opt.mem_bind;
if (opt.mem_bind_type)
desc->mem_bind_type = opt.mem_bind_type;
if (opt.plane_size != NO_VAL)
desc->plane_size = opt.plane_size;
desc->task_dist = opt.distribution;
if (opt.plane_size != NO_VAL)
desc->plane_size = opt.plane_size;
if (opt.licenses)
desc->licenses = xstrdup(opt.licenses);
desc->network = opt.network;
if (opt.nice)
desc->nice = NICE_OFFSET + opt.nice;
desc->mail_type = opt.mail_type;
if (opt.mail_user)
desc->mail_user = xstrdup(opt.mail_user);
if (opt.begin)
desc->begin_time = opt.begin;
if (opt.account)
desc->account = xstrdup(opt.account);
if (opt.acctg_freq >= 0)
desc->acctg_freq = opt.acctg_freq;
if (opt.comment)
desc->comment = xstrdup(opt.comment);
if (opt.qos)
desc->qos = xstrdup(opt.qos);
if (opt.cwd)
desc->work_dir = xstrdup(opt.cwd);
else if (work_dir)
desc->work_dir = xstrdup(work_dir);
if (opt.hold)
desc->priority = 0;
#ifdef HAVE_BG
if (opt.geometry[0] > 0) {
int i;
for (i=0; i<SYSTEM_DIMENSIONS; i++)
desc->geometry[i] = opt.geometry[i];
}
#endif
if (opt.conn_type != (uint16_t)NO_VAL)
desc->conn_type[0] = opt.conn_type;
if (opt.reboot)
desc->reboot = 1;
if (opt.no_rotate)
desc->rotate = 0;
if (opt.blrtsimage)
desc->blrtsimage = xstrdup(opt.blrtsimage);
if (opt.linuximage)
desc->linuximage = xstrdup(opt.linuximage);
if (opt.mloaderimage)
desc->mloaderimage = xstrdup(opt.mloaderimage);
if (opt.ramdiskimage)
desc->ramdiskimage = xstrdup(opt.ramdiskimage);
/* job constraints */
if (opt.mincpus > -1)
desc->pn_min_cpus = opt.mincpus;
if (opt.realmem > -1)
desc->pn_min_memory = opt.realmem;
else if (opt.mem_per_cpu > -1)
desc->pn_min_memory = opt.mem_per_cpu | MEM_PER_CPU;
if (opt.tmpdisk > -1)
desc->pn_min_tmp_disk = opt.tmpdisk;
if (opt.overcommit) {
desc->min_cpus = opt.min_nodes;
desc->overcommit = opt.overcommit;
} else
desc->min_cpus = opt.ntasks * opt.cpus_per_task;
if (opt.ntasks_set)
desc->num_tasks = opt.ntasks;
if (opt.cpus_set)
desc->cpus_per_task = opt.cpus_per_task;
if (opt.ntasks_per_node)
desc->ntasks_per_node = opt.ntasks_per_node;
if (opt.ntasks_per_socket > -1)
desc->ntasks_per_socket = opt.ntasks_per_socket;
if (opt.ntasks_per_core > -1)
desc->ntasks_per_core = opt.ntasks_per_core;
/* node constraints */
if (opt.sockets_per_node != NO_VAL)
desc->sockets_per_node = opt.sockets_per_node;
if (opt.cores_per_socket != NO_VAL)
desc->cores_per_socket = opt.cores_per_socket;
if (opt.threads_per_core != NO_VAL)
desc->threads_per_core = opt.threads_per_core;
if (opt.no_kill)
desc->kill_on_node_fail = 0;
if (opt.time_limit != NO_VAL)
desc->time_limit = opt.time_limit;
if (opt.time_min != NO_VAL)
desc->time_min = opt.time_min;
desc->shared = opt.shared;
desc->job_id = opt.jobid;
desc->wait_all_nodes = opt.wait_all_nodes;
if (opt.warn_signal)
desc->warn_signal = opt.warn_signal;
if (opt.warn_time)
desc->warn_time = opt.warn_time;
if (opt.spank_job_env_size) {
desc->spank_job_env = opt.spank_job_env;
desc->spank_job_env_size = opt.spank_job_env_size;
}
return 0;
}
/*
* Create job description structure based off srun options
* (see opt.h)
*/
static job_desc_msg_t *_job_desc_msg_create_from_opts(slurm_opt_t *opt_local)
{
srun_opt_t *srun_opt = opt_local->srun_opt;
job_desc_msg_t *j = xmalloc(sizeof(*j));
hostlist_t hl = NULL;
xassert(srun_opt);
slurm_init_job_desc_msg(j);
#if defined HAVE_ALPS_CRAY && defined HAVE_REAL_CRAY
static bool sgi_err_logged = false;
uint64_t pagg_id = job_getjid(getpid());
/*
* Interactive sessions require pam_job.so in /etc/pam.d/common-session
* since creating sgi_job containers requires root permissions. This is
* the only exception where we allow the fallback of using the SID to
* confirm the reservation (caught later, in do_basil_confirm).
*/
if (pagg_id != (uint64_t) -1) {
if (!j->select_jobinfo)
j->select_jobinfo = select_g_select_jobinfo_alloc();
select_g_select_jobinfo_set(j->select_jobinfo,
SELECT_JOBDATA_PAGG_ID, &pagg_id);
} else if (!sgi_err_logged) {
error("No SGI job container ID detected - please enable the "
"Cray job service via /etc/init.d/job");
sgi_err_logged = true;
}
#endif
j->contiguous = opt_local->contiguous;
if (opt_local->core_spec != NO_VAL16)
j->core_spec = opt_local->core_spec;
j->features = opt_local->constraints;
j->cluster_features = opt_local->c_constraints;
if (opt_local->gres && xstrcasecmp(opt_local->gres, "NONE"))
j->gres = opt_local->gres;
if (opt_local->immediate == 1)
j->immediate = opt_local->immediate;
if (opt_local->job_name)
j->name = opt_local->job_name;
else
j->name = srun_opt->cmd_name;
if (srun_opt->argc > 0) {
j->argc = 1;
j->argv = (char **) xmalloc(sizeof(char *) * 2);
j->argv[0] = xstrdup(srun_opt->argv[0]);
}
if (opt_local->acctg_freq)
j->acctg_freq = xstrdup(opt_local->acctg_freq);
j->reservation = opt_local->reservation;
j->wckey = opt_local->wckey;
j->x11 = opt.x11;
if (j->x11) {
j->x11_magic_cookie = xstrdup(opt.x11_magic_cookie);
j->x11_target_port = opt.x11_target_port;
}
j->req_nodes = xstrdup(opt_local->nodelist);
/* simplify the job allocation nodelist,
* not laying out tasks until step */
if (j->req_nodes) {
hl = hostlist_create(j->req_nodes);
xfree(opt_local->nodelist);
opt_local->nodelist = hostlist_ranged_string_xmalloc(hl);
hostlist_uniq(hl);
xfree(j->req_nodes);
j->req_nodes = hostlist_ranged_string_xmalloc(hl);
hostlist_destroy(hl);
}
if (((opt_local->distribution & SLURM_DIST_STATE_BASE) ==
SLURM_DIST_ARBITRARY) && !j->req_nodes) {
error("With Arbitrary distribution you need to "
"specify a nodelist or hostfile with the -w option");
return NULL;
}
j->extra = opt_local->extra;
j->exc_nodes = opt_local->exc_nodes;
j->partition = opt_local->partition;
j->min_nodes = opt_local->min_nodes;
if (opt_local->sockets_per_node != NO_VAL)
j->sockets_per_node = opt_local->sockets_per_node;
if (opt_local->cores_per_socket != NO_VAL)
j->cores_per_socket = opt_local->cores_per_socket;
if (opt_local->threads_per_core != NO_VAL) {
j->threads_per_core = opt_local->threads_per_core;
/* if 1 always make sure affinity knows about it */
if (j->threads_per_core == 1)
srun_opt->cpu_bind_type |= CPU_BIND_ONE_THREAD_PER_CORE;
}
j->user_id = opt_local->uid;
j->dependency = opt_local->dependency;
if (opt_local->nice != NO_VAL)
j->nice = NICE_OFFSET + opt_local->nice;
if (opt_local->priority)
j->priority = opt_local->priority;
if (srun_opt->cpu_bind)
j->cpu_bind = srun_opt->cpu_bind;
if (srun_opt->cpu_bind_type)
j->cpu_bind_type = srun_opt->cpu_bind_type;
if (opt_local->delay_boot != NO_VAL)
j->delay_boot = opt_local->delay_boot;
if (opt_local->mem_bind)
j->mem_bind = opt_local->mem_bind;
if (opt_local->mem_bind_type)
j->mem_bind_type = opt_local->mem_bind_type;
if (opt_local->plane_size != NO_VAL)
j->plane_size = opt_local->plane_size;
j->task_dist = opt_local->distribution;
j->group_id = opt_local->gid;
j->mail_type = opt_local->mail_type;
if (opt_local->ntasks_per_node != NO_VAL)
j->ntasks_per_node = opt_local->ntasks_per_node;
if (opt_local->ntasks_per_socket != NO_VAL)
j->ntasks_per_socket = opt_local->ntasks_per_socket;
if (opt_local->ntasks_per_core != NO_VAL)
j->ntasks_per_core = opt_local->ntasks_per_core;
if (opt_local->mail_user)
j->mail_user = opt_local->mail_user;
if (opt_local->burst_buffer)
j->burst_buffer = opt_local->burst_buffer;
if (opt_local->begin)
j->begin_time = opt_local->begin;
if (opt_local->deadline)
j->deadline = opt_local->deadline;
if (opt_local->licenses)
j->licenses = opt_local->licenses;
if (opt_local->network)
j->network = opt_local->network;
if (opt_local->profile)
j->profile = opt_local->profile;
if (opt_local->account)
j->account = opt_local->account;
if (opt_local->comment)
j->comment = opt_local->comment;
if (opt_local->qos)
j->qos = opt_local->qos;
if (opt_local->cwd)
j->work_dir = opt_local->cwd;
if (opt_local->hold)
j->priority = 0;
if (opt_local->jobid != NO_VAL)
j->job_id = opt_local->jobid;
#ifdef HAVE_BG
if (opt_local->geometry[0] > 0) {
int i;
for (i = 0; i < SYSTEM_DIMENSIONS; i++)
j->geometry[i] = opt_local->geometry[i];
}
#endif
memcpy(j->conn_type, opt_local->conn_type, sizeof(j->conn_type));
if (opt_local->reboot)
j->reboot = 1;
if (opt_local->no_rotate)
j->rotate = 0;
if (opt_local->blrtsimage)
j->blrtsimage = opt_local->blrtsimage;
if (opt_local->linuximage)
j->linuximage = opt_local->linuximage;
if (opt_local->mloaderimage)
j->mloaderimage = opt_local->mloaderimage;
if (opt_local->ramdiskimage)
j->ramdiskimage = opt_local->ramdiskimage;
if (opt_local->max_nodes)
j->max_nodes = opt_local->max_nodes;
else if (opt_local->nodes_set) {
/* On an allocation if the max nodes isn't set set it
* to do the same behavior as with salloc or sbatch.
*/
j->max_nodes = opt_local->min_nodes;
}
if (opt_local->pn_min_cpus != NO_VAL)
j->pn_min_cpus = opt_local->pn_min_cpus;
if (opt_local->pn_min_memory != NO_VAL64)
j->pn_min_memory = opt_local->pn_min_memory;
else if (opt_local->mem_per_cpu != NO_VAL64)
j->pn_min_memory = opt_local->mem_per_cpu | MEM_PER_CPU;
if (opt_local->pn_min_tmp_disk != NO_VAL)
j->pn_min_tmp_disk = opt_local->pn_min_tmp_disk;
if (opt_local->overcommit) {
j->min_cpus = opt_local->min_nodes;
j->overcommit = opt_local->overcommit;
} else if (opt_local->cpus_set)
j->min_cpus = opt_local->ntasks * opt_local->cpus_per_task;
else
j->min_cpus = opt_local->ntasks;
if (opt_local->ntasks_set)
j->num_tasks = opt_local->ntasks;
if (opt_local->cpus_set)
j->cpus_per_task = opt_local->cpus_per_task;
if (opt_local->no_kill)
j->kill_on_node_fail = 0;
if (opt_local->time_limit != NO_VAL)
j->time_limit = opt_local->time_limit;
if (opt_local->time_min != NO_VAL)
j->time_min = opt_local->time_min;
if (opt_local->shared != NO_VAL16)
j->shared = opt_local->shared;
if (opt_local->warn_signal)
j->warn_signal = opt_local->warn_signal;
if (opt_local->warn_time)
j->warn_time = opt_local->warn_time;
if (opt_local->job_flags)
j->bitflags = opt_local->job_flags;
if (opt_local->cpu_freq_min != NO_VAL)
j->cpu_freq_min = opt_local->cpu_freq_min;
if (opt_local->cpu_freq_max != NO_VAL)
j->cpu_freq_max = opt_local->cpu_freq_max;
if (opt_local->cpu_freq_gov != NO_VAL)
j->cpu_freq_gov = opt_local->cpu_freq_gov;
if (opt_local->req_switch >= 0)
j->req_switch = opt_local->req_switch;
if (opt_local->wait4switch >= 0)
j->wait4switch = opt_local->wait4switch;
/* srun uses the same listening port for the allocation response
* message as all other messages */
j->alloc_resp_port = slurmctld_comm_addr.port;
j->other_port = slurmctld_comm_addr.port;
if (opt_local->spank_job_env_size) {
j->spank_job_env = opt_local->spank_job_env;
j->spank_job_env_size = opt_local->spank_job_env_size;
}
if (opt_local->power_flags)
j->power_flags = opt_local->power_flags;
if (opt_local->mcs_label)
j->mcs_label = opt_local->mcs_label;
j->wait_all_nodes = 1;
/* If can run on multiple clusters find the earliest run time
* and run it there */
j->clusters = xstrdup(opt_local->clusters);
return j;
}
