void pnpbios_calls_init(union pnp_bios_install_struct *header)
{
int i;
spin_lock_init(&pnp_bios_lock);
pnp_bios_callpoint.offset = header->fields.pm16offset;
pnp_bios_callpoint.segment = PNP_CS16;
set_base(bad_bios_desc, __va((unsigned long)0x40 << 4));
_set_limit((char *)&bad_bios_desc, 4095 - (0x40 << 4));
for (i = 0; i < NR_CPUS; i++) {
struct desc_struct *gdt = get_cpu_gdt_table(i);
if (!gdt)
continue;
set_base(gdt[GDT_ENTRY_PNPBIOS_CS32], &pnp_bios_callfunc);
set_base(gdt[GDT_ENTRY_PNPBIOS_CS16],
__va(header->fields.pm16cseg));
set_base(gdt[GDT_ENTRY_PNPBIOS_DS],
__va(header->fields.pm16dseg));
}
}
int set_user_limits(stepd_step_rec_t *job)
{
slurm_rlimits_info_t *rli;
struct rlimit r;
rlim_t task_mem_bytes;
if (getrlimit(RLIMIT_CPU, &r) == 0) {
if (r.rlim_max != RLIM_INFINITY) {
error("SLURM process CPU time limit is %d seconds",
(int) r.rlim_max);
}
}
for (rli = get_slurm_rlimits_info(); rli->name; rli++)
_set_limit( job->env, rli );
/* Set soft and hard memory and data size limit for this process,
* handle job limit (for all spawned processes) in slurmd */
task_mem_bytes = job->step_mem; /* MB */
task_mem_bytes *= (1024 * 1024);
#ifdef RLIMIT_DATA
if ((task_mem_bytes) && (getrlimit(RLIMIT_DATA, &r) == 0) &&
(r.rlim_max > task_mem_bytes)) {
r.rlim_max = r.rlim_cur = task_mem_bytes;
if (setrlimit(RLIMIT_DATA, &r)) {
/* Indicates that limit has already been exceeded */
fatal("setrlimit(RLIMIT_DATA, %u MB): %m",
job->step_mem);
} else
debug2("Set task_data(%u MB)", job->step_mem);
#if 0
getrlimit(RLIMIT_DATA, &r);
info("task DATA limits: %u %u", r.rlim_cur, r.rlim_max);
#endif
}
#endif
return SLURM_SUCCESS;
}
int set_user_limits(stepd_step_rec_t *job)
{
#ifdef RLIMIT_AS
#define SLURM_RLIMIT_VSIZE RLIMIT_AS
#define SLURM_RLIMIT_VNAME "RLIMIT_AS"
#elif defined(RLIMIT_DATA)
/* RLIMIT_DATA is useless on many systems which provide anonymous
* mmap()'s in addition to brk(), use it here only as a fallback for
* oddball systems lacking RLIMIT_AS. */
#define SLURM_RLIMIT_VSIZE RLIMIT_DATA
#define SLURM_RLIMIT_VNAME "RLIMIT_DATA"
#endif
slurm_rlimits_info_t *rli;
struct rlimit r;
rlim_t task_mem_bytes;
#ifdef SLURM_RLIMIT_VSIZE
uint16_t vsize_factor;
#endif
if (getrlimit(RLIMIT_CPU, &r) == 0) {
if (r.rlim_max != RLIM_INFINITY) {
error("SLURM process CPU time limit is %d seconds",
(int) r.rlim_max);
}
}
for (rli = get_slurm_rlimits_info(); rli->name; rli++)
_set_limit( job->env, rli );
/* Set soft and hard rss and vsize limit for this process,
* handle job limit (for all spawned processes) in slurmd */
task_mem_bytes = job->step_mem; /* MB */
task_mem_bytes *= (1024 * 1024);
/* Many systems, Linux included, ignore RSS limits, but set it
* here anyway for consistency and to provide a way for
* applications to interrogate what the RSS limit is (with the
* caveat that the real RSS limit is over all job tasks on the
* node and not per process, but hopefully this is better than
* nothing). */
#ifdef RLIMIT_RSS
if ((task_mem_bytes) && (getrlimit(RLIMIT_RSS, &r) == 0) &&
(r.rlim_max > task_mem_bytes)) {
r.rlim_max = r.rlim_cur = task_mem_bytes;
if (setrlimit(RLIMIT_RSS, &r)) {
/* Indicates that limit has already been exceeded */
fatal("setrlimit(RLIMIT_RSS, %u MB): %m",
job->step_mem);
} else
debug2("Set task rss(%u MB)", job->step_mem);
#if 0
getrlimit(RLIMIT_RSS, &r);
info("task RSS limits: %u %u", r.rlim_cur, r.rlim_max);
#endif
}
#endif
#ifdef SLURM_RLIMIT_VSIZE
if ((task_mem_bytes) &&
((vsize_factor = slurm_get_vsize_factor()) != 0) &&
(getrlimit(SLURM_RLIMIT_VSIZE, &r) == 0) &&
(r.rlim_max > task_mem_bytes)) {
r.rlim_max = task_mem_bytes * (vsize_factor / 100.0);
r.rlim_cur = r.rlim_max;
if (setrlimit(SLURM_RLIMIT_VSIZE, &r)) {
/* Indicates that limit has already been exceeded */
fatal("setrlimit(%s, %u MB): %m",
SLURM_RLIMIT_VNAME, job->step_mem);
} else
debug2("Set task vsize(%u MB)", job->step_mem);
#if 0
getrlimit(SLURM_RLIMIT_VSIZE, &r);
info("task VSIZE limits: %u %u", r.rlim_cur, r.rlim_max);
#endif
}
#endif
return SLURM_SUCCESS;
}
