- linux-morello-ltp - op-lists.linaro.org

[PATCH v5 1/3] lib/tst_pid: Find cgroup pid.max programmatically

by Teo Couprie Diaz

In some distributions, the two files used in lib/tst_pid.c are not available, but cgroups still imposes a task limit far smaller than the kernel pid_max. If the cgroup sysfs is mounted, we can use it to retrieve the current task limit imposed to the process. Implement the retrieval of this limit. This can be done by first checking /proc/self/cgroup to get the cgroup the process is in, which will be a path under the cgroup sysfs. To get the path to the cgroup sysfs, check /proc/self/mountinfo. Finally, concatenate those two paths with pid.max to get the full path to the file containing the limit. This patch changes the way read_session_pids_limit is called, not passing a format string to be completed anymore, but is still used the same way. A following patch will update this function. This fixes failures for msgstress04. Signed-off-by: Teo Couprie Diaz <teo.coupriediaz(a)arm.com> --- lib/tst_pid.c | 53 +++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 43 insertions(+), 10 deletions(-) diff --git a/lib/tst_pid.c b/lib/tst_pid.c index 21cadef2a..98f733d33 100644 --- a/lib/tst_pid.c +++ b/lib/tst_pid.c @@ -31,8 +31,6 @@ #include "tst_safe_macros.h" #define PID_MAX_PATH "/proc/sys/kernel/pid_max" -#define CGROUPS_V1_SLICE_FMT "/sys/fs/cgroup/pids/user.slice/user-%d.slice/pids.max" -#define CGROUPS_V2_SLICE_FMT "/sys/fs/cgroup/user.slice/user-%d.slice/pids.max" /* Leave some available processes for the OS */ #define PIDS_RESERVE 50 @@ -96,18 +94,53 @@ static int read_session_pids_limit(const char *path_fmt, int uid, static int get_session_pids_limit(void (*cleanup_fn) (void)) { - int max_pids, uid; + char path[PATH_MAX + 1]; + char cgroup_pids[PATH_MAX + 1]; + char catchall; + int uid, ret = 0; uid = get_session_uid(); - max_pids = read_session_pids_limit(CGROUPS_V2_SLICE_FMT, uid, cleanup_fn); - if (max_pids < 0) - max_pids = read_session_pids_limit(CGROUPS_V1_SLICE_FMT, uid, - cleanup_fn); + /* Check for generic cgroup v1 pid.max */ + ret = FILE_LINES_SCANF(cleanup_fn, "/proc/self/cgroup", + "%*d:pids:%s\n", cgroup_pids); + /* + * This is a bit of a hack of scanf format strings. Indeed, if all + * conversion specifications have been matched the return of scanf will be + * the same whether any outstanding literal characters match or not. + * As we want to match the literal part, we can add a catchall after it + * so that it won't be counted if the literal part doesn't match. + * This makes the macro go to the next line until the catchall, thus + * the literal parts, is matched. + * + * Assume that the root of the mount is '/'. It can be anything, + * but it should be '/' on any normal system. + */ + if (!ret) + ret = FILE_LINES_SCANF(cleanup_fn, "/proc/self/mountinfo", + "%*s %*s %*s %*s %s %*[^-] - cgroup %*s %*[rw],pid%c", + path, &catchall); + + if (!ret) { + strncat(path, cgroup_pids, PATH_MAX); + strncat(path, "/pids.max", PATH_MAX); + return read_session_pids_limit(path, uid, cleanup_fn); + } - if (max_pids < 0) - return -1; + /* Check for generic cgroup v2 pid.max */ + ret = FILE_LINES_SCANF(cleanup_fn, "/proc/self/cgroup", + "%*d::%s\n", cgroup_pids); + if (!ret) + ret = FILE_LINES_SCANF(cleanup_fn, "/proc/self/mountinfo", + "%*s %*s %*s %*s %s %*[^-] - cgroup2 %c", + path, &catchall); + + if (!ret) { + strncat(path, cgroup_pids, PATH_MAX); + strncat(path, "/pids.max", PATH_MAX); + return read_session_pids_limit(path, uid, cleanup_fn); + } - return max_pids; + return -1; } int tst_get_free_pids_(void (*cleanup_fn) (void)) -- 2.25.1

1 year, 2 months

2
3
0 0

[PATCH v3 1/2] syscalls/mq_open: Add an alternative error for musl

by Amit Daniel Kachhap

Musl and glibc syscall wrappers handles the null mq name in different ways and report different errors. Glibc reports EINVAL error if the mq_name is not preceded by "/" character but musl library does not treat this as an error and invokes the kernel mq_open syscall which finally fails with ENOENT error. Introduce an alternative return error ENOENT so that this test passes with musl library. Signed-off-by: Amit Daniel Kachhap <amit.kachhap(a)arm.com> --- changes in v3: *) Retain the mq_open library call and add new error code for musl failure as suggested by Beata. testcases/kernel/syscalls/mq_open/mq_open01.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/testcases/kernel/syscalls/mq_open/mq_open01.c b/testcases/kernel/syscalls/mq_open/mq_open01.c index cd2a229d8..8a229d298 100644 --- a/testcases/kernel/syscalls/mq_open/mq_open01.c +++ b/testcases/kernel/syscalls/mq_open/mq_open01.c @@ -34,6 +34,7 @@ struct test_case { struct mq_attr *rq; int ret; int err; + int alt_err; void (*setup)(void); void (*cleanup)(void); }; @@ -96,6 +97,7 @@ static struct test_case tcase[] = { .oflag = O_CREAT, .ret = -1, .err = EINVAL, + .alt_err = ENOENT, /* Musl library reports this error for empty mqueue name */ }, { .desc = "NORMAL", @@ -260,9 +262,11 @@ static void do_test(unsigned int i) } if (TST_ERR != tc->err) { - tst_res(TFAIL | TTERRNO, "%s expected errno: %d", - tc->desc, TST_ERR); - goto CLEANUP; + if (TST_ERR != tc->alt_err) { + tst_res(TFAIL | TTERRNO, "%s expected errno: %d", + tc->desc, TST_ERR); + goto CLEANUP; + } } if (TST_RET != tc->ret) { -- 2.25.1

1 year, 2 months

2
7
0 0

[PATCH] README: Update build with test_ioctl dependencies

by Teo Couprie Diaz

Add 'tools/apicmds' to build targets to satisfy the dependency for the tests that do rely on it. Namely: test_ioctl which, despite being shell-based, does not follow the usual approach of using the test.sh test library, instead relying on the legacy approach of using apicmds binaries. It should be reworked to use the new framework at some point though. Signed-off-by: Teo Couprie Diaz <teo.coupriediaz(a)arm.com> --- README.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.rst b/README.rst index 4aebadd35..8b6e3a776 100644 --- a/README.rst +++ b/README.rst @@ -97,9 +97,9 @@ Assumptions: *TRIPLE* & *MORELLO_SUPPORT* in `Building Musl`) LTP_BUILD - out-of-tree build path (created by LTP's build.sh script if needed) LTP_INSTALL - destination path where LTP tests are to be installed - TARGETS - build targets, currently only pan and testcases/kernel/syscalls - are supported, it can be further narrowed down for specific syscall - testcases: + TARGETS - build targets, currently only pan, tools/apicmds and + testcases/kernel/syscalls are supported, it can be further narrowed + down for specific syscall testcases: TARGETS="pan testcases/kernel/syscalls/${syscall}" TARGET_FEATURE - morello+c64 (purecap) only: -march=morello+c64 @@ -117,7 +117,7 @@ Assumptions: export CONFIGURE_OPT_EXTRA="--prefix=/ --host=aarch64-linux-gnu --disable-metadata --without-numa" MAKE_OPTS="TST_NEWER_64_SYSCALL=no TST_COMPAT_16_SYSCALL=no" \ - TARGETS="pan testcases/kernel/syscalls" BUILD_DIR="$LTP_BUILD" \ + TARGETS="pan tools/apicmds testcases/kernel/syscalls" BUILD_DIR="$LTP_BUILD" \ CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" \ ./build.sh -t cross -o out -ip "${LTP_INSTALL}" -- 2.25.1

1 year, 2 months

2
1
0 0

[PATCH v4 1/4] lib/tst_pid: Find cgroup pid.max programatically

by Teo Couprie Diaz

In some distributions, the two files used in lib/tst_pid.c are not available, but cgroups still imposes a task limit far smaller than the kernel pid_max. If the cgroup sysfs is mounted, we can use it to retrieve the current task limit imposed to the process. Implement the retrieval of this limit. This can be done by first checking /proc/self/cgroup to get the cgroup the process is in, which will be a path under the cgroup sysfs. To get the path to the cgroup sysfs, check /proc/self/mountinfo. Finally, concatenate those two paths with pid.max to get the full path to the file containing the limit. This patch changes the way read_session_pids_limit is called, not passing a format string to be completed anymore, but is still used the same way. A following patch will update this function. This fixes failures for msgstress04. Signed-off-by: Teo Couprie Diaz <teo.coupriediaz(a)arm.com> --- lib/tst_pid.c | 53 +++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 43 insertions(+), 10 deletions(-) diff --git a/lib/tst_pid.c b/lib/tst_pid.c index 21cadef2a..f140acbc0 100644 --- a/lib/tst_pid.c +++ b/lib/tst_pid.c @@ -31,8 +31,6 @@ #include "tst_safe_macros.h" #define PID_MAX_PATH "/proc/sys/kernel/pid_max" -#define CGROUPS_V1_SLICE_FMT "/sys/fs/cgroup/pids/user.slice/user-%d.slice/pids.max" -#define CGROUPS_V2_SLICE_FMT "/sys/fs/cgroup/user.slice/user-%d.slice/pids.max" /* Leave some available processes for the OS */ #define PIDS_RESERVE 50 @@ -96,18 +94,53 @@ static int read_session_pids_limit(const char *path_fmt, int uid, static int get_session_pids_limit(void (*cleanup_fn) (void)) { - int max_pids, uid; + char path[PATH_MAX + 1]; + char cgroup_pids[PATH_MAX + 1]; + char catchall; + int uid, ret = 0; uid = get_session_uid(); - max_pids = read_session_pids_limit(CGROUPS_V2_SLICE_FMT, uid, cleanup_fn); - if (max_pids < 0) - max_pids = read_session_pids_limit(CGROUPS_V1_SLICE_FMT, uid, - cleanup_fn); + /* Check for generic cgroup v1 pid.max */ + ret = FILE_LINES_SCANF(cleanup_fn, "/proc/self/cgroup", + "%*d:pids:%s\n", cgroup_pids); + /* + * This is a bit of a hack of scanf format strings. Indeed, if all + * conversion specifications have been matched the return of scanf will be + * the same whether any outstanding literal characters match or not. + * As we want to match the literal part, we can add a catchall after it + * so that it won't be counted if the literal part doesn't match. + * This makes the macro go to the next line until the catchall, thus + * the literal parts, is matched. + * + * Assume that the root of the mount is '/'. It can be anything, + * but it should be '/' on any normal system. + */ + if (!ret) + ret = FILE_LINES_SCANF(cleanup_fn, "/proc/self/mountinfo", + "%*s %*s %*s %*s %s %*s %*s - %*s cgroup %*[rw],pid%c", + path, &catchall); + + if (!ret) { + strncat(path, cgroup_pids, PATH_MAX); + strncat(path, "/pids.max", PATH_MAX); + return read_session_pids_limit(path, uid, cleanup_fn); + } - if (max_pids < 0) - return -1; + /* Check for generic cgroup v2 pid.max */ + ret = FILE_LINES_SCANF(cleanup_fn, "/proc/self/cgroup", + "%*d::%s\n", cgroup_pids); + if (!ret) + ret = FILE_LINES_SCANF(cleanup_fn, "/proc/self/mountinfo", + "%*s %*s %*s %*s %s %*s %*s - cgroup2 %c", + path, &catchall); + + if (!ret) { + strncat(path, cgroup_pids, PATH_MAX); + strncat(path, "/pids.max", PATH_MAX); + return read_session_pids_limit(path, uid, cleanup_fn); + } - return max_pids; + return -1; } int tst_get_free_pids_(void (*cleanup_fn) (void)) -- 2.25.1

1 year, 2 months

3
11
0 0

[PATCH v3 1/3] lib/tst_pid: Find cgroup pid.max programatically

by Teo Couprie Diaz

In our debian-based distribution, the two files used in lib/tst_pid.c are not available, but cgroups still imposes a task limit far smaller than the kernel pid_max. If the cgroup sysfs is mounted, we can use it to retrieve the current task limit imposed to the process. Implement the retrieval of this limit. This can be done by first checking /proc/self/cgroup to get the cgroup the process is in, which will be a path under the cgroup sysfs. To get the path to the cgroup sysfs, check /proc/self/mountinfo. Finally, concatenate those two paths with pid.max to get the full path to the file containing the limit. This fixes failures for msgstress04. Signed-off-by: Teo Couprie Diaz <teo.coupriediaz(a)arm.com> --- Review branch as the changes are quite large: https://git.morello-project.org/Teo-CD/morello-linux-ltp/-/commits/review/t… lib/tst_pid.c | 55 ++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 44 insertions(+), 11 deletions(-) diff --git a/lib/tst_pid.c b/lib/tst_pid.c index 21cadef2a..ee3b98771 100644 --- a/lib/tst_pid.c +++ b/lib/tst_pid.c @@ -31,8 +31,6 @@ #include "tst_safe_macros.h" #define PID_MAX_PATH "/proc/sys/kernel/pid_max" -#define CGROUPS_V1_SLICE_FMT "/sys/fs/cgroup/pids/user.slice/user-%d.slice/pids.max" -#define CGROUPS_V2_SLICE_FMT "/sys/fs/cgroup/user.slice/user-%d.slice/pids.max" /* Leave some available processes for the OS */ #define PIDS_RESERVE 50 @@ -96,18 +94,53 @@ static int read_session_pids_limit(const char *path_fmt, int uid, static int get_session_pids_limit(void (*cleanup_fn) (void)) { - int max_pids, uid; - + char path[PATH_MAX + 1]; + char cgroup_pids[PATH_MAX + 1]; + char catchall; + int uid, cgroup_ok = 0; uid = get_session_uid(); - max_pids = read_session_pids_limit(CGROUPS_V2_SLICE_FMT, uid, cleanup_fn); - if (max_pids < 0) - max_pids = read_session_pids_limit(CGROUPS_V1_SLICE_FMT, uid, - cleanup_fn); - if (max_pids < 0) - return -1; + /* Check for generic cgroup v1 pid.max */ + cgroup_ok = FILE_LINES_SCANF(cleanup_fn, "/proc/self/cgroup", + "%*d :pids: %s\n", &cgroup_pids); + /* + * This is a bit of hack of scanf format strings. It only works forward + * which means that if a variable has been matched, but not a later + * part of the format it still counts as a match. Thus, we need a + * catch-all match later in the string that will _not_ be counted if + * the static part of the format doesn't match. + * This way, the macro will go on the next line rather than returning + * on a line matching the %s but not the static part later. + * + * Assume that the root of the mount is /. It can technically be anything, + * but it should be / on any normal system. + */ + if (!cgroup_ok) + cgroup_ok = FILE_LINES_SCANF(cleanup_fn, "/proc/self/mountinfo", + "%*s %*s %*s %*s %s %*s %*s - %*s cgroup %*[rw],pid%c", + &path, &catchall); + + if (!cgroup_ok) { + strncat(path, cgroup_pids, PATH_MAX); + strncat(path, "/pids.max", PATH_MAX); + return read_session_pids_limit(path, uid, cleanup_fn); + } - return max_pids; + /* Check for generic cgroup v2 pid.max */ + cgroup_ok = FILE_LINES_SCANF(cleanup_fn, "/proc/self/cgroup", + "%*d :: %s\n", &cgroup_pids); + if (!cgroup_ok) + cgroup_ok = FILE_LINES_SCANF(cleanup_fn, "/proc/self/mountinfo", + "%*s %*s %*s %*s %s %*s %*s - cgroup2 %c", + &path, &catchall); + + if (!cgroup_ok) { + strncat(path, cgroup_pids, PATH_MAX); + strncat(path, "/pids.max", PATH_MAX); + return read_session_pids_limit(path, uid, cleanup_fn); + } + + return -1; } int tst_get_free_pids_(void (*cleanup_fn) (void)) -- 2.25.1

1 year, 3 months

2
11
0 0

[PATCH] ioctl/test_ioctl: Source test framework

by Teo Couprie Diaz

test_ioctl calls functions from the shell test framework but does not source it. For unexplained reasons this works on a regular LTP build, but not ours. Source the framework to be able to successfully complete. Signed-off-by: Teo Couprie Diaz <teo.coupriediaz(a)arm.com> --- NB: This needs a change to the build script used for LTP fix the failure. Indeed, the build framework is in the testcases/lib target which we do not build by default, thus not making the framework available anyway. testcases/kernel/syscalls/ioctl/test_ioctl | 2 ++ 1 file changed, 2 insertions(+) diff --git a/testcases/kernel/syscalls/ioctl/test_ioctl b/testcases/kernel/syscalls/ioctl/test_ioctl index 923275433..cf960dd35 100755 --- a/testcases/kernel/syscalls/ioctl/test_ioctl +++ b/testcases/kernel/syscalls/ioctl/test_ioctl @@ -23,6 +23,8 @@ export TCID=ioctl01_02 export TST_TOTAL=2 export TST_COUNT=0 +. test.sh + has_tty() { if command -v stty >/dev/null 2>&1; then -- 2.25.1

1 year, 3 months

2
3
0 0

[PATCH v2 0/1] Find cgroup pid.max programatically

by Teo Couprie Diaz

We observed failures of the msgstress0{3,4} because they hit the PID limit imposed by cgroup. This usually is not an issue as either: - the system is fast enough for the threads to complete before hitting the limit, - the PID limit is far higher than the number of threads started by the tests, - there is no cgroup restricting the PID count further, - the limit can be found in the cgroup user slice. In the case of our distributions on the Morello boards, neither of those is true. Indeed, the tasks do not complete fast enough to prevent hitting the limit, the limit is quite low (4915 PIDs!) because of the low number of cores and the default limit set by systemd of 15% per service, and the root user is not in its own cgroup user-slice, rather under the serial or sshd service, depending on the access method to the board. This means that we needed to find a way in the test to find this limit. In this patch, I implement it by checking /proc/self/cgroup and /proc/self/mountinfo to find the cgroup imposing the PID limit as well as where the cgroup sysfs is mounted, if it is. This has proven more reliable than the previous patch's implementation and more stable, however it is still imperfect in a few ways: - it cannot find the limit if the cgroup sysfs is not mounted, - it assumes only one cgroup imposing limits (might be OK), - it assumes the cgroup is the one with the limit (it might be set by a parent cgroup), - it assumes the mountinfo peer groups are consistent across systems. It also introduces a few warings as I use a #define to set the array lengths, which cannot be used in the format string to limit the number of characters. An alternate solution could be implemented by writing a shell script parsing this data directly and passing it as an argument to the affected tests. See for example runtest/cap_bounds or runtest/commands. But this implies changing each affected tests. To note, upstream is aware that those tests are quite broken[0]. There was a patch series updating them but it was never followed-through. As this is not really Morello related, rather it is directly linked to the tests and the systems they are run on, this change might be shelved undefinitely. Thanks a lot to Beata for the help while investigating this ! [0]: https://lists.linux.it/pipermail/ltp/2022-January/027163.html Teo Couprie Diaz (1): lib/tst_pid: Find cgroup pid.max programatically lib/tst_pid.c | 43 +++++++++++++++++++ .../syscalls/ipc/msgstress/msgstress03.c | 2 +- 2 files changed, 44 insertions(+), 1 deletion(-) -- 2.25.1

1 year, 3 months

2
8
0 0

[PATCH v3 1/2] syscalls/mq_open: Avoid the libc syscall wrapper

by Amit Daniel Kachhap

Musl and glibc syscall wrappers handles the null mq name in different ways and report different errors. Glibc reports error if the mq_name is not preceded by "/" character but musl does not treat this as an error. Avoid the syscall wrapper by calling the syscall directly. This needs skipping the leading "/" character in mq_name as expected by the kernel. Signed-off-by: Amit Daniel Kachhap <amit.kachhap(a)arm.com> --- Changes in v3: * Updated commit messages for musl and glibc as pointed by Beata. testcases/kernel/syscalls/mq_open/mq_open01.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/testcases/kernel/syscalls/mq_open/mq_open01.c b/testcases/kernel/syscalls/mq_open/mq_open01.c index cd2a229d8..06858991e 100644 --- a/testcases/kernel/syscalls/mq_open/mq_open01.c +++ b/testcases/kernel/syscalls/mq_open/mq_open01.c @@ -14,6 +14,7 @@ #include "tst_test.h" #include "tst_safe_file_ops.h" #include "tst_safe_posix_ipc.h" +#include "lapi/syscalls.h" #define QUEUE_NAME "/test_mqueue" #define QUEUE_INIT "/init_mqueue" @@ -95,7 +96,7 @@ static struct test_case tcase[] = { .qname = "", .oflag = O_CREAT, .ret = -1, - .err = EINVAL, + .err = ENOENT, }, { .desc = "NORMAL", @@ -228,7 +229,10 @@ static void do_test(unsigned int i) if (tc->setup) tc->setup(); - TEST(fd = mq_open(qname, tc->oflag, S_IRWXU, tc->rq)); + if (*qname == '/') + TEST(fd = tst_syscall(__NR_mq_open, qname + 1, tc->oflag, S_IRWXU, tc->rq)); + else + TEST(fd = tst_syscall(__NR_mq_open, qname, tc->oflag, S_IRWXU, tc->rq)); if (fd > 0 && tc->rq) { if (mq_getattr(fd, &oldattr) < 0) { -- 2.25.1

1 year, 3 months

2
3
0 0

[RFC PATCH 0/1] Fixes for msgstress0{3,4}

by Teo Couprie Diaz

This fixes two tests that were failing in our debian distribution because of a PID limit imposed by systemd which was not properly detected. This was fixed by adding another file to read the max_pid from that should be available everywhere. This worked for msgstress04, but doing some testing msgstress03 still hit the limit. Printing the number of PIDs in use, it seems like msgstress03 had some accounting issues, the real number of PIDs in use always being 5-10% greater than what it thought it was. Not finding where this accounting error was, I reduced the number of free PIDs by 10% which proved to do the trick. I'm not too sure about these solutions and would be happy to receive some feedback, hence the RFC state. (It might make sense to split the patch as well, but it would be two very small diffs.) Thanks in advance ! Teo Couprie Diaz (1): lib/tst_pid: Add a new file to get pid_max lib/tst_pid.c | 4 ++++ testcases/kernel/syscalls/ipc/msgstress/msgstress03.c | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) -- 2.25.1

1 year, 3 months

3
11
0 0

[PATCH v2] syscalls/msync: map and unmap to get ENOMEM

by Teo Couprie Diaz

In order to get an unmapped memory area, the test case msync03 uses sbrk with an offset to make sure it is beyond the program break. This causes issues in purecap, where brk is disabled, and in plain aarch64 due to a buggy sbrk implemention in Musl (ver. 1.5). Instead, don't rely on sbrk at all and use an mmaped page, unmap it and use this pointer in order to get an unmapped area of memory. This guarantees an ENOMEM in both compat and purecap. Signed-off-by: Teo Couprie Diaz <teo.coupriediaz(a)arm.com> --- testcases/kernel/syscalls/msync/msync03.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/testcases/kernel/syscalls/msync/msync03.c b/testcases/kernel/syscalls/msync/msync03.c index 8fa62e57a..3231bac1e 100644 --- a/testcases/kernel/syscalls/msync/msync03.c +++ b/testcases/kernel/syscalls/msync/msync03.c @@ -120,7 +120,8 @@ static void setup(void) nwrite += BUF_SIZE; } - addr1 = SAFE_MMAP(cleanup, 0, page_sz, PROT_READ | PROT_WRITE, + /* addr4 will point to the second page which will be unmapped. */ + addr1 = SAFE_MMAP(cleanup, 0, page_sz*2, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_LOCKED, fd, 0); /* addr2 is not a multiple of PAGESIZE */ @@ -130,8 +131,9 @@ static void setup(void) SAFE_GETRLIMIT(NULL, RLIMIT_DATA, &rl); addr3 = (char *)(uintptr_t)rl.rlim_max; - /* memory pointed to by addr4 was not mapped */ - addr4 = sbrk(0) + (4 * page_sz); + /* memory pointed to by addr4 is not mapped */ + addr4 = addr1 + page_sz; + SAFE_MUNMAP(cleanup, addr4, page_sz); } static void msync_verify(struct test_case_t *tc) -- 2.25.1

1 year, 4 months

3
2
0 0

2024

2023

2022

linux-morello-ltp