[LTP] [PATCH 0/3] syscalls: munmap: Convert to new API

[LTP] [PATCH 0/3] syscalls: munmap: Convert to new API

[Ricardo B. Marlière via ltp]

Signed-off-by: Ricardo B. Marlière <rbm@suse.com>
---
Ricardo B. Marlière (3):
      syscalls: munmap01: Convert to new API
      syscalls: munmap02: Make it a variant of munmap01
      syscalls: munmap03: Convert to new API

 runtest/syscalls                            |   1 -
 testcases/kernel/syscalls/munmap/.gitignore |   1 -
 testcases/kernel/syscalls/munmap/munmap01.c | 269 ++++++++--------------------
 testcases/kernel/syscalls/munmap/munmap02.c | 252 --------------------------
 testcases/kernel/syscalls/munmap/munmap03.c | 162 +++++------------
 5 files changed, 122 insertions(+), 563 deletions(-)
---
base-commit: 16cd67ef1f85e6b14c182fa49632a5014560edfa
change-id: 20250703-conversions-munmap-3b6a29faa268

Best regards,
-- 
Ricardo B. Marlière <rbm@suse.com>


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH 1/3] syscalls: munmap01: Convert to new API

[Ricardo B. Marlière via ltp]

From: Ricardo B. Marlière <rbm@suse.com>

Signed-off-by: Ricardo B. Marlière <rbm@suse.com>
---
 testcases/kernel/syscalls/munmap/munmap01.c | 244 ++++++----------------------
 1 file changed, 52 insertions(+), 192 deletions(-)

diff --git a/testcases/kernel/syscalls/munmap/munmap01.c b/testcases/kernel/syscalls/munmap/munmap01.c
index dfd81fa2b32de2354a8053c4b7ebf1d518b8bb67..b602c3094d7b351a69afe84b0c9c03d72078e64d 100644
--- a/testcases/kernel/syscalls/munmap/munmap01.c
+++ b/testcases/kernel/syscalls/munmap/munmap01.c
@@ -1,157 +1,55 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
- *
- *   Copyright (c) International Business Machines  Corp., 2001
- *
- *   This program is free software;  you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program 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 General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program;  if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Copyright (c) International Business Machines  Corp., 2001
+ *	07/2001 Ported by Wayne Boyer
+ * Copyright (c) 2025 SUSE LLC Ricardo B. Marlière <rbm@suse.com>
  */
 
-/*
- * Test Name: munmap01
+/*\
+ * Verify that, munmap call will succeed to unmap a mapped file or
+ * anonymous shared memory region from the calling process's address space
+ * and after successful completion of munmap, the unmapped region is no
+ * longer accessible.
  *
- * Test Description:
- *  Verify that, munmap call will succeed to unmap a mapped file or
- *  anonymous shared memory region from the calling process's address space
- *  and after successful completion of munmap, the unmapped region is no
- *  longer accessible.
- *
- * Expected Result:
- *  munmap call should succeed to unmap a mapped file or anonymous shared
- *  memory region from the process's address space and it returns with a
- *  value 0, further reference to the unmapped region should result in a
- *  segmentation fault (SIGSEGV).
- *
- * Algorithm:
- *  Setup:
- *   Setup signal handling.
- *   Create temporary directory.
- *   Pause for SIGUSR1 if option specified.
- *
- *  Test:
- *   Loop if the proper options are given.
- *   Execute system call
- *   Check return code, if system call failed (return=-1)
- *   	Log the errno and Issue a FAIL message.
- *   Otherwise,
- *   	Verify the Functionality of system call
- *      if successful,
- *      	Issue Functionality-Pass message.
- *      Otherwise,
- *		Issue Functionality-Fail message.
- *  Cleanup:
- *   Print errno log and/or timing stats if options given
- *   Delete the temporary directory created.
- *
- * Usage:  <for command-line>
- *  munmap01 [-c n] [-f] [-i n] [-I x] [-P x] [-t]
- *     where,  -c n : Run n copies concurrently.
- *             -f   : Turn off functionality Testing.
- *	       -i n : Execute test n times.
- *	       -I x : Execute test for x seconds.
- *	       -P x : Pause for x seconds between iterations.
- *	       -t   : Turn on syscall timing.
- *
- * HISTORY
- *	07/2001 Ported by Wayne Boyer
- *
- * RESTRICTIONS:
- *  None.$
+ * munmap call should succeed to unmap a mapped file or anonymous shared
+ * memory region from the process's address space and it returns with a
+ * value 0, further reference to the unmapped region should result in a
+ * segmentation fault (SIGSEGV).
  */
-#include <errno.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <sys/mman.h>
-
-#include "test.h"
-#include "safe_macros.h"
-
-#define TEMPFILE	"mmapfile"
 
-char *TCID = "munmap01";
-int TST_TOTAL = 1;
+#include "tst_test.h"
 
-char *addr;			/* addr of memory mapped region */
-int fildes;			/* file descriptor for tempfile */
-unsigned int map_len;		/* length of the region to be mapped */
+static int fd;
+static char *map_addr;
+static unsigned int map_len;
 
-void setup();			/* Main setup function of test */
-void cleanup();			/* cleanup function for the test */
-void sig_handler();		/* signal catching function */
-
-int main(int ac, char **av)
+static void run(void)
 {
-	int lc;
-
-	tst_parse_opts(ac, av, NULL, NULL);
-
-	for (lc = 0; TEST_LOOPING(lc); lc++) {
-
-		tst_count = 0;
-
-		setup();
-
-		/*
-		 * Call munmap to unmap the mapped region of the
-		 * temporary file from the calling process's address space.
-		 */
-		TEST(munmap(addr, map_len));
-
-		/* Check for the return value of munmap() */
-		if (TEST_RETURN == -1) {
-			tst_resm(TFAIL, "munmap() fails, errno=%d : %s",
-				 TEST_ERRNO, strerror(TEST_ERRNO));
-			continue;
-		}
-
-		/*
-		 * Check whether further reference is possible
-		 * to the unmapped memory region by writing
-		 * to the first byte of region with
-		 * some arbitrary number.
-		 */
-		*addr = 50;
+	SAFE_MUNMAP(map_addr, map_len);
 
-		/* This message is printed if no SIGSEGV */
-		tst_resm(TFAIL, "process succeeds to refer unmapped memory region");
+	/*
+	 * Check whether further reference is possible to the unmapped memory
+	 * region by writing to the first byte of region with some arbitrary
+	 * number.
+	 */
+	*map_addr = 50;
 
-		cleanup();
+	/* This message is printed if no SIGSEGV */
+	tst_res(TFAIL, "process succeeds to refer unmapped memory region");
+}
 
-	}
-	tst_exit();
+static void sig_handler(LTP_ATTRIBUTE_UNUSED int i)
+{
+	tst_res(TPASS, "Functionality of munmap() successful");
+	_exit(0);
 }
 
-/*
- * setup() - performs all ONE TIME setup for this test.
- *
- * Set up signal handler to catch SIGSEGV.
- * Get system page size, create a temporary file for reading/writing,
- * write one byte data into it, map the open file for the specified
- * map length.
- */
-void setup(void)
+static void setup(void)
 {
 	size_t page_sz;
 
-	tst_sig(NOFORK, DEF_HANDLER, cleanup);
-
-	/* call signal function to trap the signal generated */
-	if (signal(SIGSEGV, sig_handler) == SIG_ERR) {
-		tst_brkm(TBROK, cleanup, "signal fails to catch signal");
-	}
-
-	TEST_PAUSE;
+	/* Call signal function to trap the signal generated */
+	SAFE_SIGNAL(SIGSEGV, sig_handler);
 
 	/* Get the system page size */
 	page_sz = getpagesize();
@@ -162,74 +60,36 @@ void setup(void)
 	 */
 	map_len = 3 * page_sz;
 
-	tst_tmpdir();
-
-	/* Creat a temporary file used for mapping */
-	if ((fildes = open(TEMPFILE, O_RDWR | O_CREAT, 0666)) < 0) {
-		tst_brkm(TBROK, cleanup, "open() on %s Failed, errno=%d : %s",
-			 TEMPFILE, errno, strerror(errno));
-	}
+	/* Create a temporary file used for mapping */
+	fd = SAFE_OPEN("mmapfile", O_RDWR | O_CREAT, 0666);
 
 	/*
-	 * move the file pointer to maplength position from the beginning
+	 * Move the file pointer to maplength position from the beginning
 	 * of the file.
 	 */
-	SAFE_LSEEK(cleanup, fildes, map_len, SEEK_SET);
+	SAFE_LSEEK(fd, map_len, SEEK_SET);
 
 	/* Write one byte into temporary file */
-	if (write(fildes, "a", 1) != 1) {
-		tst_brkm(TBROK, cleanup, "write() on %s Failed, errno=%d : %s",
-			 TEMPFILE, errno, strerror(errno));
-	}
+	SAFE_WRITE(SAFE_WRITE_ALL, fd, "a", 1);
 
 	/*
-	 * map the open file 'TEMPFILE' from its beginning up to the maplength
+	 * Map the open file 'mmapfile' from its beginning up to the maplength
 	 * into the calling process's address space at the system choosen
 	 * with read/write permissions to the mapped region.
 	 */
-	addr = mmap(0, map_len, PROT_READ | PROT_WRITE,
-		    MAP_FILE | MAP_SHARED, fildes, 0);
-
-	/* check for the return value of mmap system call */
-	if (addr == (char *)MAP_FAILED) {
-		tst_brkm(TBROK, cleanup, "mmap() Failed on %s, errno=%d : %s",
-			 TEMPFILE, errno, strerror(errno));
-	}
-
+	map_addr = SAFE_MMAP(0, map_len, PROT_READ | PROT_WRITE,
+			     MAP_FILE | MAP_SHARED, fd, 0);
 }
 
-/*
- * sig_handler() - signal catching function.
- *   This function is used to trap the signal generated when tried to read or
- *   write to the memory mapped region which is already detached from the
- *   calling process address space.
- *   this function is invoked when SIGSEGV generated and it calls test
- *   cleanup function and exit the program.
- */
-void sig_handler(void)
+static void cleanup(void)
 {
-	tst_resm(TPASS, "Functionality of munmap() successful");
-
-	/* Invoke test cleanup function and exit */
-	cleanup();
-
-	tst_exit();
+	if (fd)
+		SAFE_CLOSE(fd);
 }
 
-/*
- * cleanup() - performs all ONE TIME cleanup for this test at
- *             completion or premature exit.
- *  	       Close the temporary file.
- *  	       Remove the temporary directory.
- */
-void cleanup(void)
-{
-
-	/* Close the temporary file */
-	if (close(fildes) < 0) {
-		tst_brkm(TFAIL, NULL, "close() on %s Failed, errno=%d : %s",
-			 TEMPFILE, errno, strerror(errno));
-	}
-
-	tst_rmdir();
-}
+static struct tst_test test = {
+	.test_all = run,
+	.setup = setup,
+	.cleanup = cleanup,
+	.needs_tmpdir = 1,
+};

-- 
2.50.0


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH 2/3] syscalls: munmap02: Make it a variant of munmap01

[Ricardo B. Marlière via ltp]

From: Ricardo B. Marlière <rbm@suse.com>

Signed-off-by: Ricardo B. Marlière <rbm@suse.com>
---
 runtest/syscalls                            |   1 -
 testcases/kernel/syscalls/munmap/.gitignore |   1 -
 testcases/kernel/syscalls/munmap/munmap01.c |  47 +++++-
 testcases/kernel/syscalls/munmap/munmap02.c | 252 ----------------------------
 4 files changed, 38 insertions(+), 263 deletions(-)

diff --git a/runtest/syscalls b/runtest/syscalls
index 582422ac9ca8ccae598c626a11cf6ee7c30f0e3a..9c80bccb09114d8b9730fdee05e3e28f5cc44afc 100644
--- a/runtest/syscalls
+++ b/runtest/syscalls
@@ -949,7 +949,6 @@ munlock02 munlock02
 munlockall01 munlockall01
 
 munmap01 munmap01
-munmap02 munmap02
 munmap03 munmap03
 
 nanosleep01 nanosleep01
diff --git a/testcases/kernel/syscalls/munmap/.gitignore b/testcases/kernel/syscalls/munmap/.gitignore
index 94d8c10a24cae47c6805546bff41a84a2a2e8173..aa6e14a670e85dd17f965b4a465997a021f8b4ac 100644
--- a/testcases/kernel/syscalls/munmap/.gitignore
+++ b/testcases/kernel/syscalls/munmap/.gitignore
@@ -1,3 +1,2 @@
 /munmap01
-/munmap02
 /munmap03
diff --git a/testcases/kernel/syscalls/munmap/munmap01.c b/testcases/kernel/syscalls/munmap/munmap01.c
index b602c3094d7b351a69afe84b0c9c03d72078e64d..de85a48d5bdeb278473bada279bd286e74fd6cdb 100644
--- a/testcases/kernel/syscalls/munmap/munmap01.c
+++ b/testcases/kernel/syscalls/munmap/munmap01.c
@@ -9,12 +9,12 @@
  * Verify that, munmap call will succeed to unmap a mapped file or
  * anonymous shared memory region from the calling process's address space
  * and after successful completion of munmap, the unmapped region is no
- * longer accessible.
+ * longer accessible (even if partially unmapped).
  *
- * munmap call should succeed to unmap a mapped file or anonymous shared
- * memory region from the process's address space and it returns with a
- * value 0, further reference to the unmapped region should result in a
- * segmentation fault (SIGSEGV).
+ * munmap call should succeed to unmap a part or all of the mapped region of
+ * a file or anonymous shared memory region from the process's address space
+ * and it returns with a value 0, further reference to the unmapped region
+ * should result in a segmentation fault (SIGSEGV).
  */
 
 #include "tst_test.h"
@@ -22,6 +22,10 @@
 static int fd;
 static char *map_addr;
 static unsigned int map_len;
+static const char *const variants[] = {
+	"unmapped region not accessible",
+	"partially unmapped region not accessible",
+};
 
 static void run(void)
 {
@@ -46,14 +50,13 @@ static void sig_handler(LTP_ATTRIBUTE_UNUSED int i)
 
 static void setup(void)
 {
-	size_t page_sz;
+	size_t page_sz = getpagesize();
+
+	tst_res(TINFO, "Testing variant: %s", variants[tst_variant]);
 
 	/* Call signal function to trap the signal generated */
 	SAFE_SIGNAL(SIGSEGV, sig_handler);
 
-	/* Get the system page size */
-	page_sz = getpagesize();
-
 	/*
 	 * Get the length of the open file to be mapped into process
 	 * address space.
@@ -79,10 +82,35 @@ static void setup(void)
 	 */
 	map_addr = SAFE_MMAP(0, map_len, PROT_READ | PROT_WRITE,
 			     MAP_FILE | MAP_SHARED, fd, 0);
+
+	if (tst_variant) {
+		/*
+		 * Increment the start address of the region at which the file
+		 * is mapped to a maplength of 3 times the system page size by
+		 * the value of system  page size and decrement the maplength
+		 * value by the value of system page size.
+		 */
+		map_addr = (char *)((long)map_addr + page_sz);
+		map_len = map_len - page_sz;
+	}
 }
 
 static void cleanup(void)
 {
+	size_t page_sz = getpagesize();
+
+	if (tst_variant) {
+		/*
+		 * Get the start address and length of the portion of
+		 * the mapped region of the file.
+		 */
+		map_addr = (char *)((long)map_addr - page_sz);
+		map_len = map_len - page_sz;
+
+		/* Unmap the portion of the region of the file left unmapped */
+		SAFE_MUNMAP(map_addr, map_len);
+	}
+
 	if (fd)
 		SAFE_CLOSE(fd);
 }
@@ -92,4 +120,5 @@ static struct tst_test test = {
 	.setup = setup,
 	.cleanup = cleanup,
 	.needs_tmpdir = 1,
+	.test_variants = ARRAY_SIZE(variants),
 };
diff --git a/testcases/kernel/syscalls/munmap/munmap02.c b/testcases/kernel/syscalls/munmap/munmap02.c
deleted file mode 100644
index 311c0ea14a2f1b7120c792095c6990a7d2aa16d8..0000000000000000000000000000000000000000
--- a/testcases/kernel/syscalls/munmap/munmap02.c
+++ /dev/null
@@ -1,252 +0,0 @@
-/*
- *
- *   Copyright (c) International Business Machines  Corp., 2001
- *
- *   This program is free software;  you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program 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 General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program;  if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/*
- * Test Name: munmap02
- *
- * Test Description:
- *  Verify that, munmap call will succeed to unmap a mapped file or
- *  anonymous shared memory region from the calling process's address space
- *  if the region specified by the address and the length is part or all of
- *  the mapped region.
- *
- * Expected Result:
- *  munmap call should succeed to unmap a part or all of mapped region of a
- *  file or anonymous shared memory from the process's address space and it
- *  returns with a value 0,
- *  further reference to the unmapped region should result in a segmentation
- *  fault (SIGSEGV).
- *
- * Algorithm:
- *  Setup:
- *   Setup signal handling.
- *   Create temporary directory.
- *   Pause for SIGUSR1 if option specified.
- *
- *  Test:
- *   Loop if the proper options are given.
- *   Execute system call
- *   Check return code, if system call failed (return=-1)
- *   	Log the errno and Issue a FAIL message.
- *   Otherwise,
- *   	Verify the Functionality of system call
- *      if successful,
- *      	Issue Functionality-Pass message.
- *      Otherwise,
- *		Issue Functionality-Fail message.
- *  Cleanup:
- *   Print errno log and/or timing stats if options given
- *   Delete the temporary directory created.
- *
- * Usage:  <for command-line>
- *  munmap01 [-c n] [-f] [-i n] [-I x] [-P x] [-t]
- *     where,  -c n : Run n copies concurrently.
- *             -f   : Turn off functionality Testing.
- *	       -i n : Execute test n times.
- *	       -I x : Execute test for x seconds.
- *	       -P x : Pause for x seconds between iterations.
- *	       -t   : Turn on syscall timing.
- *
- * HISTORY
- *	07/2001 Ported by Wayne Boyer
- *
- * RESTRICTIONS:
- *  None.
- */
-#include <errno.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <sys/mman.h>
-
-#include "test.h"
-#include "safe_macros.h"
-
-#define TEMPFILE	"mmapfile"
-
-char *TCID = "munmap02";
-int TST_TOTAL = 1;
-
-static size_t page_sz;
-char *addr;			/* addr of memory mapped region */
-int fildes;			/* file descriptor for tempfile */
-unsigned int map_len;		/* length of the region to be mapped */
-
-void setup();			/* Main setup function of test */
-void cleanup();			/* cleanup function for the test */
-void sig_handler();		/* signal catching function */
-
-int main(int ac, char **av)
-{
-	int lc;
-
-	tst_parse_opts(ac, av, NULL, NULL);
-
-	for (lc = 0; TEST_LOOPING(lc); lc++) {
-
-		tst_count = 0;
-
-		setup();
-
-		/*
-		 * Call munmap to unmap the part of the mapped region of the
-		 * temporary file from the address and length that is part of
-		 * the mapped region.
-		 */
-		TEST(munmap(addr, map_len));
-
-		/* Check for the return value of munmap() */
-		if (TEST_RETURN == -1) {
-			tst_resm(TFAIL, "munmap() fails, errno=%d : %s",
-				 TEST_ERRNO, strerror(TEST_ERRNO));
-			continue;
-		}
-		/*
-		 * Check whether further reference is possible
-		 * to the unmapped memory region by writing
-		 * to the first byte of region with
-		 * some arbitrary number.
-		 */
-		*addr = 50;
-
-		/* This message is printed if no SIGSEGV */
-		tst_resm(TFAIL, "process succeeds to refer unmapped "
-			 "memory region");
-		cleanup();
-
-	}
-	tst_exit();
-}
-
-/*
- * setup() - performs all ONE TIME setup for this test.
- * Setup signal handler to catch SIGSEGV.
- * Get system page size, create a temporary file for reading/writing,
- * write one byte data into it, map the open file for the specified
- * map length.
- */
-void setup(void)
-{
-
-	tst_sig(NOFORK, DEF_HANDLER, cleanup);
-
-	/* call signal function to trap the signal generated */
-	if (signal(SIGSEGV, sig_handler) == SIG_ERR) {
-		tst_brkm(TBROK, cleanup, "signal fails to catch signal");
-	}
-
-	TEST_PAUSE;
-
-	/* Get the system page size */
-	page_sz = getpagesize();
-
-	/*
-	 * Get the length of the open file to be mapped into process
-	 * address space.
-	 */
-	map_len = 3 * page_sz;
-
-	tst_tmpdir();
-
-	/* Creat a temporary file used for mapping */
-	if ((fildes = open(TEMPFILE, O_RDWR | O_CREAT, 0666)) < 0) {
-		tst_brkm(TBROK, cleanup, "open() on %s Failed, errno=%d : %s",
-			 TEMPFILE, errno, strerror(errno));
-	}
-
-	/*
-	 * move the file pointer to maplength position from the beginning
-	 * of the file.
-	 */
-	SAFE_LSEEK(cleanup, fildes, map_len, SEEK_SET);
-
-	/* Write one byte into temporary file */
-	if (write(fildes, "a", 1) != 1) {
-		tst_brkm(TBROK, cleanup, "write() on %s Failed, errno=%d : %s",
-			 TEMPFILE, errno, strerror(errno));
-	}
-
-	/*
-	 * map the open file 'TEMPFILE' from its beginning up to the maplength
-	 * into the calling process's address space at the system choosen
-	 * with read/write permissions to the mapped region.
-	 */
-	addr = mmap(0, map_len, PROT_READ | PROT_WRITE,
-		    MAP_FILE | MAP_SHARED, fildes, 0);
-
-	/* check for the return value of mmap system call */
-	if (addr == (char *)MAP_FAILED) {
-		tst_brkm(TBROK, cleanup, "mmap() Failed on %s, errno=%d : %s",
-			 TEMPFILE, errno, strerror(errno));
-	}
-
-	/*
-	 * increment the start address of the region at which the file is
-	 * mapped to a maplength of 3 times the system page size by the value
-	 * of system  page size and decrement the maplength value by the value
-	 * of system page size.
-	 */
-	addr = (char *)((long)addr + page_sz);
-	map_len = map_len - page_sz;
-}
-
-/*
- * void
- * sig_handler() - signal catching function.
- *   This function is used to trap the signal generated when tried to read or
- *   write to the memory mapped region which is already detached from the
- *   calling process address space.
- *   this function is invoked when SIGSEGV generated and it calls test
- *   cleanup function and exit the program.
- */
-void sig_handler(void)
-{
-	tst_resm(TPASS, "Functionality of munmap() successful");
-
-	/* Invoke test cleanup function and exit */
-	cleanup();
-
-	tst_exit();
-}
-
-/*
- * cleanup() - performs all ONE TIME cleanup for this test at
- *             completion or premature exit.
- *  Unmap the portion of the region of the file left unmapped.
- *  Close the temporary file.
- *  Remove the temporary directory.
- */
-void cleanup(void)
-{
-
-	/*
-	 * get the start address and length of the portion of
-	 * the mapped region of the file.
-	 */
-	addr = (char *)((long)addr - page_sz);
-	map_len = map_len - page_sz;
-
-	/* unmap the portion of the region of the file left unmapped */
-	SAFE_MUNMAP(NULL, addr, map_len);
-
-	/* Close the temporary file */
-	SAFE_CLOSE(NULL, fildes);
-
-	tst_rmdir();
-}

-- 
2.50.0


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH 3/3] syscalls: munmap03: Convert to new API

[Ricardo B. Marlière via ltp]

From: Ricardo B. Marlière <rbm@suse.com>

Signed-off-by: Ricardo B. Marlière <rbm@suse.com>
---
 testcases/kernel/syscalls/munmap/munmap03.c | 162 ++++++++--------------------
 1 file changed, 43 insertions(+), 119 deletions(-)

diff --git a/testcases/kernel/syscalls/munmap/munmap03.c b/testcases/kernel/syscalls/munmap/munmap03.c
index 60bcb93b0e359b579294d6745e1e729340c0d92e..7aab587ad4ca0e0add973a7344a338240f485647 100644
--- a/testcases/kernel/syscalls/munmap/munmap03.c
+++ b/testcases/kernel/syscalls/munmap/munmap03.c
@@ -1,148 +1,72 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
- *
- *   Copyright (c) International Business Machines  Corp., 2001
- *
- *   This program is free software;  you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program 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 General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program;  if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Copyright (c) International Business Machines  Corp., 2001
+ *	07/2001 Ported by Wayne Boyer
+ * Copyright (c) 2025 SUSE LLC Ricardo B. Marlière <rbm@suse.com>
  */
 
-/*
- * Test Description:
- *  Verify that,
- *   1. munmap() fails with -1 return value and sets errno to EINVAL
- *      if addresses in the range [addr,addr+len) are outside the valid
- *	range for the address space of a process.
- *   2. munmap() fails with -1 return value and sets errno to EINVAL
- *      if the len argument is 0.
- *   3. munmap() fails with -1 return value and sets errno to EINVAL
- *      if the addr argument is not a multiple of the page size as
- *      returned by sysconf().
+/*\
+ * Verify that, munmap() fails with errno:
  *
- * HISTORY
- *	07/2001 Ported by Wayne Boyer
+ * - EINVAL, if addresses in the range [addr,addr+len) are outside the valid
+ *   range for the address space of a process.
+ * - EINVAL, if the len argument is 0.
+ * - EINVAL, if the addr argument is not a multiple of the page size as
+ *   returned by sysconf().
  */
 
-#include <errno.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <sys/resource.h>
-#include <sys/stat.h>
-
-#include "test.h"
-#include "safe_macros.h"
-
-char *TCID = "munmap03";
+#include "tst_test.h"
 
 static size_t page_sz;
 static char *global_addr;
 static size_t global_maplen;
 
-static void setup(void);
-static void cleanup(void);
+static struct tcase {
+	int exp_errno;
+	char *addr;
+	int len;
 
-static void test_einval1(void);
-static void test_einval2(void);
-static void test_einval3(void);
-static void (*testfunc[])(void) = { test_einval1, test_einval2, test_einval3 };
-int TST_TOTAL = ARRAY_SIZE(testfunc);
+} tcases[] = {
+	{ EINVAL, NULL, 0 },
+	{ EINVAL, NULL, 0 },
+	{ EINVAL, NULL, 0 },
+};
 
-int main(int ac, char **av)
+static void run(unsigned int i)
 {
-	int i, lc;
+	struct tcase *tc = &tcases[i];
 
-	tst_parse_opts(ac, av, NULL, NULL);
-
-	setup();
-
-	for (lc = 0; TEST_LOOPING(lc); lc++) {
-		tst_count = 0;
-
-		for (i = 0; i < TST_TOTAL; i++)
-			(*testfunc[i])();
-	}
-
-	cleanup();
-	tst_exit();
+	TST_EXP_FAIL(munmap(tc->addr, tc->len), EINVAL);
 }
 
 static void setup(void)
-{
-	tst_sig(NOFORK, DEF_HANDLER, cleanup);
-
-	TEST_PAUSE;
-
-	page_sz = (size_t)sysconf(_SC_PAGESIZE);
-
-	global_maplen = page_sz * 2;
-	global_addr = SAFE_MMAP(cleanup, NULL, global_maplen, PROT_READ |
-				PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-}
-
-static void check_and_print(int expected_errno)
-{
-	if (TEST_RETURN == -1) {
-		if (TEST_ERRNO == expected_errno) {
-			tst_resm(TPASS | TTERRNO, "failed as expected");
-		} else {
-			tst_resm(TFAIL | TTERRNO,
-				 "failed unexpectedly; expected - %d : %s",
-				 expected_errno, strerror(expected_errno));
-		}
-	} else {
-		tst_resm(TFAIL, "munmap succeeded unexpectedly");
-	}
-}
-
-static void test_einval1(void)
 {
 	struct rlimit brkval;
-	char *addr;
-	size_t map_len;
-
-	SAFE_GETRLIMIT(cleanup, RLIMIT_DATA, &brkval);
-
-	addr = (char *)brkval.rlim_max;
-	map_len = page_sz * 2;
-
-	TEST(munmap(addr, map_len));
 
-	check_and_print(EINVAL);
-}
-
-static void test_einval2(void)
-{
-	char *addr = global_addr;
-	size_t map_len = 0;
-
-	TEST(munmap(addr, map_len));
-
-	check_and_print(EINVAL);
-}
+	page_sz = getpagesize();
+	global_maplen = page_sz * 2;
+	global_addr = SAFE_MMAP(NULL, global_maplen, PROT_READ | PROT_WRITE,
+				MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 
-static void test_einval3(void)
-{
-	char *addr = (char *)(global_addr + 1);
-	size_t map_len = page_sz;
+	SAFE_GETRLIMIT(RLIMIT_DATA, &brkval);
+	tcases[0].addr = (char *)brkval.rlim_max;
+	tcases[0].len = page_sz * 2;
 
-	TEST(munmap(addr, map_len));
+	tcases[1].addr = global_addr;
+	tcases[1].len = 0;
 
-	check_and_print(EINVAL);
+	tcases[2].addr = (char *)(global_addr + 1);
+	tcases[2].len = page_sz;
 }
 
 static void cleanup(void)
 {
-	if (munmap(global_addr, global_maplen) == -1)
-		tst_resm(TWARN | TERRNO, "munmap failed");
+	SAFE_MUNMAP(global_addr, global_maplen);
 }
+
+static struct tst_test test = {
+	.test = run,
+	.tcnt = ARRAY_SIZE(tcases),
+	.setup = setup,
+	.cleanup = cleanup,
+};

-- 
2.50.0


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH 1/3] syscalls: munmap01: Convert to new API

[Andrea Cervesato via ltp]

Hi!

The conversion of the old API test is still bringing things which we 
want to get rid in the new test.
Read below.

On 7/3/25 8:39 PM, Ricardo B. Marlière via ltp wrote:
> From: Ricardo B. Marlière <rbm@suse.com>
>
> Signed-off-by: Ricardo B. Marlière <rbm@suse.com>
> ---
>   testcases/kernel/syscalls/munmap/munmap01.c | 244 ++++++----------------------
>   1 file changed, 52 insertions(+), 192 deletions(-)
>
> diff --git a/testcases/kernel/syscalls/munmap/munmap01.c b/testcases/kernel/syscalls/munmap/munmap01.c
> index dfd81fa2b32de2354a8053c4b7ebf1d518b8bb67..b602c3094d7b351a69afe84b0c9c03d72078e64d 100644
> --- a/testcases/kernel/syscalls/munmap/munmap01.c
> +++ b/testcases/kernel/syscalls/munmap/munmap01.c
> @@ -1,157 +1,55 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
>   /*
> - *
> - *   Copyright (c) International Business Machines  Corp., 2001
> - *
> - *   This program is free software;  you can redistribute it and/or modify
> - *   it under the terms of the GNU General Public License as published by
> - *   the Free Software Foundation; either version 2 of the License, or
> - *   (at your option) any later version.
> - *
> - *   This program 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 General Public License for more details.
> - *
> - *   You should have received a copy of the GNU General Public License
> - *   along with this program;  if not, write to the Free Software
> - *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + * Copyright (c) International Business Machines  Corp., 2001
> + *	07/2001 Ported by Wayne Boyer
> + * Copyright (c) 2025 SUSE LLC Ricardo B. Marlière <rbm@suse.com>
>    */
>   
> -/*
> - * Test Name: munmap01
> +/*\
> + * Verify that, munmap call will succeed to unmap a mapped file or
> + * anonymous shared memory region from the calling process's address space
> + * and after successful completion of munmap, the unmapped region is no
> + * longer accessible.
>    *
> - * Test Description:
> - *  Verify that, munmap call will succeed to unmap a mapped file or
> - *  anonymous shared memory region from the calling process's address space
> - *  and after successful completion of munmap, the unmapped region is no
> - *  longer accessible.
> - *
> - * Expected Result:
> - *  munmap call should succeed to unmap a mapped file or anonymous shared
> - *  memory region from the process's address space and it returns with a
> - *  value 0, further reference to the unmapped region should result in a
> - *  segmentation fault (SIGSEGV).
> - *
> - * Algorithm:
> - *  Setup:
> - *   Setup signal handling.
> - *   Create temporary directory.
> - *   Pause for SIGUSR1 if option specified.
> - *
> - *  Test:
> - *   Loop if the proper options are given.
> - *   Execute system call
> - *   Check return code, if system call failed (return=-1)
> - *   	Log the errno and Issue a FAIL message.
> - *   Otherwise,
> - *   	Verify the Functionality of system call
> - *      if successful,
> - *      	Issue Functionality-Pass message.
> - *      Otherwise,
> - *		Issue Functionality-Fail message.
> - *  Cleanup:
> - *   Print errno log and/or timing stats if options given
> - *   Delete the temporary directory created.
> - *
> - * Usage:  <for command-line>
> - *  munmap01 [-c n] [-f] [-i n] [-I x] [-P x] [-t]
> - *     where,  -c n : Run n copies concurrently.
> - *             -f   : Turn off functionality Testing.
> - *	       -i n : Execute test n times.
> - *	       -I x : Execute test for x seconds.
> - *	       -P x : Pause for x seconds between iterations.
> - *	       -t   : Turn on syscall timing.
> - *
> - * HISTORY
> - *	07/2001 Ported by Wayne Boyer
> - *
> - * RESTRICTIONS:
> - *  None.$
> + * munmap call should succeed to unmap a mapped file or anonymous shared
> + * memory region from the process's address space and it returns with a
> + * value 0, further reference to the unmapped region should result in a
> + * segmentation fault (SIGSEGV).
>    */
> -#include <errno.h>
> -#include <unistd.h>
> -#include <fcntl.h>
> -#include <sys/stat.h>
> -#include <sys/mman.h>
> -
> -#include "test.h"
> -#include "safe_macros.h"
> -
> -#define TEMPFILE	"mmapfile"
>   
> -char *TCID = "munmap01";
> -int TST_TOTAL = 1;
> +#include "tst_test.h"
>   
> -char *addr;			/* addr of memory mapped region */
> -int fildes;			/* file descriptor for tempfile */
> -unsigned int map_len;		/* length of the region to be mapped */
> +static int fd;
> +static char *map_addr;
> +static unsigned int map_len;
>   
> -void setup();			/* Main setup function of test */
> -void cleanup();			/* cleanup function for the test */
> -void sig_handler();		/* signal catching function */
> -
> -int main(int ac, char **av)
> +static void run(void)
>   {
> -	int lc;
> -
> -	tst_parse_opts(ac, av, NULL, NULL);
> -
> -	for (lc = 0; TEST_LOOPING(lc); lc++) {
> -
> -		tst_count = 0;
> -
> -		setup();
> -
> -		/*
> -		 * Call munmap to unmap the mapped region of the
> -		 * temporary file from the calling process's address space.
> -		 */
> -		TEST(munmap(addr, map_len));
> -
> -		/* Check for the return value of munmap() */
> -		if (TEST_RETURN == -1) {
> -			tst_resm(TFAIL, "munmap() fails, errno=%d : %s",
> -				 TEST_ERRNO, strerror(TEST_ERRNO));
> -			continue;
> -		}
> -
> -		/*
> -		 * Check whether further reference is possible
> -		 * to the unmapped memory region by writing
> -		 * to the first byte of region with
> -		 * some arbitrary number.
> -		 */
> -		*addr = 50;
> +	SAFE_MUNMAP(map_addr, map_len);
>   
> -		/* This message is printed if no SIGSEGV */
> -		tst_resm(TFAIL, "process succeeds to refer unmapped memory region");
> +	/*
> +	 * Check whether further reference is possible to the unmapped memory
> +	 * region by writing to the first byte of region with some arbitrary
> +	 * number.
> +	 */
> +	*map_addr = 50;
>   
> -		cleanup();
> +	/* This message is printed if no SIGSEGV */
> +	tst_res(TFAIL, "process succeeds to refer unmapped memory region");
> +}
>   
> -	}
> -	tst_exit();
> +static void sig_handler(LTP_ATTRIBUTE_UNUSED int i)
> +{
> +	tst_res(TPASS, "Functionality of munmap() successful");
> +	_exit(0);
>   }
Signals must be used carefully and in specific situations due to their 
asynchronous nature. In this case, we can just SAFE_FORK() a child and 
to verify that child has been signaled after accessing a un-mapped memory.
>   
> -/*
> - * setup() - performs all ONE TIME setup for this test.
> - *
> - * Set up signal handler to catch SIGSEGV.
> - * Get system page size, create a temporary file for reading/writing,
> - * write one byte data into it, map the open file for the specified
> - * map length.
> - */
> -void setup(void)
> +static void setup(void)
>   {
>   	size_t page_sz;
>   
> -	tst_sig(NOFORK, DEF_HANDLER, cleanup);
> -
> -	/* call signal function to trap the signal generated */
> -	if (signal(SIGSEGV, sig_handler) == SIG_ERR) {
> -		tst_brkm(TBROK, cleanup, "signal fails to catch signal");
> -	}
> -
> -	TEST_PAUSE;
> +	/* Call signal function to trap the signal generated */
> +	SAFE_SIGNAL(SIGSEGV, sig_handler);
>   
>   	/* Get the system page size */
>   	page_sz = getpagesize();
> @@ -162,74 +60,36 @@ void setup(void)
>   	 */
>   	map_len = 3 * page_sz;
>   
> -	tst_tmpdir();
> -
> -	/* Creat a temporary file used for mapping */
> -	if ((fildes = open(TEMPFILE, O_RDWR | O_CREAT, 0666)) < 0) {
> -		tst_brkm(TBROK, cleanup, "open() on %s Failed, errno=%d : %s",
> -			 TEMPFILE, errno, strerror(errno));
> -	}
> +	/* Create a temporary file used for mapping */
> +	fd = SAFE_OPEN("mmapfile", O_RDWR | O_CREAT, 0666);
>   
>   	/*
> -	 * move the file pointer to maplength position from the beginning
> +	 * Move the file pointer to maplength position from the beginning
>   	 * of the file.
>   	 */
> -	SAFE_LSEEK(cleanup, fildes, map_len, SEEK_SET);
> +	SAFE_LSEEK(fd, map_len, SEEK_SET);
>   
>   	/* Write one byte into temporary file */
> -	if (write(fildes, "a", 1) != 1) {
> -		tst_brkm(TBROK, cleanup, "write() on %s Failed, errno=%d : %s",
> -			 TEMPFILE, errno, strerror(errno));
> -	}
> +	SAFE_WRITE(SAFE_WRITE_ALL, fd, "a", 1);
>   
>   	/*
> -	 * map the open file 'TEMPFILE' from its beginning up to the maplength
> +	 * Map the open file 'mmapfile' from its beginning up to the maplength
>   	 * into the calling process's address space at the system choosen
>   	 * with read/write permissions to the mapped region.
>   	 */
> -	addr = mmap(0, map_len, PROT_READ | PROT_WRITE,
> -		    MAP_FILE | MAP_SHARED, fildes, 0);
> -
> -	/* check for the return value of mmap system call */
> -	if (addr == (char *)MAP_FAILED) {
> -		tst_brkm(TBROK, cleanup, "mmap() Failed on %s, errno=%d : %s",
> -			 TEMPFILE, errno, strerror(errno));
> -	}
> -
> +	map_addr = SAFE_MMAP(0, map_len, PROT_READ | PROT_WRITE,
> +			     MAP_FILE | MAP_SHARED, fd, 0);
>   }
>   
> -/*
> - * sig_handler() - signal catching function.
> - *   This function is used to trap the signal generated when tried to read or
> - *   write to the memory mapped region which is already detached from the
> - *   calling process address space.
> - *   this function is invoked when SIGSEGV generated and it calls test
> - *   cleanup function and exit the program.
> - */
> -void sig_handler(void)
> +static void cleanup(void)
>   {
> -	tst_resm(TPASS, "Functionality of munmap() successful");
> -
> -	/* Invoke test cleanup function and exit */
> -	cleanup();
> -
> -	tst_exit();
> +	if (fd)
> +		SAFE_CLOSE(fd);
>   }
>   
> -/*
> - * cleanup() - performs all ONE TIME cleanup for this test at
> - *             completion or premature exit.
> - *  	       Close the temporary file.
> - *  	       Remove the temporary directory.
> - */
> -void cleanup(void)
> -{
> -
> -	/* Close the temporary file */
> -	if (close(fildes) < 0) {
> -		tst_brkm(TFAIL, NULL, "close() on %s Failed, errno=%d : %s",
> -			 TEMPFILE, errno, strerror(errno));
> -	}
> -
> -	tst_rmdir();
> -}
> +static struct tst_test test = {
> +	.test_all = run,
> +	.setup = setup,
> +	.cleanup = cleanup,
> +	.needs_tmpdir = 1,
> +};

Also, please remove comments if not strictly needed, because they are 
kind of obvious when we read the test code.

- Andrea


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH 1/3] syscalls: munmap01: Convert to new API

[Andrea Cervesato via ltp]

On 7/3/25 8:39 PM, Ricardo B. Marlière via ltp wrote:
> +static void cleanup(void)
>   {
> -	tst_resm(TPASS, "Functionality of munmap() successful");
> -
> -	/* Invoke test cleanup function and exit */
> -	cleanup();
> -
> -	tst_exit();
> +	if (fd)
> +		SAFE_CLOSE(fd);
>   }

Also remember that test can be run with -i0, so if you don't unmap 
memory in the cleanup() function, that will remain allocated in the system.

- Andrea


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH 3/3] syscalls: munmap03: Convert to new API

[Andrea Cervesato via ltp]

Hi!

On 7/3/25 8:39 PM, Ricardo B. Marlière via ltp wrote:
> From: Ricardo B. Marlière <rbm@suse.com>
>
> Signed-off-by: Ricardo B. Marlière <rbm@suse.com>
> ---
>   testcases/kernel/syscalls/munmap/munmap03.c | 162 ++++++++--------------------
>   1 file changed, 43 insertions(+), 119 deletions(-)
>
> diff --git a/testcases/kernel/syscalls/munmap/munmap03.c b/testcases/kernel/syscalls/munmap/munmap03.c
> index 60bcb93b0e359b579294d6745e1e729340c0d92e..7aab587ad4ca0e0add973a7344a338240f485647 100644
> --- a/testcases/kernel/syscalls/munmap/munmap03.c
> +++ b/testcases/kernel/syscalls/munmap/munmap03.c
> @@ -1,148 +1,72 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
>   /*
> - *
> - *   Copyright (c) International Business Machines  Corp., 2001
> - *
> - *   This program is free software;  you can redistribute it and/or modify
> - *   it under the terms of the GNU General Public License as published by
> - *   the Free Software Foundation; either version 2 of the License, or
> - *   (at your option) any later version.
> - *
> - *   This program 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 General Public License for more details.
> - *
> - *   You should have received a copy of the GNU General Public License
> - *   along with this program;  if not, write to the Free Software
> - *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + * Copyright (c) International Business Machines  Corp., 2001
> + *	07/2001 Ported by Wayne Boyer
> + * Copyright (c) 2025 SUSE LLC Ricardo B. Marlière <rbm@suse.com>
>    */
>   
> -/*
> - * Test Description:
> - *  Verify that,
> - *   1. munmap() fails with -1 return value and sets errno to EINVAL
> - *      if addresses in the range [addr,addr+len) are outside the valid
> - *	range for the address space of a process.
> - *   2. munmap() fails with -1 return value and sets errno to EINVAL
> - *      if the len argument is 0.
> - *   3. munmap() fails with -1 return value and sets errno to EINVAL
> - *      if the addr argument is not a multiple of the page size as
> - *      returned by sysconf().
> +/*\
> + * Verify that, munmap() fails with errno:
>    *
> - * HISTORY
> - *	07/2001 Ported by Wayne Boyer
> + * - EINVAL, if addresses in the range [addr,addr+len) are outside the valid
> + *   range for the address space of a process.
> + * - EINVAL, if the len argument is 0.
> + * - EINVAL, if the addr argument is not a multiple of the page size as
> + *   returned by sysconf().
>    */
>   
> -#include <errno.h>
> -#include <unistd.h>
> -#include <fcntl.h>
> -#include <sys/mman.h>
> -#include <sys/resource.h>
> -#include <sys/stat.h>
> -
> -#include "test.h"
> -#include "safe_macros.h"
> -
> -char *TCID = "munmap03";
> +#include "tst_test.h"
>   
>   static size_t page_sz;
>   static char *global_addr;
>   static size_t global_maplen;
>   
> -static void setup(void);
> -static void cleanup(void);
> +static struct tcase {
> +	int exp_errno;
> +	char *addr;
> +	int len;
>   
> -static void test_einval1(void);
> -static void test_einval2(void);
> -static void test_einval3(void);
> -static void (*testfunc[])(void) = { test_einval1, test_einval2, test_einval3 };
> -int TST_TOTAL = ARRAY_SIZE(testfunc);
> +} tcases[] = {
> +	{ EINVAL, NULL, 0 },
> +	{ EINVAL, NULL, 0 },
> +	{ EINVAL, NULL, 0 },
> +};
>   
> -int main(int ac, char **av)
> +static void run(unsigned int i)
>   {
> -	int i, lc;
> +	struct tcase *tc = &tcases[i];
>   
> -	tst_parse_opts(ac, av, NULL, NULL);
> -
> -	setup();
> -
> -	for (lc = 0; TEST_LOOPING(lc); lc++) {
> -		tst_count = 0;
> -
> -		for (i = 0; i < TST_TOTAL; i++)
> -			(*testfunc[i])();
> -	}
> -
> -	cleanup();
> -	tst_exit();
> +	TST_EXP_FAIL(munmap(tc->addr, tc->len), EINVAL);
>   }
>   
>   static void setup(void)
> -{
> -	tst_sig(NOFORK, DEF_HANDLER, cleanup);
> -
> -	TEST_PAUSE;
> -
> -	page_sz = (size_t)sysconf(_SC_PAGESIZE);
> -
> -	global_maplen = page_sz * 2;
> -	global_addr = SAFE_MMAP(cleanup, NULL, global_maplen, PROT_READ |
> -				PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
> -}
> -
> -static void check_and_print(int expected_errno)
> -{
> -	if (TEST_RETURN == -1) {
> -		if (TEST_ERRNO == expected_errno) {
> -			tst_resm(TPASS | TTERRNO, "failed as expected");
> -		} else {
> -			tst_resm(TFAIL | TTERRNO,
> -				 "failed unexpectedly; expected - %d : %s",
> -				 expected_errno, strerror(expected_errno));
> -		}
> -	} else {
> -		tst_resm(TFAIL, "munmap succeeded unexpectedly");
> -	}
> -}
> -
> -static void test_einval1(void)
>   {
>   	struct rlimit brkval;
> -	char *addr;
> -	size_t map_len;
> -
> -	SAFE_GETRLIMIT(cleanup, RLIMIT_DATA, &brkval);
> -
> -	addr = (char *)brkval.rlim_max;
> -	map_len = page_sz * 2;
> -
> -	TEST(munmap(addr, map_len));
>   
> -	check_and_print(EINVAL);
> -}
> -
> -static void test_einval2(void)
> -{
> -	char *addr = global_addr;
> -	size_t map_len = 0;
> -
> -	TEST(munmap(addr, map_len));
> -
> -	check_and_print(EINVAL);
> -}
> +	page_sz = getpagesize();
> +	global_maplen = page_sz * 2;
> +	global_addr = SAFE_MMAP(NULL, global_maplen, PROT_READ | PROT_WRITE,
> +				MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
>   
> -static void test_einval3(void)
> -{
> -	char *addr = (char *)(global_addr + 1);
> -	size_t map_len = page_sz;
> +	SAFE_GETRLIMIT(RLIMIT_DATA, &brkval);
> +	tcases[0].addr = (char *)brkval.rlim_max;
> +	tcases[0].len = page_sz * 2;
>   
> -	TEST(munmap(addr, map_len));
> +	tcases[1].addr = global_addr;
> +	tcases[1].len = 0;
>   
> -	check_and_print(EINVAL);
> +	tcases[2].addr = (char *)(global_addr + 1);
> +	tcases[2].len = page_sz;
We don't usually use this approach because it's error prone. Instead, we 
create different static variables and we reference them to the structure 
after setting them inside setup(). For an example, you can take a look 
at lsm_set_self_attr01.c .
>   }
>   
>   static void cleanup(void)
>   {
> -	if (munmap(global_addr, global_maplen) == -1)
> -		tst_resm(TWARN | TERRNO, "munmap failed");
> +	SAFE_MUNMAP(global_addr, global_maplen);
>   }
> +
> +static struct tst_test test = {
> +	.test = run,
> +	.tcnt = ARRAY_SIZE(tcases),
> +	.setup = setup,
> +	.cleanup = cleanup,
> +};
>
We are still missing many other errors which could be tested. Please 
take a look at "man munmap" ERRORS section and try to verify how many of 
them could be actually be tested in this code by passing invalid data.

- Andrea


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH 1/3] syscalls: munmap01: Convert to new API

[Ricardo B. Marlière via ltp]

On Fri Jul 4, 2025 at 9:03 AM -03, Andrea Cervesato wrote:
> Hi!
>
> The conversion of the old API test is still bringing things which we 
> want to get rid in the new test.
> Read below.
>
> On 7/3/25 8:39 PM, Ricardo B. Marlière via ltp wrote:
>> From: Ricardo B. Marlière <rbm@suse.com>
>>
>> Signed-off-by: Ricardo B. Marlière <rbm@suse.com>
>> ---
>>   testcases/kernel/syscalls/munmap/munmap01.c | 244 ++++++----------------------
>>   1 file changed, 52 insertions(+), 192 deletions(-)
>>
>> diff --git a/testcases/kernel/syscalls/munmap/munmap01.c b/testcases/kernel/syscalls/munmap/munmap01.c
>> index dfd81fa2b32de2354a8053c4b7ebf1d518b8bb67..b602c3094d7b351a69afe84b0c9c03d72078e64d 100644
>> --- a/testcases/kernel/syscalls/munmap/munmap01.c
>> +++ b/testcases/kernel/syscalls/munmap/munmap01.c
>> @@ -1,157 +1,55 @@
>> +// SPDX-License-Identifier: GPL-2.0-or-later
>>   /*
>> - *
>> - *   Copyright (c) International Business Machines  Corp., 2001
>> - *
>> - *   This program is free software;  you can redistribute it and/or modify
>> - *   it under the terms of the GNU General Public License as published by
>> - *   the Free Software Foundation; either version 2 of the License, or
>> - *   (at your option) any later version.
>> - *
>> - *   This program 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 General Public License for more details.
>> - *
>> - *   You should have received a copy of the GNU General Public License
>> - *   along with this program;  if not, write to the Free Software
>> - *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
>> + * Copyright (c) International Business Machines  Corp., 2001
>> + *	07/2001 Ported by Wayne Boyer
>> + * Copyright (c) 2025 SUSE LLC Ricardo B. Marlière <rbm@suse.com>
>>    */
>>   
>> -/*
>> - * Test Name: munmap01
>> +/*\
>> + * Verify that, munmap call will succeed to unmap a mapped file or
>> + * anonymous shared memory region from the calling process's address space
>> + * and after successful completion of munmap, the unmapped region is no
>> + * longer accessible.
>>    *
>> - * Test Description:
>> - *  Verify that, munmap call will succeed to unmap a mapped file or
>> - *  anonymous shared memory region from the calling process's address space
>> - *  and after successful completion of munmap, the unmapped region is no
>> - *  longer accessible.
>> - *
>> - * Expected Result:
>> - *  munmap call should succeed to unmap a mapped file or anonymous shared
>> - *  memory region from the process's address space and it returns with a
>> - *  value 0, further reference to the unmapped region should result in a
>> - *  segmentation fault (SIGSEGV).
>> - *
>> - * Algorithm:
>> - *  Setup:
>> - *   Setup signal handling.
>> - *   Create temporary directory.
>> - *   Pause for SIGUSR1 if option specified.
>> - *
>> - *  Test:
>> - *   Loop if the proper options are given.
>> - *   Execute system call
>> - *   Check return code, if system call failed (return=-1)
>> - *   	Log the errno and Issue a FAIL message.
>> - *   Otherwise,
>> - *   	Verify the Functionality of system call
>> - *      if successful,
>> - *      	Issue Functionality-Pass message.
>> - *      Otherwise,
>> - *		Issue Functionality-Fail message.
>> - *  Cleanup:
>> - *   Print errno log and/or timing stats if options given
>> - *   Delete the temporary directory created.
>> - *
>> - * Usage:  <for command-line>
>> - *  munmap01 [-c n] [-f] [-i n] [-I x] [-P x] [-t]
>> - *     where,  -c n : Run n copies concurrently.
>> - *             -f   : Turn off functionality Testing.
>> - *	       -i n : Execute test n times.
>> - *	       -I x : Execute test for x seconds.
>> - *	       -P x : Pause for x seconds between iterations.
>> - *	       -t   : Turn on syscall timing.
>> - *
>> - * HISTORY
>> - *	07/2001 Ported by Wayne Boyer
>> - *
>> - * RESTRICTIONS:
>> - *  None.$
>> + * munmap call should succeed to unmap a mapped file or anonymous shared
>> + * memory region from the process's address space and it returns with a
>> + * value 0, further reference to the unmapped region should result in a
>> + * segmentation fault (SIGSEGV).
>>    */
>> -#include <errno.h>
>> -#include <unistd.h>
>> -#include <fcntl.h>
>> -#include <sys/stat.h>
>> -#include <sys/mman.h>
>> -
>> -#include "test.h"
>> -#include "safe_macros.h"
>> -
>> -#define TEMPFILE	"mmapfile"
>>   
>> -char *TCID = "munmap01";
>> -int TST_TOTAL = 1;
>> +#include "tst_test.h"
>>   
>> -char *addr;			/* addr of memory mapped region */
>> -int fildes;			/* file descriptor for tempfile */
>> -unsigned int map_len;		/* length of the region to be mapped */
>> +static int fd;
>> +static char *map_addr;
>> +static unsigned int map_len;
>>   
>> -void setup();			/* Main setup function of test */
>> -void cleanup();			/* cleanup function for the test */
>> -void sig_handler();		/* signal catching function */
>> -
>> -int main(int ac, char **av)
>> +static void run(void)
>>   {
>> -	int lc;
>> -
>> -	tst_parse_opts(ac, av, NULL, NULL);
>> -
>> -	for (lc = 0; TEST_LOOPING(lc); lc++) {
>> -
>> -		tst_count = 0;
>> -
>> -		setup();
>> -
>> -		/*
>> -		 * Call munmap to unmap the mapped region of the
>> -		 * temporary file from the calling process's address space.
>> -		 */
>> -		TEST(munmap(addr, map_len));
>> -
>> -		/* Check for the return value of munmap() */
>> -		if (TEST_RETURN == -1) {
>> -			tst_resm(TFAIL, "munmap() fails, errno=%d : %s",
>> -				 TEST_ERRNO, strerror(TEST_ERRNO));
>> -			continue;
>> -		}
>> -
>> -		/*
>> -		 * Check whether further reference is possible
>> -		 * to the unmapped memory region by writing
>> -		 * to the first byte of region with
>> -		 * some arbitrary number.
>> -		 */
>> -		*addr = 50;
>> +	SAFE_MUNMAP(map_addr, map_len);
>>   
>> -		/* This message is printed if no SIGSEGV */
>> -		tst_resm(TFAIL, "process succeeds to refer unmapped memory region");
>> +	/*
>> +	 * Check whether further reference is possible to the unmapped memory
>> +	 * region by writing to the first byte of region with some arbitrary
>> +	 * number.
>> +	 */
>> +	*map_addr = 50;
>>   
>> -		cleanup();
>> +	/* This message is printed if no SIGSEGV */
>> +	tst_res(TFAIL, "process succeeds to refer unmapped memory region");
>> +}
>>   
>> -	}
>> -	tst_exit();
>> +static void sig_handler(LTP_ATTRIBUTE_UNUSED int i)
>> +{
>> +	tst_res(TPASS, "Functionality of munmap() successful");
>> +	_exit(0);
>>   }
> Signals must be used carefully and in specific situations due to their 
> asynchronous nature. In this case, we can just SAFE_FORK() a child and 
> to verify that child has been signaled after accessing a un-mapped memory.

Ah, indeed.. Sorry about that, I keep forgetting some things even if I
did them before.

>>   
>> -/*
>> - * setup() - performs all ONE TIME setup for this test.
>> - *
>> - * Set up signal handler to catch SIGSEGV.
>> - * Get system page size, create a temporary file for reading/writing,
>> - * write one byte data into it, map the open file for the specified
>> - * map length.
>> - */
>> -void setup(void)
>> +static void setup(void)
>>   {
>>   	size_t page_sz;
>>   
>> -	tst_sig(NOFORK, DEF_HANDLER, cleanup);
>> -
>> -	/* call signal function to trap the signal generated */
>> -	if (signal(SIGSEGV, sig_handler) == SIG_ERR) {
>> -		tst_brkm(TBROK, cleanup, "signal fails to catch signal");
>> -	}
>> -
>> -	TEST_PAUSE;
>> +	/* Call signal function to trap the signal generated */
>> +	SAFE_SIGNAL(SIGSEGV, sig_handler);
>>   
>>   	/* Get the system page size */
>>   	page_sz = getpagesize();
>> @@ -162,74 +60,36 @@ void setup(void)
>>   	 */
>>   	map_len = 3 * page_sz;
>>   
>> -	tst_tmpdir();
>> -
>> -	/* Creat a temporary file used for mapping */
>> -	if ((fildes = open(TEMPFILE, O_RDWR | O_CREAT, 0666)) < 0) {
>> -		tst_brkm(TBROK, cleanup, "open() on %s Failed, errno=%d : %s",
>> -			 TEMPFILE, errno, strerror(errno));
>> -	}
>> +	/* Create a temporary file used for mapping */
>> +	fd = SAFE_OPEN("mmapfile", O_RDWR | O_CREAT, 0666);
>>   
>>   	/*
>> -	 * move the file pointer to maplength position from the beginning
>> +	 * Move the file pointer to maplength position from the beginning
>>   	 * of the file.
>>   	 */
>> -	SAFE_LSEEK(cleanup, fildes, map_len, SEEK_SET);
>> +	SAFE_LSEEK(fd, map_len, SEEK_SET);
>>   
>>   	/* Write one byte into temporary file */
>> -	if (write(fildes, "a", 1) != 1) {
>> -		tst_brkm(TBROK, cleanup, "write() on %s Failed, errno=%d : %s",
>> -			 TEMPFILE, errno, strerror(errno));
>> -	}
>> +	SAFE_WRITE(SAFE_WRITE_ALL, fd, "a", 1);
>>   
>>   	/*
>> -	 * map the open file 'TEMPFILE' from its beginning up to the maplength
>> +	 * Map the open file 'mmapfile' from its beginning up to the maplength
>>   	 * into the calling process's address space at the system choosen
>>   	 * with read/write permissions to the mapped region.
>>   	 */
>> -	addr = mmap(0, map_len, PROT_READ | PROT_WRITE,
>> -		    MAP_FILE | MAP_SHARED, fildes, 0);
>> -
>> -	/* check for the return value of mmap system call */
>> -	if (addr == (char *)MAP_FAILED) {
>> -		tst_brkm(TBROK, cleanup, "mmap() Failed on %s, errno=%d : %s",
>> -			 TEMPFILE, errno, strerror(errno));
>> -	}
>> -
>> +	map_addr = SAFE_MMAP(0, map_len, PROT_READ | PROT_WRITE,
>> +			     MAP_FILE | MAP_SHARED, fd, 0);
>>   }
>>   
>> -/*
>> - * sig_handler() - signal catching function.
>> - *   This function is used to trap the signal generated when tried to read or
>> - *   write to the memory mapped region which is already detached from the
>> - *   calling process address space.
>> - *   this function is invoked when SIGSEGV generated and it calls test
>> - *   cleanup function and exit the program.
>> - */
>> -void sig_handler(void)
>> +static void cleanup(void)
>>   {
>> -	tst_resm(TPASS, "Functionality of munmap() successful");
>> -
>> -	/* Invoke test cleanup function and exit */
>> -	cleanup();
>> -
>> -	tst_exit();
>> +	if (fd)
>> +		SAFE_CLOSE(fd);
>>   }
>>   
>> -/*
>> - * cleanup() - performs all ONE TIME cleanup for this test at
>> - *             completion or premature exit.
>> - *  	       Close the temporary file.
>> - *  	       Remove the temporary directory.
>> - */
>> -void cleanup(void)
>> -{
>> -
>> -	/* Close the temporary file */
>> -	if (close(fildes) < 0) {
>> -		tst_brkm(TFAIL, NULL, "close() on %s Failed, errno=%d : %s",
>> -			 TEMPFILE, errno, strerror(errno));
>> -	}
>> -
>> -	tst_rmdir();
>> -}
>> +static struct tst_test test = {
>> +	.test_all = run,
>> +	.setup = setup,
>> +	.cleanup = cleanup,
>> +	.needs_tmpdir = 1,
>> +};
>
> Also, please remove comments if not strictly needed, because they are 
> kind of obvious when we read the test code.

Sure!

Thanks for reviewing,
-	Ricardo.


>
> - Andrea


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH 3/3] syscalls: munmap03: Convert to new API

[Ricardo B. Marlière via ltp]

On Fri Jul 4, 2025 at 9:14 AM -03, Andrea Cervesato wrote:
> Hi!
>
> On 7/3/25 8:39 PM, Ricardo B. Marlière via ltp wrote:
>> From: Ricardo B. Marlière <rbm@suse.com>
>>
>> Signed-off-by: Ricardo B. Marlière <rbm@suse.com>
>> ---
>>   testcases/kernel/syscalls/munmap/munmap03.c | 162 ++++++++--------------------
>>   1 file changed, 43 insertions(+), 119 deletions(-)
>>
>> diff --git a/testcases/kernel/syscalls/munmap/munmap03.c b/testcases/kernel/syscalls/munmap/munmap03.c
>> index 60bcb93b0e359b579294d6745e1e729340c0d92e..7aab587ad4ca0e0add973a7344a338240f485647 100644
>> --- a/testcases/kernel/syscalls/munmap/munmap03.c
>> +++ b/testcases/kernel/syscalls/munmap/munmap03.c
>> @@ -1,148 +1,72 @@
>> +// SPDX-License-Identifier: GPL-2.0-or-later
>>   /*
>> - *
>> - *   Copyright (c) International Business Machines  Corp., 2001
>> - *
>> - *   This program is free software;  you can redistribute it and/or modify
>> - *   it under the terms of the GNU General Public License as published by
>> - *   the Free Software Foundation; either version 2 of the License, or
>> - *   (at your option) any later version.
>> - *
>> - *   This program 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 General Public License for more details.
>> - *
>> - *   You should have received a copy of the GNU General Public License
>> - *   along with this program;  if not, write to the Free Software
>> - *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
>> + * Copyright (c) International Business Machines  Corp., 2001
>> + *	07/2001 Ported by Wayne Boyer
>> + * Copyright (c) 2025 SUSE LLC Ricardo B. Marlière <rbm@suse.com>
>>    */
>>   
>> -/*
>> - * Test Description:
>> - *  Verify that,
>> - *   1. munmap() fails with -1 return value and sets errno to EINVAL
>> - *      if addresses in the range [addr,addr+len) are outside the valid
>> - *	range for the address space of a process.
>> - *   2. munmap() fails with -1 return value and sets errno to EINVAL
>> - *      if the len argument is 0.
>> - *   3. munmap() fails with -1 return value and sets errno to EINVAL
>> - *      if the addr argument is not a multiple of the page size as
>> - *      returned by sysconf().
>> +/*\
>> + * Verify that, munmap() fails with errno:
>>    *
>> - * HISTORY
>> - *	07/2001 Ported by Wayne Boyer
>> + * - EINVAL, if addresses in the range [addr,addr+len) are outside the valid
>> + *   range for the address space of a process.
>> + * - EINVAL, if the len argument is 0.
>> + * - EINVAL, if the addr argument is not a multiple of the page size as
>> + *   returned by sysconf().
>>    */
>>   
>> -#include <errno.h>
>> -#include <unistd.h>
>> -#include <fcntl.h>
>> -#include <sys/mman.h>
>> -#include <sys/resource.h>
>> -#include <sys/stat.h>
>> -
>> -#include "test.h"
>> -#include "safe_macros.h"
>> -
>> -char *TCID = "munmap03";
>> +#include "tst_test.h"
>>   
>>   static size_t page_sz;
>>   static char *global_addr;
>>   static size_t global_maplen;
>>   
>> -static void setup(void);
>> -static void cleanup(void);
>> +static struct tcase {
>> +	int exp_errno;
>> +	char *addr;
>> +	int len;
>>   
>> -static void test_einval1(void);
>> -static void test_einval2(void);
>> -static void test_einval3(void);
>> -static void (*testfunc[])(void) = { test_einval1, test_einval2, test_einval3 };
>> -int TST_TOTAL = ARRAY_SIZE(testfunc);
>> +} tcases[] = {
>> +	{ EINVAL, NULL, 0 },
>> +	{ EINVAL, NULL, 0 },
>> +	{ EINVAL, NULL, 0 },
>> +};
>>   
>> -int main(int ac, char **av)
>> +static void run(unsigned int i)
>>   {
>> -	int i, lc;
>> +	struct tcase *tc = &tcases[i];
>>   
>> -	tst_parse_opts(ac, av, NULL, NULL);
>> -
>> -	setup();
>> -
>> -	for (lc = 0; TEST_LOOPING(lc); lc++) {
>> -		tst_count = 0;
>> -
>> -		for (i = 0; i < TST_TOTAL; i++)
>> -			(*testfunc[i])();
>> -	}
>> -
>> -	cleanup();
>> -	tst_exit();
>> +	TST_EXP_FAIL(munmap(tc->addr, tc->len), EINVAL);
>>   }
>>   
>>   static void setup(void)
>> -{
>> -	tst_sig(NOFORK, DEF_HANDLER, cleanup);
>> -
>> -	TEST_PAUSE;
>> -
>> -	page_sz = (size_t)sysconf(_SC_PAGESIZE);
>> -
>> -	global_maplen = page_sz * 2;
>> -	global_addr = SAFE_MMAP(cleanup, NULL, global_maplen, PROT_READ |
>> -				PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
>> -}
>> -
>> -static void check_and_print(int expected_errno)
>> -{
>> -	if (TEST_RETURN == -1) {
>> -		if (TEST_ERRNO == expected_errno) {
>> -			tst_resm(TPASS | TTERRNO, "failed as expected");
>> -		} else {
>> -			tst_resm(TFAIL | TTERRNO,
>> -				 "failed unexpectedly; expected - %d : %s",
>> -				 expected_errno, strerror(expected_errno));
>> -		}
>> -	} else {
>> -		tst_resm(TFAIL, "munmap succeeded unexpectedly");
>> -	}
>> -}
>> -
>> -static void test_einval1(void)
>>   {
>>   	struct rlimit brkval;
>> -	char *addr;
>> -	size_t map_len;
>> -
>> -	SAFE_GETRLIMIT(cleanup, RLIMIT_DATA, &brkval);
>> -
>> -	addr = (char *)brkval.rlim_max;
>> -	map_len = page_sz * 2;
>> -
>> -	TEST(munmap(addr, map_len));
>>   
>> -	check_and_print(EINVAL);
>> -}
>> -
>> -static void test_einval2(void)
>> -{
>> -	char *addr = global_addr;
>> -	size_t map_len = 0;
>> -
>> -	TEST(munmap(addr, map_len));
>> -
>> -	check_and_print(EINVAL);
>> -}
>> +	page_sz = getpagesize();
>> +	global_maplen = page_sz * 2;
>> +	global_addr = SAFE_MMAP(NULL, global_maplen, PROT_READ | PROT_WRITE,
>> +				MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
>>   
>> -static void test_einval3(void)
>> -{
>> -	char *addr = (char *)(global_addr + 1);
>> -	size_t map_len = page_sz;
>> +	SAFE_GETRLIMIT(RLIMIT_DATA, &brkval);
>> +	tcases[0].addr = (char *)brkval.rlim_max;
>> +	tcases[0].len = page_sz * 2;
>>   
>> -	TEST(munmap(addr, map_len));
>> +	tcases[1].addr = global_addr;
>> +	tcases[1].len = 0;
>>   
>> -	check_and_print(EINVAL);
>> +	tcases[2].addr = (char *)(global_addr + 1);
>> +	tcases[2].len = page_sz;
> We don't usually use this approach because it's error prone. Instead, we 
> create different static variables and we reference them to the structure 
> after setting them inside setup(). For an example, you can take a look 
> at lsm_set_self_attr01.c .

Ack.

>>   }
>>   
>>   static void cleanup(void)
>>   {
>> -	if (munmap(global_addr, global_maplen) == -1)
>> -		tst_resm(TWARN | TERRNO, "munmap failed");
>> +	SAFE_MUNMAP(global_addr, global_maplen);
>>   }
>> +
>> +static struct tst_test test = {
>> +	.test = run,
>> +	.tcnt = ARRAY_SIZE(tcases),
>> +	.setup = setup,
>> +	.cleanup = cleanup,
>> +};
>>
> We are still missing many other errors which could be tested. Please 
> take a look at "man munmap" ERRORS section and try to verify how many of 
> them could be actually be tested in this code by passing invalid data.

Most of those are for mmap. The only one left seems to be ENOMEM, which
I don't think it's viable to test. WDYT?

>
> - Andrea


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH 3/3] syscalls: munmap03: Convert to new API

[Andrea Cervesato via ltp]

On 7/4/25 5:23 PM, Ricardo B. Marlière wrote:
> Most of those are for mmap. The only one left seems to be ENOMEM, which
> I don't think it's viable to test. WDYT?
I guess you mean:

        ENOMEM The  process's  maximum number of mappings would have been
               exceeded.  This error can also occur  for  munmap(), when
               unmapping  a  region in the middle of an existing mapping,
               since this results in two smaller mappings on either side

               of the region being unmapped.

Luckily it is testable, but we need a new test for that. What we can do 
is to read 
https://docs.kernel.org/admin-guide/sysctl/vm.html#max-map-count and to 
map the maximum amount of memory map areas. Then we munmap() in the 
middle of one of them, resulting in +1 mapped areas and obtaining ENOMEM 
from the syscall. Feel free to explore it.

- Andrea


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH 3/3] syscalls: munmap03: Convert to new API

[Ricardo B. Marlière via ltp]

On Fri Jul 4, 2025 at 1:26 PM -03, Andrea Cervesato wrote:
> On 7/4/25 5:23 PM, Ricardo B. Marlière wrote:
>> Most of those are for mmap. The only one left seems to be ENOMEM, which
>> I don't think it's viable to test. WDYT?
> I guess you mean:
>
>         ENOMEM The  process's  maximum number of mappings would have been
>                exceeded.  This error can also occur  for  munmap(), when
>                unmapping  a  region in the middle of an existing mapping,
>                since this results in two smaller mappings on either side
>
>                of the region being unmapped.
>
> Luckily it is testable, but we need a new test for that. What we can do 
> is to read 
> https://docs.kernel.org/admin-guide/sysctl/vm.html#max-map-count and to 
> map the maximum amount of memory map areas. Then we munmap() in the 
> middle of one of them, resulting in +1 mapped areas and obtaining ENOMEM 
> from the syscall. Feel free to explore it.
>

Thanks for the pointers, I'll give it a shot 8-)

> - Andrea


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp