int main(void) {
prlimit();
return 0;
}
int main(int argc, char* argv[]) {
struct rlimit* r;
struct rlimit* r2;
ALLOCATE_GUARD(r, 0);
ALLOCATE_GUARD(r2, 'x');
test_assert(0 == getrlimit(RLIMIT_FSIZE, r));
test_assert(r->rlim_cur > 0);
test_assert(r->rlim_max > 0);
VERIFY_GUARD(r);
r->rlim_cur /= 2;
test_assert(0 == setrlimit(RLIMIT_FSIZE, r));
VERIFY_GUARD(r);
test_assert(0 == getrlimit(RLIMIT_FSIZE, r2));
test_assert(r2->rlim_cur == r->rlim_cur);
VERIFY_GUARD(r2);
test_assert(0 == prlimit(0, RLIMIT_FSIZE, r, r2));
test_assert(r2->rlim_cur == r->rlim_cur);
VERIFY_GUARD(r);
VERIFY_GUARD(r2);
atomic_puts("EXIT-SUCCESS");
return 0;
}
static int
virProcessPrLimit(pid_t pid,
int resource,
const struct rlimit *new_limit,
struct rlimit *old_limit)
{
return prlimit(pid, resource, new_limit, old_limit);
}
static int proc_protect(struct judgx_proc_info *proc_info){
cap_t caps;
struct rlimit limit;
struct judgx_com_proc_add com_proc_add;
/*caps = cap_init();
if(cap_set_file(proc_info->path,caps)){
cap_free(caps);
goto error;
}
cap_free(caps);*/
limit.rlim_cur = 1;
limit.rlim_max = limit.rlim_cur;
prlimit(proc_info->pid,RLIMIT_NPROC,&limit,NULL);
limit.rlim_cur = 4L;
limit.rlim_max = limit.rlim_cur;
prlimit(proc_info->pid,RLIMIT_NOFILE,&limit,NULL);
limit.rlim_cur = (proc_info->timelimit) / 1000L + 1L;
limit.rlim_max = limit.rlim_cur;
prlimit(proc_info->pid,RLIMIT_CPU,&limit,NULL);
/*limit.rlim_cur = proc_info->memlimit * 1024L + 4096L * 128L;
limit.rlim_max = limit.rlim_cur;
prlimit(proc_info->pid,RLIMIT_AS,&limit,NULL);*/
com_proc_add.path[0] = '\0';
strncat(com_proc_add.path,proc_info->exe_path,sizeof(com_proc_add.path));
com_proc_add.pid = proc_info->pid;
com_proc_add.memlimit = proc_info->memlimit * 1024L + 4096L * 128L;
if(ioctl(judgx_modfd,IOCTL_PROC_ADD,&com_proc_add)){
return -1;
}
proc_info->task = com_proc_add.task;
return 0;
}
void SysResourceTest::CheckResourceLimits() {
ASSERT_EQ(0, getrlimit(RLIMIT_CORE, &l32_));
ASSERT_EQ(0, getrlimit64(RLIMIT_CORE, &l64_));
ASSERT_EQ(0, prlimit(0, RLIMIT_CORE, nullptr, &pr_l32_));
ASSERT_EQ(0, prlimit64(0, RLIMIT_CORE, nullptr, &pr_l64_));
ASSERT_EQ(l32_.rlim_cur, pr_l32_.rlim_cur);
ASSERT_EQ(l64_.rlim_cur, pr_l64_.rlim_cur);
if (l64_.rlim_cur == RLIM64_INFINITY) {
ASSERT_EQ(RLIM_INFINITY, l32_.rlim_cur);
} else {
ASSERT_EQ(l64_.rlim_cur, l32_.rlim_cur);
}
ASSERT_EQ(l32_.rlim_max, pr_l32_.rlim_max);
ASSERT_EQ(l64_.rlim_max, pr_l64_.rlim_max);
if (l64_.rlim_max == RLIM64_INFINITY) {
ASSERT_EQ(RLIM_INFINITY, l32_.rlim_max);
} else {
ASSERT_EQ(l64_.rlim_max, l32_.rlim_max);
}
}
static int
virProcessPrLimit(pid_t pid, int resource, struct rlimit *rlim)
{
return prlimit(pid, resource, rlim, NULL);
}
lim.rlim_max = MAX_LIMIT_NUM_FD;
}
}
// Move the iterator back to where it was.
LE_ASSERT(le_cfg_GoToParent(procCfg) == LE_OK);
}
// Hard and soft limits are the same.
lim.rlim_cur = lim.rlim_max;
// @todo: Should report the resource name as something more readable than the node name in the
// config tree.
LE_INFO("Setting resource limit %s to value %d.", resourceName, (int)lim.rlim_max);
LE_ERROR_IF(prlimit(pid, resourceID, &lim, NULL) == -1,
"Could not set resource limit %s (%d). %m.", resourceName, resourceID);
}
//--------------------------------------------------------------------------------------------------
/**
* Sets the resource limits for the specified application.
*/
//--------------------------------------------------------------------------------------------------
void resLim_SetAppLimits
(
app_Ref_t appRef ///< [IN] The application to set resource limits for.
)
{
// Get the application's user name for use with cgroups.
int main(int argc, char **argv)
{
struct rlimit limit;
char soft[22], hard[22];
pid_t pid;
int index = 0;
if (argc < 2 || !strcmp(argv[1], "-h"))
{
return usage();
}
if (!(pid = atol(argv[1])) || (!geteuid() && kill(pid, 0)))
{
fprintf(stderr, "invalid PID %s\n", argv[1]);
return -2;
}
if (argc < 3)
{
return usage();
}
if (!strcmp(argv[2], "-a"))
{
printf("Limit Soft Limit Hard Limit Units Option\n");
while (limits[index].description)
{
if (!prlimit(pid, limits[index].resource, NULL, &limit))
{
if (limit.rlim_cur != RLIM_INFINITY)
{
sprintf(soft, "%ld", limit.rlim_cur);
}
else
{
strcpy(soft, "unlimited");
}
if (limit.rlim_max != RLIM_INFINITY)
{
sprintf(hard, "%ld", limit.rlim_max);
}
else
{
strcpy(hard, "unlimited");
}
}
else
{
strcpy(soft, "unknown");
strcpy(hard, "unknown");
}
printf("%-26.26s%-21.21s%-21.21s%-15.15s-%c\n", limits[index].description, soft, hard, limits[index].units, limits[index].option);
index++;
}
return 0;
}
if (argc < 4 || strlen(argv[2]) != 2 || argv[2][0] != '-')
{
return usage();
}
while (limits[index].description)
{
if (argv[2][1] == limits[index].option)
{
break;
}
index++;
}
if (!limits[index].description)
{
fprintf(stderr, "unknown option %s\n", argv[2]);
return usage();
}
limit.rlim_cur = limit.rlim_max = atol(argv[3]);
if (prlimit(pid, limits[index].resource, &limit, NULL))
{
perror("rlimit");
return -3;
}
return 0;
}
TEST_F(SysResourceTest, prlimit) {
pr_l32_.rlim_cur = pr_l32_.rlim_max;
ASSERT_EQ(0, prlimit(0, RLIMIT_CORE, &pr_l32_, nullptr));
CheckResourceLimits();
ASSERT_EQ(pr_l32_.rlim_max, pr_l32_.rlim_cur);
}
void SetUp() override {
ASSERT_EQ(0, getrlimit(RLIMIT_CORE, &l32_));
ASSERT_EQ(0, getrlimit64(RLIMIT_CORE, &l64_));
ASSERT_EQ(0, prlimit(0, RLIMIT_CORE, nullptr, &pr_l32_));
ASSERT_EQ(0, prlimit64(0, RLIMIT_CORE, nullptr, &pr_l64_));
}
