[4/4] Add test for getrlimit/setrlimit/prlimit with infinity value

Message ID 20180105132429.21118-5-aurelien@aurel32.net
State New
Headers show
Series
  • Fix getrlimit/setrlimit/prlimit on Alpha and 32-bit machines
Related show

Commit Message

Aurelien Jarno Jan. 5, 2018, 1:24 p.m.
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.
---
 ChangeLog                                     |   5 +
 sysdeps/unix/sysv/linux/Makefile              |   3 +-
 sysdeps/unix/sysv/linux/tst-rlimit-infinity.c | 157 ++++++++++++++++++++++++++
 3 files changed, 164 insertions(+), 1 deletion(-)
 create mode 100644 sysdeps/unix/sysv/linux/tst-rlimit-infinity.c

Comments

Joseph Myers Jan. 5, 2018, 1:47 p.m. | #1
The new test is missing copyright / license notices.
Adhemerval Zanella Jan. 5, 2018, 1:58 p.m. | #2
On 05/01/2018 11:24, Aurelien Jarno wrote:
> 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.

LGTM with two remarks below.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

> ---
>  ChangeLog                                     |   5 +
>  sysdeps/unix/sysv/linux/Makefile              |   3 +-
>  sysdeps/unix/sysv/linux/tst-rlimit-infinity.c | 157 ++++++++++++++++++++++++++
>  3 files changed, 164 insertions(+), 1 deletion(-)
>  create mode 100644 sysdeps/unix/sysv/linux/tst-rlimit-infinity.c
> 
> diff --git a/ChangeLog b/ChangeLog
> index 53c3d62b2e..81ce7f3dfc 100644
> --- a/ChangeLog
> +++ b/ChangeLog
> @@ -1,3 +1,8 @@
> +2018-01-05  Aurelien Jarno  <aurelien@aurel32.net>
> +
> +	* 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>
>  
>  	[BZ #22678]
> diff --git a/sysdeps/unix/sysv/linux/Makefile b/sysdeps/unix/sysv/linux/Makefile
> index 4af9c5661d..8f19e0efc3 100644
> --- a/sysdeps/unix/sysv/linux/Makefile
> +++ b/sysdeps/unix/sysv/linux/Makefile
> @@ -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
> diff --git a/sysdeps/unix/sysv/linux/tst-rlimit-infinity.c b/sysdeps/unix/sysv/linux/tst-rlimit-infinity.c
> new file mode 100644
> index 0000000000..58aace625a
> --- /dev/null
> +++ b/sysdeps/unix/sysv/linux/tst-rlimit-infinity.c

Missing Copyright header.

> @@ -0,0 +1,157 @@
> +#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;
> +}
> +
> +#define TEST_FUNCTION do_test ()
> +#include "../test-skeleton.c"

Correct to use libsupport is to include <support/test-driver.c> instead
(and you do not need to define TEST_FUNCTION if you have a do_test function
already).
Aurelien Jarno Jan. 5, 2018, 5:51 p.m. | #3
On 2018-01-05 11:58, Adhemerval Zanella wrote:
> 
> 
> On 05/01/2018 11:24, Aurelien Jarno wrote:
> > 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.
> 
> LGTM with two remarks below.
> 
> Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

Thanks for the review, I'll the two issues that before committing.

Patch

diff --git a/ChangeLog b/ChangeLog
index 53c3d62b2e..81ce7f3dfc 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,8 @@ 
+2018-01-05  Aurelien Jarno  <aurelien@aurel32.net>
+
+	* 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>
 
 	[BZ #22678]
diff --git a/sysdeps/unix/sysv/linux/Makefile b/sysdeps/unix/sysv/linux/Makefile
index 4af9c5661d..8f19e0efc3 100644
--- a/sysdeps/unix/sysv/linux/Makefile
+++ b/sysdeps/unix/sysv/linux/Makefile
@@ -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
diff --git a/sysdeps/unix/sysv/linux/tst-rlimit-infinity.c b/sysdeps/unix/sysv/linux/tst-rlimit-infinity.c
new file mode 100644
index 0000000000..58aace625a
--- /dev/null
+++ b/sysdeps/unix/sysv/linux/tst-rlimit-infinity.c
@@ -0,0 +1,157 @@ 
+#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;
+}
+
+#define TEST_FUNCTION do_test ()
+#include "../test-skeleton.c"