AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-12-23 03:10:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add test for getrlimit/setrlimit/prlimit with infinity value

Browse Source 
Add a test to check that the getrlimit, setrlimit and prlimit functions
and their 64-bit equivalent behave correctly with RLIM_INFINITY and
RLIM64_INFINITY. For that it assumes that the prlimit64 function calls
the syscall directly without translating the value and that the kernel
uses the -1 value to represent infinity.

It first finds a resource with the hard limit set to infinity so the
soft limit can be manipulated easily and check for the consistency
between the value set or get by the prlimit64 and the other functions.

It is Linux specific add it uses the prlimit and prlimit64 functions.

Changelog:
	* sysdeps/unix/sysv/linux/tst-rlimit-infinity.c: New file.
	* sysdeps/unix/sysv/linux/Makefile (tests): Add tst-rlimit-infinity.
This commit is contained in:
Aurelien Jarno 2018-01-05 20:34:10 +01:00
parent 24731685c8
commit 19be56d8ce
3 changed files with 178 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
ChangeLog
View File

@ -4,6 +4,9 @@
* sysdeps/unix/sysv/linux/prlimit.c (prlimit): Translate
old_rlimit from RLIM64_INFINITY to RLIM_INFINITY.
* sysdeps/unix/sysv/linux/tst-rlimit-infinity.c: New file.
* sysdeps/unix/sysv/linux/Makefile (tests): Add tst-rlimit-infinity.
2018-01-05 Aurelien Jarno <aurelien@aurel32.net>
Adhemerval Zanella <adhemerval.zanella@linaro.org>

3
sysdeps/unix/sysv/linux/Makefile
View File

@ -44,7 +44,8 @@ sysdep_headers += sys/mount.h sys/acct.h sys/sysctl.h \
tests += tst-clone tst-clone2 tst-clone3 tst-fanotify tst-personality \
tst-quota tst-sync_file_range tst-sysconf-iov_max tst-ttyname \
test-errno-linux tst-memfd_create tst-mlock2 tst-pkey
test-errno-linux tst-memfd_create tst-mlock2 tst-pkey \
tst-rlimit-infinity
# Generate the list of SYS_* macros for the system calls (__NR_*
# macros). The file syscall-names.list contains all possible system

173
sysdeps/unix/sysv/linux/tst-rlimit-infinity.c Normal file
View File

@ -0,0 +1,173 @@
/* Copyright (C) 2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <errno.h>
#include <stdio.h>
#include <sys/resource.h>
#include <support/check.h>
static int resources[] = {
/* The following 7 limits are part of POSIX and must exist. */
RLIMIT_CORE,
RLIMIT_CPU,
RLIMIT_DATA,
RLIMIT_FSIZE,
RLIMIT_NOFILE,
RLIMIT_STACK,
RLIMIT_AS
};
#define nresources (sizeof (resources) / sizeof (resources[0]))
/* Assume that the prlimit64 function calls the prlimit64 syscall without
mangling the arguments. */
#define PRLIMIT64_INFINITY ((rlim64_t) -1)
/* As we don't know which limit will be modified, use a sufficiently high
value to not shoot ourself in the foot. Use a 32-bit value to test
both the 32- and 64-bit versions, and keep the highest bit clear to
avoid sign extension. */
#define PRLIMIT64_TESTVAL ((rlim64_t) 0x42420000)
static void
test_getrlimit (int resource, rlim_t exp_cur, rlim_t exp_max)
{
struct rlimit r;
TEST_VERIFY_EXIT (getrlimit (resource, &r) == 0);
TEST_COMPARE (r.rlim_cur, exp_cur);
TEST_COMPARE (r.rlim_max, exp_max);
}
static void
test_getrlimit64 (int resource, rlim64_t exp_cur, rlim64_t exp_max)
{
struct rlimit64 r;
TEST_VERIFY_EXIT (getrlimit64 (resource, &r) == 0);
TEST_COMPARE (r.rlim_cur, exp_cur);
TEST_COMPARE (r.rlim_max, exp_max);
}
static void
test_prlimit_get (int resource, rlim_t exp_cur, rlim_t exp_max)
{
struct rlimit r;
TEST_VERIFY_EXIT (prlimit (0, resource, NULL, &r) == 0);
TEST_COMPARE (r.rlim_cur, exp_cur);
TEST_COMPARE (r.rlim_max, exp_max);
}
static void
test_prlimit64_get (int resource, rlim64_t exp_cur, rlim64_t exp_max)
{
struct rlimit64 r;
TEST_COMPARE (prlimit64 (0, resource, NULL, &r), 0);
TEST_COMPARE (r.rlim_cur, exp_cur);
TEST_COMPARE (r.rlim_max, exp_max);
}
static void
test_setrlimit (int resource, rlim_t new_cur, rlim_t new_max)
{
struct rlimit r = { new_cur, new_max };
TEST_COMPARE (setrlimit (resource, &r), 0);
}
static void
test_setrlimit64 (int resource, rlim64_t new_cur, rlim64_t new_max)
{
struct rlimit64 r = { new_cur, new_max };
TEST_COMPARE (setrlimit64 (resource, &r), 0);
}
static void
test_prlimit_set (int resource, rlim_t new_cur, rlim_t new_max)
{
struct rlimit r = { new_cur, new_max };
TEST_COMPARE (prlimit (0, resource, &r, NULL), 0);
}
static void
test_prlimit64_set (int resource, rlim64_t new_cur, rlim64_t new_max)
{
struct rlimit64 r = { new_cur, new_max };
TEST_COMPARE (prlimit64 (0, resource, &r, NULL), 0);
}
static int
do_test (void)
{
int resource = -1;
/* Find a resource with hard limit set to infinity, so that the soft limit
can be manipulated to any value. */
for (int i = 0; i < nresources; ++i)
{
struct rlimit64 r64;
int res = prlimit64 (0, resources[i], NULL, &r64);
if ((res == 0) && (r64.rlim_max == PRLIMIT64_INFINITY))
{
resource = resources[i];
break;
}
}
if (resource == -1)
FAIL_UNSUPPORTED
("Could not find and limit with hard limit set to infinity.");
/* First check that the get functions work correctly with the test value. */
test_prlimit64_set (resource, PRLIMIT64_TESTVAL, PRLIMIT64_INFINITY);
test_getrlimit (resource, PRLIMIT64_TESTVAL, RLIM_INFINITY);
test_getrlimit64 (resource, PRLIMIT64_TESTVAL, RLIM64_INFINITY);
test_prlimit_get (resource, PRLIMIT64_TESTVAL, RLIM_INFINITY);
test_prlimit64_get (resource, PRLIMIT64_TESTVAL, RLIM64_INFINITY);
/* Then check that the get functions work correctly with infinity. */
test_prlimit64_set (resource, PRLIMIT64_INFINITY, PRLIMIT64_INFINITY);
test_getrlimit (resource, RLIM_INFINITY, RLIM_INFINITY);
test_getrlimit64 (resource, RLIM64_INFINITY, RLIM64_INFINITY);
test_prlimit_get (resource, RLIM_INFINITY, RLIM_INFINITY);
test_prlimit64_get (resource, RLIM64_INFINITY, RLIM64_INFINITY);
/* Then check that setrlimit works correctly with the test value. */
test_setrlimit (resource, PRLIMIT64_TESTVAL, RLIM_INFINITY);
test_prlimit64_get (resource, PRLIMIT64_TESTVAL, PRLIMIT64_INFINITY);
/* Then check that setrlimit works correctly with infinity. */
test_setrlimit (resource, RLIM_INFINITY, RLIM_INFINITY);
test_prlimit64_get (resource, PRLIMIT64_INFINITY, PRLIMIT64_INFINITY);
/* Then check that setrlimit64 works correctly with the test value. */
test_setrlimit64 (resource, PRLIMIT64_TESTVAL, RLIM64_INFINITY);
test_prlimit64_get (resource, PRLIMIT64_TESTVAL, PRLIMIT64_INFINITY);
/* Then check that setrlimit64 works correctly with infinity. */
test_setrlimit64 (resource, RLIM64_INFINITY, RLIM64_INFINITY);
test_prlimit64_get (resource, PRLIMIT64_INFINITY, PRLIMIT64_INFINITY);
/* Then check that prlimit works correctly with the test value. */
test_prlimit_set (resource, RLIM_INFINITY, RLIM_INFINITY);
test_prlimit64_get (resource, PRLIMIT64_INFINITY, PRLIMIT64_INFINITY);
/* Finally check that prlimit works correctly with infinity. */
test_prlimit_set (resource, PRLIMIT64_TESTVAL, RLIM_INFINITY);
test_prlimit64_get (resource, PRLIMIT64_TESTVAL, PRLIMIT64_INFINITY);
return 0;
}
#include <support/test-driver.c>