syscalls/openat2: New tests
PATCH v2 1/1 syscalls/openat2: New tests
Add tests to check working of openat2() syscall.
---V1->V2:
- Separate file for testing success/failure of different resolve flags
- Better testing for checking out of bound usage of the buffer by the kernel with the help of tst_buffers.
- s/__u64/uint64_t/
- Drop stale AIO_LIBS reference
- Other minor modifications
configure.ac | 1 + include/lapi/openat2.h | 72 ++++++++++++++ runtest/syscalls | 4 + testcases/kernel/syscalls/openat2/.gitignore | 3 + testcases/kernel/syscalls/openat2/Makefile | 7 ++ testcases/kernel/syscalls/openat2/openat201.c | 98 +++++++++++++++++++ testcases/kernel/syscalls/openat2/openat202.c | 86 ++++++++++++++++ testcases/kernel/syscalls/openat2/openat203.c | 80 +++++++++++++++ 8 files changed, 351 insertions(+) create mode 100644 include/lapi/openat2.h create mode 100644 testcases/kernel/syscalls/openat2/.gitignore create mode 100644 testcases/kernel/syscalls/openat2/Makefile create mode 100644 testcases/kernel/syscalls/openat2/openat201.c create mode 100644 testcases/kernel/syscalls/openat2/openat202.c create mode 100644 testcases/kernel/syscalls/openat2/openat203.c
configure.ac +1 -0
@@ -96,6 +96,7 @@ AC_CHECK_FUNCS([ \ name_to_handle_at \ open_tree \ openat \ + openat2 \ pidfd_open \ pidfd_send_signal \ pkey_mprotect \
include/lapi/openat2.h new file +72 -0
72 lines not on this page · raw message
runtest/syscalls +4 -0
@@ -845,6 +845,10 @@ openat01 openat01 openat02 openat02 openat03 openat03 +openat201 openat201 +openat202 openat202 +openat203 openat203 + open_tree01 open_tree01 open_tree02 open_tree02
testcases/kernel/syscalls/openat2/.gitignore new file +3 -0
@@ -0,0 +1,3 @@ +openat201 +openat202 +openat203
testcases/kernel/syscalls/openat2/Makefile new file +7 -0
@@ -0,0 +1,7 @@ +# SPDX-License-Identifier: GPL-2.0-or-later + +top_srcdir ?= ../../../.. + +include $(top_srcdir)/include/mk/testcases.mk + +include $(top_srcdir)/include/mk/generic_leaf_target.mk
testcases/kernel/syscalls/openat2/openat201.c new file +98 -0
98 lines not on this page · raw message
testcases/kernel/syscalls/openat2/openat202.c new file +86 -0
86 lines not on this page · raw message
testcases/kernel/syscalls/openat2/openat203.c new file +80 -0
80 lines not on this page · raw message
Signature · 1 line
2.21.0.rc0.269.g1a574e7a288b
PATCH v2 1/1 syscalls/openat2: New tests
Hi!
include/lapi/openat2.h line 68
Quoted 7 lines
include/lapi/openat2.h new file +7
-0+void openat2_supported_by_kernel (void ) +{ +if ((tst_kvercmp (5 ,6 ,0 )) <0 ) { +/* Check if the syscall is backported on an older kernel */ +TEST (syscall (__NR_openat2,-1 ,NULL ,NULL ,0 )); +if (TST_RET ==-1 &&TST_ERR ==ENOSYS ) +tst_brk (TCONF ,"Test not supported on kernel version < v5.2" );
The test is for 5.6 but the message says 5.2, so which one is correct?
Quoted 79 lines
include/lapi/openat2.h new file +4
-0+ } +} + +#endif /* OPENAT2_H */ runtest/syscalls +4
-0@@ -845,6 +845,10 @@ openat01 openat01 openat02 openat02 openat03 openat03 +openat201 openat201 +openat202 openat202 +openat203 openat203 + open_tree01 open_tree01 open_tree02 open_tree02testcases/kernel/syscalls/openat2/.gitignore new file +3
-0@@ -0,0 +1,3 @@ +openat201 +openat202 +openat203testcases/kernel/syscalls/openat2/Makefile new file +7
-0@@ -0,0 +1,7 @@ +# SPDX-License-Identifier: GPL-2.0-or-later + +top_srcdir ?= ../../../.. + +include $(top_srcdir)/include/mk/testcases.mk + +include $(top_srcdir)/include/mk/generic_leaf_target.mktestcases/kernel/syscalls/openat2/openat201.c new file +32
-0@@ -0,0 +1,98 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (c) 2020 Viresh Kumar <[email protected]> +* +* Basic openat2() test. +*/ +#include "tst_test.h" +#include "lapi/openat2.h" + +#define TEST_FILE "test_file" +#define TEST_DIR "test_dir" + +static struct open_how *how; +static struct open_how_pad *phow; + +static int dir_fd =-1 , fd_atcwd =AT_FDCWD ; + +static struct tcase { +int *dfd; +const char *pathname; +uint64_t flags; +uint64_t mode; +uint64_t resolve; +struct open_how **how; +size_t size; +} tcases[] = { + {&dir_fd,TEST_FILE ,O_RDWR ,S_IRWXU ,0 , &how,sizeof (*how)}, + {&dir_fd,TEST_FILE ,O_RDONLY ,S_IRUSR ,0 , &how,sizeof (*how)}, + {&dir_fd,TEST_FILE ,O_WRONLY ,S_IWUSR ,0 , &how,sizeof (*how)}, + {&dir_fd,TEST_FILE ,O_RDWR ,S_IRWXU ,RESOLVE_NO_XDEV , &how,sizeof (*how)}, + {&dir_fd,TEST_FILE ,O_RDWR ,S_IRWXU ,RESOLVE_NO_MAGICLINKS , &how,sizeof (*how)}, + {&dir_fd,TEST_FILE ,O_RDWR ,S_IRWXU ,RESOLVE_NO_SYMLINKS , &how,sizeof (*how)},
testcases/kernel/syscalls/openat2/openat201.c line 42
Quoted 10 lines
testcases/kernel/syscalls/openat2/openat201.c new file +10
-0+ {&dir_fd, TEST_FILE, O_RDWR, S_IRWXU, RESOLVE_BENEATH, &how, sizeof(*how)}, + {&dir_fd, TEST_FILE, O_RDWR, S_IRWXU, RESOLVE_IN_ROOT, &how, sizeof(*how)}, + {&fd_atcwd, TEST_FILE, O_RDWR, S_IRWXU, 0, &how, sizeof(*how)}, + {&fd_atcwd, TEST_FILE, O_RDONLY, S_IRUSR, 0, &how, sizeof(*how)}, + {&fd_atcwd, TEST_FILE, O_WRONLY, S_IWUSR, 0, &how, sizeof(*how)}, + {&fd_atcwd, TEST_FILE, O_RDWR, S_IRWXU, RESOLVE_NO_XDEV, &how, sizeof(*how)}, + {&fd_atcwd, TEST_FILE, O_RDWR, S_IRWXU, RESOLVE_NO_MAGICLINKS, &how, sizeof(*how)}, + {&fd_atcwd, TEST_FILE, O_RDWR, S_IRWXU, RESOLVE_NO_SYMLINKS, &how, sizeof(*how)}, + {&fd_atcwd, TEST_FILE, O_RDWR, S_IRWXU, RESOLVE_BENEATH, &how, sizeof(*how)}, + {&fd_atcwd, TEST_FILE, O_RDWR, S_IRWXU, RESOLVE_IN_ROOT, (struct open_how **)&phow, sizeof(*how) + 1},
^
since the padd is 64bit this should be + 8
Quoted 75 lines
testcases/kernel/syscalls/openat2/openat201.c new file +56
-0+}; + +static void cleanup (void ) +{ +if (dir_fd !=-1 ) +SAFE_CLOSE (dir_fd); +} + +static void setup (void ) +{ +openat2_supported_by_kernel (); + + phow->pad =0x00 ; +SAFE_MKDIR (TEST_DIR ,0700 ); + dir_fd =SAFE_OPEN (TEST_DIR ,O_DIRECTORY ); +} + +static void run (unsigned int n) +{ +int fd; +struct stat file_stat; +struct tcase *tc = &tcases[n]; +struct open_how *myhow = *tc->how; + + myhow->flags = tc->flags |O_CREAT ; + myhow->mode = tc->mode; + myhow->resolve = tc->resolve; + +TEST (fd =openat2 (*tc->dfd, tc->pathname, myhow, tc->size)); +if (fd <0 ) { +tst_res (TFAIL |TTERRNO ,"openat2() failed (%d)" , n); +return ; + } + +SAFE_FSTAT (fd, &file_stat); + +if (file_stat.st_size ==0 ) +tst_res (TPASS ,"openat2() passed (%d)" , n); +else +tst_res (TFAIL ,"fstat() didn't work as expected (%d)" , n); + +SAFE_CLOSE (fd); +} + +static struct tst_test test = { + .tcnt =ARRAY_SIZE (tcases), + .test = run, + .setup = setup, + .cleanup = cleanup, + .needs_tmpdir =1 , + .bufs = (struct tst_buffers []) { + {&how, .size =sizeof (*how)}, + {&phow, .size =sizeof (*phow)}, + {}, + }, +};testcases/kernel/syscalls/openat2/openat202.c new file +13
-0@@ -0,0 +1,86 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (c) 2020 Viresh Kumar <[email protected]> +* +* openat2() tests with various resolve flags. +*/ +#include "tst_test.h" +#include "lapi/openat2.h" + +#define FOO_SYMLINK "foo_symlink" + +static struct open_how *how; +
testcases/kernel/syscalls/openat2/openat202.c line 23
Quoted 10 lines
testcases/kernel/syscalls/openat2/openat202.c new file +10
-0+static struct tcase { +const char *name; +const char *pathname; +uint64_t resolve; +int exp_errno; +} tcases[] = { +/* Success cases */ + {"open /proc/version" ,"/proc/version" ,0 ,0 }, + {"open magiclinks" ,"/proc/self/exe" ,0 ,0 }, + {"open symlinks" ,FOO_SYMLINK ,0 ,0 },
Wouldn't it be easier if we added these to the first test and keep this one failures only?
testcases/kernel/syscalls/openat2/openat202.c line 30
Quoted 6 lines
testcases/kernel/syscalls/openat2/openat202.c new file +6
-0+/* Failure cases */ + {"resolve-no-xdev", "/proc/version", RESOLVE_NO_XDEV, EXDEV}, + {"resolve-no-magiclinks", "/proc/self/exe", RESOLVE_NO_MAGICLINKS, ELOOP}, + {"resolve-no-symlinks", FOO_SYMLINK, RESOLVE_NO_SYMLINKS, ELOOP}, + {"resolve-beneath", "/proc/version", RESOLVE_BENEATH, EXDEV}, + {"resolve-no-in-root", "/proc/version", RESOLVE_IN_ROOT, ENOENT},
I guess that given that we can also add "..", RESOLVE_BENEATH case as well, since .. would escape the AT_FDCWD, right?
Quoted 86 lines
testcases/kernel/syscalls/openat2/openat202.c new file +56
-0+}; + +static void setup (void ) +{ +openat2_supported_by_kernel (); +SAFE_SYMLINK ("/proc/version" ,FOO_SYMLINK ); +} + +static void run (unsigned int n) +{ +struct tcase *tc = &tcases[n]; + + how->flags =O_RDONLY |O_CREAT ; + how->mode =S_IRUSR ; + how->resolve = tc->resolve; + +TEST (openat2 (AT_FDCWD , tc->pathname, how,sizeof (*how))); + +if (!tc->exp_errno) { +if (TST_RET <0 ) { +tst_res (TFAIL |TTERRNO ,"%s: openat2() failed" , + tc->name); +return ; + } + +SAFE_CLOSE (TST_RET ); +tst_res (TPASS ,"%s: openat2() passed" , tc->name); + }else { +if (TST_RET >=0 ) { +SAFE_CLOSE (TST_RET ); +tst_res (TFAIL ,"%s: openat2() passed unexpectedly" , + tc->name); +return ; + } + +if (tc->exp_errno !=TST_ERR ) { +tst_res (TFAIL |TTERRNO ,"%s: openat2() should fail with %s" , + tc->name,tst_strerrno (tc->exp_errno)); +return ; + } + +tst_res (TPASS |TTERRNO ,"%s: openat2() failed as expected" , + tc->name); + } +} + +static struct tst_test test = { + .tcnt =ARRAY_SIZE (tcases), + .test = run, + .setup = setup, + .needs_tmpdir =1 , + .bufs = (struct tst_buffers []) { + {&how, .size =sizeof (*how)}, + {}, + } +};testcases/kernel/syscalls/openat2/openat203.c new file +24
-0@@ -0,0 +1,80 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (c) 2020 Viresh Kumar <[email protected]> +* +* Basic openat2() test to check various failures. +*/ +#include "tst_test.h" +#include "lapi/openat2.h" + +#define TEST_FILE "test_file" + +static struct open_how *how; +static struct open_how_pad *phow; + +static struct tcase { + const char *name; + int dfd; + const char *pathname; + uint64_t flags; + uint64_t mode; + uint64_t resolve; + struct open_how **how; + size_t size; + int exp_errno;
testcases/kernel/syscalls/openat2/openat203.c line 34
Quoted 10 lines
testcases/kernel/syscalls/openat2/openat203.c new file +10
-0+} tcases[] = { + {"invalid-dfd", -1, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, sizeof(*how), EBADF}, + {"invalid-pathname", AT_FDCWD, NULL, O_RDONLY | O_CREAT, S_IRUSR, 0, &how, sizeof(*how), EFAULT}, + {"invalid-flags", AT_FDCWD, TEST_FILE, O_RDONLY, S_IWUSR, 0, &how, sizeof(*how), EINVAL}, + {"invalid-mode", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, -1, 0, &how, sizeof(*how), EINVAL}, + {"invalid-resolve", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, -1, &how, sizeof(*how), EINVAL}, + {"invalid-size-zero", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, 0, EINVAL}, + {"invalid-size-small", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, sizeof(*how) - 1, EINVAL}, + {"invalid-size-big", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, sizeof(*how) + 1, EFAULT}, + {"invalid-size-big-with-pad", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, (struct open_how **)&phow, sizeof(*how) + 1, E2BIG},
Here as well +8.
Quoted 36 lines
testcases/kernel/syscalls/openat2/openat203.c new file +36
-0+}; + +static void setup (void ) +{ +openat2_supported_by_kernel (); + phow->pad =0xDEAD ; +} + +static void run (unsigned int n) +{ +struct tcase *tc = &tcases[n]; +struct open_how *myhow = *tc->how; + + myhow->flags = tc->flags; + myhow->mode = tc->mode; + myhow->resolve = tc->resolve; + +TEST (openat2 (tc->dfd, tc->pathname, myhow, tc->size)); + +if (TST_RET >=0 ) { +SAFE_CLOSE (TST_RET ); +tst_res (TFAIL ,"%s: openat2() passed unexpectedly" , + tc->name); +return ; + } + +if (tc->exp_errno !=TST_ERR ) { +tst_res (TFAIL |TTERRNO ,"%s: openat2() should fail with %s" , + tc->name,tst_strerrno (tc->exp_errno)); +return ; + } + +tst_res (TPASS |TTERRNO ,"%s: openat2() failed as expected" , tc->name); +} + +static struct tst_test test = {
testcases/kernel/syscalls/openat2/openat203.c line 80
Quoted 10 lines
testcases/kernel/syscalls/openat2/openat203.c new file +10
-0+ .tcnt = ARRAY_SIZE(tcases), + .test = run, + .setup = setup, + .needs_tmpdir = 1, + .bufs = (struct tst_buffers []) { + {&how, .size =sizeof (*how)}, + {&phow, .size =sizeof (*phow)}, + {}, + } +};
Otherwise it looks good.
Signature · 2 lines
Cyril Hrubis [email protected]
PATCH v2 1/1 syscalls/openat2: New tests
Hi,
Quoted 9 lines
include/lapi/openat2.h line 68
Quoted 7 lines
include/lapi/openat2.h new file +7
-0+void openat2_supported_by_kernel (void ) +{ +if ((tst_kvercmp (5 ,6 ,0 )) <0 ) { +/* Check if the syscall is backported on an older kernel */ +TEST (syscall (__NR_openat2,-1 ,NULL ,NULL ,0 )); +if (TST_RET ==-1 &&TST_ERR ==ENOSYS ) +tst_brk (TCONF ,"Test not supported on kernel version < v5.2" );The test is for 5.6 but the message says 5.2, so which one is correct?
Added in v5.6.
Kind regards,
Petr
PATCH v2 1/1 syscalls/openat2: New tests
In reply to Cyril HrubisQuoted 24 lines · Cyril Hrubis
Quoted 24 lines
testcases/kernel/syscalls/openat2/openat202.c new file +18
-0@@ -0,0 +1,86 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (c) 2020 Viresh Kumar <[email protected]> +* +* openat2() tests with various resolve flags. +*/ +#include "tst_test.h" +#include "lapi/openat2.h" + +#define FOO_SYMLINK "foo_symlink" + +static struct open_how *how; + +static struct tcase { + const char *name; + const char *pathname; + uint64_t resolve; + int exp_errno;
Quoted 8 lines
testcases/kernel/syscalls/openat2/openat202.c line 23
Quoted 5 lines
testcases/kernel/syscalls/openat2/openat202.c new file +5
-0+} tcases[] = { +/* Success cases */ + {"open /proc/version", "/proc/version", 0, 0}, + {"open magiclinks", "/proc/self/exe", 0, 0}, + {"open symlinks", FOO_SYMLINK, 0, 0},Wouldn't it be easier if we added these to the first test and keep this one failures only?
I thought about that earlier and kept it this way as this file is only for testing the resolve flags. Else the success cases could be added to openat201.c and failure to openat203.c itself.
This also helps in understanding (or noticing), that the test only changes the value of the resolve flag and we get an error. The first test plays with a lot of variables and so it may not be best to do it there as it would be a bit less readable.
Quoted 21 lines
Quoted 21 lines
testcases/kernel/syscalls/openat2/openat202.c new file +20
-0+/* Failure cases */ + {"resolve-no-xdev", "/proc/version", RESOLVE_NO_XDEV, EXDEV}, + {"resolve-no-magiclinks", "/proc/self/exe", RESOLVE_NO_MAGICLINKS, ELOOP}, + {"resolve-no-symlinks", FOO_SYMLINK, RESOLVE_NO_SYMLINKS, ELOOP}, + {"resolve-beneath", "/proc/version", RESOLVE_BENEATH, EXDEV}, + {"resolve-no-in-root", "/proc/version", RESOLVE_IN_ROOT, ENOENT}, +static struct tcase { + const char *name; +int dfd; +const char *pathname; +uint64_t flags; +uint64_t mode; +uint64_t resolve; +struct open_how **how; +size_t size; +int exp_errno; +} tcases[] = { + {"invalid-dfd", -1, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, sizeof(*how), EBADF}, + {"invalid-pathname", AT_FDCWD, NULL, O_RDONLY | O_CREAT, S_IRUSR, 0, &how, sizeof(*how), EFAULT}, + {"invalid-flags", AT_FDCWD, TEST_FILE, O_RDONLY, S_IWUSR, 0, &how, sizeof(*how), EINVAL},
Quoted 8 lines
testcases/kernel/syscalls/openat2/openat202.c
Quoted 6 lines
testcases/kernel/syscalls/openat2/openat202.c new file +6
-0+ {"invalid-mode", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, -1, 0, &how, sizeof(*how), EINVAL}, + {"invalid-resolve", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, -1, &how, sizeof(*how), EINVAL}, + {"invalid-size-zero", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, 0, EINVAL}, + {"invalid-size-small", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, sizeof(*how) - 1, EINVAL}, + {"invalid-size-big", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, sizeof(*how) + 1, EFAULT}, + {"invalid-size-big-with-pad", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, (struct open_how **)&phow, sizeof(*how) + 1, E2BIG},Here as well +8.
I kept this as 1 intentionally despite the fact that pad is 8 bytes long. The last 2 tests have size set to (sizeof(*how) + 1) now and the only difference is that we have provided pad of X number of bytes in one case and no pad in the other case. This gives us different error numbers based on difference in the pad available. If I use +8 here, then there are two factors which are different, the structure and the number of bytes we are sending in size and we can't be certain about why we got a different error number.
Signature · 1 line
viresh
PATCH v2 1/1 syscalls/openat2: New tests
Quoted 73 lines · Viresh Kumar
Quoted 24 lines · Cyril Hrubis
Quoted 24 lines
testcases/kernel/syscalls/openat2/openat202.c new file +18
-0@@ -0,0 +1,86 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (c) 2020 Viresh Kumar <[email protected]> +* +* openat2() tests with various resolve flags. +*/ +#include "tst_test.h" +#include "lapi/openat2.h" + +#define FOO_SYMLINK "foo_symlink" + +static struct open_how *how; + +static struct tcase { + const char *name; + const char *pathname; + uint64_t resolve; + int exp_errno;Quoted 8 lines
testcases/kernel/syscalls/openat2/openat202.c line 23
Quoted 5 lines
testcases/kernel/syscalls/openat2/openat202.c new file +5
-0+} tcases[] = { +/* Success cases */ + {"open /proc/version", "/proc/version", 0, 0}, + {"open magiclinks", "/proc/self/exe", 0, 0}, + {"open symlinks", FOO_SYMLINK, 0, 0},Wouldn't it be easier if we added these to the first test and keep this one failures only?
I thought about that earlier and kept it this way as this file is only for testing the resolve flags. Else the success cases could be added to
openat201.cand failure toopenat203.citself.This also helps in understanding (or noticing), that the test only changes the value of the resolve flag and we get an error. The first test plays with a lot of variables and so it may not be best to do it there as it would be a bit less readable.
Quoted 21 lines
Quoted 21 lines
testcases/kernel/syscalls/openat2/openat202.c new file +20
-0+/* Failure cases */ + {"resolve-no-xdev", "/proc/version", RESOLVE_NO_XDEV, EXDEV}, + {"resolve-no-magiclinks", "/proc/self/exe", RESOLVE_NO_MAGICLINKS, ELOOP}, + {"resolve-no-symlinks", FOO_SYMLINK, RESOLVE_NO_SYMLINKS, ELOOP}, + {"resolve-beneath", "/proc/version", RESOLVE_BENEATH, EXDEV}, + {"resolve-no-in-root", "/proc/version", RESOLVE_IN_ROOT, ENOENT}, +static struct tcase { + const char *name; +int dfd; +const char *pathname; +uint64_t flags; +uint64_t mode; +uint64_t resolve; +struct open_how **how; +size_t size; +int exp_errno; +} tcases[] = { + {"invalid-dfd", -1, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, sizeof(*how), EBADF}, + {"invalid-pathname", AT_FDCWD, NULL, O_RDONLY | O_CREAT, S_IRUSR, 0, &how, sizeof(*how), EFAULT}, + {"invalid-flags", AT_FDCWD, TEST_FILE, O_RDONLY, S_IWUSR, 0, &how, sizeof(*how), EINVAL},Quoted 8 lines
testcases/kernel/syscalls/openat2/openat202.c
Quoted 6 lines
testcases/kernel/syscalls/openat2/openat202.c new file +6
-0+ {"invalid-mode", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, -1, 0, &how, sizeof(*how), EINVAL}, + {"invalid-resolve", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, -1, &how, sizeof(*how), EINVAL}, + {"invalid-size-zero", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, 0, EINVAL}, + {"invalid-size-small", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, sizeof(*how) - 1, EINVAL}, + {"invalid-size-big", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, sizeof(*how) + 1, EFAULT}, + {"invalid-size-big-with-pad", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, (struct open_how **)&phow, sizeof(*how) + 1, E2BIG},Here as well +8.
Quoted 8 lines
I kept this as 1 intentionally despite the fact that pad is 8 bytes long. The last 2 tests have size set to (
sizeof(*how)+ 1) now and the only difference is that we have provided pad of X number of bytes in one case and no pad in the other case. This gives us different error numbers based on difference in the pad available. If I use +8 here, then there are two factors which are different, the structure and the number of bytes we are sending in size and we can't be certain about why we got a different error number.
@Cyril: I am waiting for your response before sending the next version here. Thanks.
Signature · 1 line
viresh
PATCH v2 1/1 syscalls/openat2: New tests
In reply to Viresh KumarHi!
Quoted 11 lines
Quoted 2 lines
Wouldn't it be easier if we added these to the first test and keep this one failures only?
I thought about that earlier and kept it this way as this file is only for testing the resolve flags. Else the success cases could be added to
openat201.cand failure toopenat203.citself.This also helps in understanding (or noticing), that the test only changes the value of the resolve flag and we get an error. The first test plays with a lot of variables and so it may not be best to do it there as it would be a bit less readable.
Okay then.
Quoted 30 lines
Quoted 21 lines
Quoted 21 lines
(quoted diff) +20
-0+ /* Failure cases */ + {"resolve-no-xdev", "/proc/version", RESOLVE_NO_XDEV, EXDEV}, + {"resolve-no-magiclinks", "/proc/self/exe", RESOLVE_NO_MAGICLINKS, ELOOP}, + {"resolve-no-symlinks", FOO_SYMLINK, RESOLVE_NO_SYMLINKS, ELOOP}, + {"resolve-beneath", "/proc/version", RESOLVE_BENEATH, EXDEV}, + {"resolve-no-in-root", "/proc/version", RESOLVE_IN_ROOT, ENOENT}, +static struct tcase { + const char *name; + int dfd; + const char *pathname; + uint64_t flags; + uint64_t mode; + uint64_t resolve; + struct open_how **how; + size_t size; + int exp_errno; +} tcases[] = { + {"invalid-dfd", -1, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, sizeof(*how), EBADF}, + {"invalid-pathname", AT_FDCWD, NULL, O_RDONLY | O_CREAT, S_IRUSR, 0, &how, sizeof(*how), EFAULT}, + {"invalid-flags", AT_FDCWD, TEST_FILE, O_RDONLY, S_IWUSR, 0, &how, sizeof(*how), EINVAL},Quoted 8 lines
testcases/kernel/syscalls/openat2/openat203.c line 34
Quoted 6 lines
testcases/kernel/syscalls/openat2/openat203.c new file +6
-0+ {"invalid-mode", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, -1, 0, &how, sizeof(*how), EINVAL}, + {"invalid-resolve", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, -1, &how, sizeof(*how), EINVAL}, + {"invalid-size-zero", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, 0, EINVAL}, + {"invalid-size-small", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, sizeof(*how) - 1, EINVAL}, + {"invalid-size-big", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, &how, sizeof(*how) + 1, EFAULT}, + {"invalid-size-big-with-pad", AT_FDCWD, TEST_FILE, O_RDWR | O_CREAT, S_IRWXU, 0, (struct open_how **)&phow, sizeof(*how) + 1, E2BIG},Here as well +8.
Quoted 8 lines
I kept this as 1 intentionally despite the fact that pad is 8 bytes long. The last 2 tests have size set to (
sizeof(*how)+ 1) now and the only difference is that we have provided pad of X number of bytes in one case and no pad in the other case. This gives us different error numbers based on difference in the pad available. If I use +8 here, then there are two factors which are different, the structure and the number of bytes we are sending in size and we can't be certain about why we got a different error number.
I do not get it, we can pass +8 to the EFAULT case as well, or whatever, there is a whole page after the data.
What I would like to have here is that the size we pass to the kernel is exactly the size of the data have have allocate, so that we catch off-by-one accesses after the structure.
Signature · 2 lines
Cyril Hrubis [email protected]