Re: [LTP] landlock: fix make check warnings/errors

Re: [LTP] landlock: fix make check warnings/errors

[linuxtestproject.agent]

Hi Andrea,

On Mon, 06 Jul 2026, Andrea Cervesato wrote:
> landlock: fix make check warnings/errors

> -			if (strstr(readdir_files[i], de->d_name) != NULL)
> +			if (!strstr(readdir_files[i], de->d_name))
>  				files_counted++;

This inverts the condition. The original incremented files_counted when
de->d_name was found in readdir_files[i]. The patched version increments
it when de->d_name is NOT found.

Removing the redundant != NULL comparison should produce:

    if (strstr(readdir_files[i], de->d_name))
        files_counted++;

With the ! prefix the count tracks non-matches instead of matches, so
TST_EXP_EQ_LI(files_counted, ARRAY_SIZE(readdir_files)) at the end of
_test_readdir() will produce wrong results.

Verdict - Needs revision

---
Note:

The agent can sometimes produce false positives although often its
findings are genuine. If you find issues with the review, please
comment this email or ignore the suggestions.

Regards,
LTP AI Reviewer

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

[LTP] [PATCH v2] landlock: fix make check warnings/errors

[Andrea Cervesato]

From: Andrea Cervesato <andrea.cervesato@suse.com>

Signed-off-by: Andrea Cervesato <andrea.cervesato@suse.com>
---
Changes in v2:
- fix inverted statement
- Link to v1: https://lore.kernel.org/20260706-fix_make_check_landlock-v1-1-46f821b20128@suse.com
---
 testcases/kernel/syscalls/landlock/landlock01.c    |  7 +-
 testcases/kernel/syscalls/landlock/landlock02.c    | 17 ++---
 testcases/kernel/syscalls/landlock/landlock03.c    |  9 +--
 testcases/kernel/syscalls/landlock/landlock04.c    | 16 ++--
 testcases/kernel/syscalls/landlock/landlock05.c    | 28 +++----
 testcases/kernel/syscalls/landlock/landlock06.c    | 11 +--
 testcases/kernel/syscalls/landlock/landlock07.c    |  5 +-
 testcases/kernel/syscalls/landlock/landlock08.c    | 44 ++++-------
 testcases/kernel/syscalls/landlock/landlock09.c    |  2 +-
 .../kernel/syscalls/landlock/landlock_common.h     | 86 ++++++++--------------
 .../kernel/syscalls/landlock/landlock_tester.h     | 60 +++++++--------
 11 files changed, 104 insertions(+), 181 deletions(-)

diff --git a/testcases/kernel/syscalls/landlock/landlock01.c b/testcases/kernel/syscalls/landlock/landlock01.c
index bf206dae7751448419407b950b2aebc3f1708211..d817d97862c98a15b055812aed3ff9ddecd3ef14 100644
--- a/testcases/kernel/syscalls/landlock/landlock01.c
+++ b/testcases/kernel/syscalls/landlock/landlock01.c
@@ -44,11 +44,8 @@ static void run(unsigned int n)
 	if (*tc->attr)
 		(*tc->attr)->handled_access_fs = tc->access_fs;
 
-	TST_EXP_FAIL(tst_syscall(__NR_landlock_create_ruleset,
-			*tc->attr, *tc->size, tc->flags),
-		tc->exp_errno,
-		"%s",
-		tc->msg);
+	TST_EXP_FAIL(tst_syscall(__NR_landlock_create_ruleset, *tc->attr, *tc->size, tc->flags),
+		     tc->exp_errno, "%s", tc->msg);
 
 	if (TST_RET >= 0)
 		SAFE_CLOSE(TST_RET);
diff --git a/testcases/kernel/syscalls/landlock/landlock02.c b/testcases/kernel/syscalls/landlock/landlock02.c
index 37dc72d32c633a2f249c5a9ef879b6d288a63259..3edddfdeb0de2378cf312a7876247eadf102ff78 100644
--- a/testcases/kernel/syscalls/landlock/landlock02.c
+++ b/testcases/kernel/syscalls/landlock/landlock02.c
@@ -136,9 +136,8 @@ static void run(unsigned int n)
 		attr = *tc->net_attr;
 	}
 
-	TST_EXP_FAIL(tst_syscall(__NR_landlock_add_rule,
-		*tc->fd, tc->rule_type, attr, tc->flags),
-		tc->exp_errno, "%s", tc->msg);
+	TST_EXP_FAIL(tst_syscall(__NR_landlock_add_rule, *tc->fd, tc->rule_type, attr, tc->flags),
+		     tc->exp_errno, "%s", tc->msg);
 }
 
 static void setup(void)
@@ -150,14 +149,14 @@ static void setup(void)
 	attr_abi6->handled_access_fs = LANDLOCK_ACCESS_FS_EXECUTE;
 
 	if (abi_current < 4) {
-		ruleset_fd = TST_EXP_FD_SILENT(tst_syscall(__NR_landlock_create_ruleset,
-			attr_abi1, sizeof(struct tst_landlock_ruleset_attr_abi1), 0));
+		ruleset_fd = TST_EXP_FD_SILENT(tst_syscall(__NR_landlock_create_ruleset, attr_abi1,
+							   sizeof(struct tst_landlock_ruleset_attr_abi1), 0));
 	} else if (abi_current < 6) {
-		ruleset_fd = TST_EXP_FD_SILENT(tst_syscall(__NR_landlock_create_ruleset,
-			attr_abi4, sizeof(struct tst_landlock_ruleset_attr_abi4), 0));
+		ruleset_fd = TST_EXP_FD_SILENT(tst_syscall(__NR_landlock_create_ruleset, attr_abi4,
+							   sizeof(struct tst_landlock_ruleset_attr_abi4), 0));
 	} else {
-		ruleset_fd = TST_EXP_FD_SILENT(tst_syscall(__NR_landlock_create_ruleset,
-			attr_abi6, sizeof(struct tst_landlock_ruleset_attr_abi6), 0));
+		ruleset_fd = TST_EXP_FD_SILENT(tst_syscall(__NR_landlock_create_ruleset, attr_abi6,
+							   sizeof(struct tst_landlock_ruleset_attr_abi6), 0));
 	}
 }
 
diff --git a/testcases/kernel/syscalls/landlock/landlock03.c b/testcases/kernel/syscalls/landlock/landlock03.c
index 3c0cd56b0a12d1dafece3298f585f8b8ed0abcc2..cda636688c98e04f545fbd0fa7f280a6d244e259 100644
--- a/testcases/kernel/syscalls/landlock/landlock03.c
+++ b/testcases/kernel/syscalls/landlock/landlock03.c
@@ -56,15 +56,14 @@ static void run_child(struct tcase *tc)
 	if (tc->exp_errno == E2BIG) {
 		for (int i = 0; i < MAX_STACKED_RULESETS; i++) {
 			TST_EXP_PASS_SILENT(tst_syscall(__NR_landlock_restrict_self,
-				*tc->fd, tc->flags));
+							*tc->fd, tc->flags));
 			if (TST_RET == -1)
 				return;
 		}
 	}
 
 	TST_EXP_FAIL(tst_syscall(__NR_landlock_restrict_self, *tc->fd, tc->flags),
-		tc->exp_errno,
-		"%s", tc->msg);
+		     tc->exp_errno, "%s", tc->msg);
 
 	if (tc->exp_errno == EPERM)
 		tst_cap_action(&needadmin);
@@ -86,8 +85,8 @@ static void setup(void)
 
 	ruleset_attr->handled_access_fs = LANDLOCK_ACCESS_FS_EXECUTE;
 
-	ruleset_fd = TST_EXP_FD_SILENT(tst_syscall(__NR_landlock_create_ruleset,
-		ruleset_attr, sizeof(struct tst_landlock_ruleset_attr_abi1), 0));
+	ruleset_fd = TST_EXP_FD_SILENT(tst_syscall(__NR_landlock_create_ruleset, ruleset_attr,
+						   sizeof(struct tst_landlock_ruleset_attr_abi1), 0));
 
 	file_fd = SAFE_OPEN("junk.bin", O_CREAT, 0777);
 }
diff --git a/testcases/kernel/syscalls/landlock/landlock04.c b/testcases/kernel/syscalls/landlock/landlock04.c
index 86dc199942bb009beb9515b3b7d5011b864fcc58..ce1d6c37aad3125d9dca0e73463da473a1c7f5e5 100644
--- a/testcases/kernel/syscalls/landlock/landlock04.c
+++ b/testcases/kernel/syscalls/landlock/landlock04.c
@@ -6,7 +6,7 @@
 /*\
  * This test verifies that all landlock filesystem rules are working properly.
  * The way we do it is to verify that all disabled syscalls are not working but
- * the one we enabled via specifc landlock rules.
+ * the one we enabled via specific landlock rules.
  */
 
 #include "landlock_common.h"
@@ -104,7 +104,7 @@ static void enable_exec_libs(const int ruleset_fd)
 	fp = SAFE_FOPEN("/proc/self/maps", "r");
 
 	while (fgets(line, sizeof(line), fp)) {
-		if (strstr(line, ".so") == NULL)
+		if (!strstr(line, ".so"))
 			continue;
 
 		SAFE_SSCANF(line, "%*x-%*x %*s %*x %*s %*d %s", path);
@@ -131,8 +131,7 @@ static void enable_exec_libs(const int ruleset_fd)
 			LANDLOCK_ACCESS_FS_EXECUTE;
 		path_beneath_attr->parent_fd = SAFE_OPEN(path, O_PATH | O_CLOEXEC);
 
-		SAFE_LANDLOCK_ADD_RULE(
-			ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,	path_beneath_attr, 0);
+		SAFE_LANDLOCK_ADD_RULE(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,	path_beneath_attr, 0);
 
 		SAFE_CLOSE(path_beneath_attr->parent_fd);
 	}
@@ -164,8 +163,7 @@ static void setup(void)
 
 	ruleset_attr->handled_access_fs = supported_rules;
 
-	ruleset_fd = SAFE_LANDLOCK_CREATE_RULESET(
-		ruleset_attr, sizeof(struct tst_landlock_ruleset_attr_abi1), 0);
+	ruleset_fd = SAFE_LANDLOCK_CREATE_RULESET(ruleset_attr, sizeof(struct tst_landlock_ruleset_attr_abi1), 0);
 
 	/* since our binary is dynamically linked, we need to enable dependences
 	 * to be read and executed
@@ -177,11 +175,9 @@ static void setup(void)
 		SAFE_MKDIR(SANDBOX_FOLDER, PERM_MODE);
 
 	path_beneath_attr->allowed_access = variant.access;
-	path_beneath_attr->parent_fd = SAFE_OPEN(
-		SANDBOX_FOLDER, O_PATH | O_CLOEXEC);
+	path_beneath_attr->parent_fd = SAFE_OPEN(SANDBOX_FOLDER, O_PATH | O_CLOEXEC);
 
-	SAFE_LANDLOCK_ADD_RULE(
-		ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,	path_beneath_attr, 0);
+	SAFE_LANDLOCK_ADD_RULE(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,	path_beneath_attr, 0);
 
 	SAFE_CLOSE(path_beneath_attr->parent_fd);
 }
diff --git a/testcases/kernel/syscalls/landlock/landlock05.c b/testcases/kernel/syscalls/landlock/landlock05.c
index ad5e932b077499e43a91c8e32ae6fdf5fedf23f3..527ddfa1b369d7c1c03f945bb7a0d2a0ff92cfb0 100644
--- a/testcases/kernel/syscalls/landlock/landlock05.c
+++ b/testcases/kernel/syscalls/landlock/landlock05.c
@@ -19,12 +19,12 @@
 #include "landlock_common.h"
 
 #define MNTPOINT "sandbox"
-#define DIR1 MNTPOINT"/folder1"
-#define DIR2 MNTPOINT"/folder2"
-#define DIR3 MNTPOINT"/folder3"
-#define FILENAME1 DIR1"/file"
-#define FILENAME2 DIR2"/file"
-#define FILENAME3 DIR3"/file"
+#define DIR1 MNTPOINT "/folder1"
+#define DIR2 MNTPOINT "/folder2"
+#define DIR3 MNTPOINT "/folder3"
+#define FILENAME1 DIR1 "/file"
+#define FILENAME2 DIR2 "/file"
+#define FILENAME3 DIR3 "/file"
 
 static struct tst_landlock_ruleset_attr_abi1 *ruleset_attr;
 static struct landlock_path_beneath_attr *path_beneath_attr;
@@ -65,20 +65,10 @@ static void setup(void)
 		LANDLOCK_ACCESS_FS_WRITE_FILE |
 		LANDLOCK_ACCESS_FS_REFER;
 
-	ruleset_fd = SAFE_LANDLOCK_CREATE_RULESET(
-		ruleset_attr, sizeof(struct tst_landlock_ruleset_attr_abi1), 0);
+	ruleset_fd = SAFE_LANDLOCK_CREATE_RULESET(ruleset_attr, sizeof(struct tst_landlock_ruleset_attr_abi1), 0);
 
-	apply_landlock_fs_rule(
-		path_beneath_attr,
-		ruleset_fd,
-		LANDLOCK_ACCESS_FS_REFER,
-		DIR1);
-
-	apply_landlock_fs_rule(
-		path_beneath_attr,
-		ruleset_fd,
-		LANDLOCK_ACCESS_FS_REFER,
-		DIR2);
+	apply_landlock_fs_rule(path_beneath_attr, ruleset_fd, LANDLOCK_ACCESS_FS_REFER, DIR1);
+	apply_landlock_fs_rule(path_beneath_attr, ruleset_fd, LANDLOCK_ACCESS_FS_REFER, DIR2);
 
 	enforce_ruleset(ruleset_fd);
 
diff --git a/testcases/kernel/syscalls/landlock/landlock06.c b/testcases/kernel/syscalls/landlock/landlock06.c
index c2ac20d5939d20dd870efc6186f87d91a2476247..9d621a04791140b4d9352bee54352721e7e7717e 100644
--- a/testcases/kernel/syscalls/landlock/landlock06.c
+++ b/testcases/kernel/syscalls/landlock/landlock06.c
@@ -14,7 +14,7 @@
 #include <sys/ioctl.h>
 
 #define MNTPOINT "sandbox"
-#define FILENAME MNTPOINT"/fifo"
+#define FILENAME MNTPOINT "/fifo"
 
 static struct tst_landlock_ruleset_attr_abi1 *ruleset_attr;
 static struct landlock_path_beneath_attr *path_beneath_attr;
@@ -52,13 +52,8 @@ static void setup(void)
 
 	ruleset_attr->handled_access_fs = LANDLOCK_ACCESS_FS_IOCTL_DEV;
 
-	apply_landlock_fs_layer(
-		ruleset_attr,
-		sizeof(struct tst_landlock_ruleset_attr_abi1),
-		path_beneath_attr,
-		MNTPOINT,
-		LANDLOCK_ACCESS_FS_IOCTL_DEV
-	);
+	apply_landlock_fs_layer(ruleset_attr, sizeof(struct tst_landlock_ruleset_attr_abi1),
+				path_beneath_attr, MNTPOINT, LANDLOCK_ACCESS_FS_IOCTL_DEV);
 }
 
 static void cleanup(void)
diff --git a/testcases/kernel/syscalls/landlock/landlock07.c b/testcases/kernel/syscalls/landlock/landlock07.c
index 0dfa7ea111d8141caf6ea252f990fd0d564ceaa0..a9f8cc562dc6379ddfbb16db26c28e6a62cd841c 100644
--- a/testcases/kernel/syscalls/landlock/landlock07.c
+++ b/testcases/kernel/syscalls/landlock/landlock07.c
@@ -68,10 +68,7 @@ static void setup(void)
 	verify_landlock_is_enabled();
 
 	ruleset_attr->handled_access_fs = LANDLOCK_ACCESS_FS_WRITE_FILE;
-	ruleset_fd = SAFE_LANDLOCK_CREATE_RULESET(
-		ruleset_attr,
-		sizeof(struct tst_landlock_ruleset_attr_abi1),
-		0);
+	ruleset_fd = SAFE_LANDLOCK_CREATE_RULESET(ruleset_attr, sizeof(struct tst_landlock_ruleset_attr_abi1), 0);
 }
 
 static void cleanup(void)
diff --git a/testcases/kernel/syscalls/landlock/landlock08.c b/testcases/kernel/syscalls/landlock/landlock08.c
index 7e7d8470bf49662416f7c83a444876575b29fb16..c86880cd2f334780cb53b04fac99a9a557235bc2 100644
--- a/testcases/kernel/syscalls/landlock/landlock08.c
+++ b/testcases/kernel/syscalls/landlock/landlock08.c
@@ -58,8 +58,7 @@ static void create_server(const int addr_family)
 	SAFE_CLOSE(socket.fd);
 }
 
-static void test_bind(const int addr_family, const in_port_t port,
-	const int exp_err)
+static void test_bind(const int addr_family, const in_port_t port, const int exp_err)
 {
 	struct socket_data socket;
 	struct sockaddr *addr = NULL;
@@ -68,20 +67,17 @@ static void test_bind(const int addr_family, const in_port_t port,
 	getsocket_addr(&socket, addr_family, &addr);
 
 	if (exp_err) {
-		TST_EXP_FAIL(
-			bind(socket.fd, addr, socket.address_size),
-			exp_err, "bind() access on port %u", port);
+		TST_EXP_FAIL(bind(socket.fd, addr, socket.address_size),
+			     exp_err, "bind() access on port %u", port);
 	} else {
-		TST_EXP_PASS(
-			bind(socket.fd, addr, socket.address_size),
-			"bind() access on port %u", port);
+		TST_EXP_PASS(bind(socket.fd, addr, socket.address_size),
+			     "bind() access on port %u", port);
 	}
 
 	SAFE_CLOSE(socket.fd);
 }
 
-static void test_connect(const int addr_family, const in_port_t port,
-	const int exp_err)
+static void test_connect(const int addr_family, const in_port_t port, const int exp_err)
 {
 	struct socket_data socket;
 	struct sockaddr *addr = NULL;
@@ -90,13 +86,11 @@ static void test_connect(const int addr_family, const in_port_t port,
 	getsocket_addr(&socket, addr_family, &addr);
 
 	if (exp_err) {
-		TST_EXP_FAIL(
-			connect(socket.fd, addr, socket.address_size),
-			exp_err, "connect() on port %u", port);
+		TST_EXP_FAIL(connect(socket.fd, addr, socket.address_size),
+			     exp_err, "connect() on port %u", port);
 	} else {
-		TST_EXP_PASS(
-			connect(socket.fd, addr, socket.address_size),
-			"connect() on port %u", port);
+		TST_EXP_PASS(connect(socket.fd, addr, socket.address_size),
+			     "connect() on port %u", port);
 	}
 
 	SAFE_CLOSE(socket.fd);
@@ -142,12 +136,8 @@ static void run(void)
 		tst_res(TINFO, "Enable bind() access only for port %u",
 			addr_port);
 
-		apply_landlock_net_layer(
-			ruleset_attr,
-			sizeof(struct tst_landlock_ruleset_attr_abi4),
-			net_port_attr,
-			addr_port,
-			LANDLOCK_ACCESS_NET_BIND_TCP);
+		apply_landlock_net_layer(ruleset_attr, sizeof(struct tst_landlock_ruleset_attr_abi4),
+					 net_port_attr, addr_port, LANDLOCK_ACCESS_NET_BIND_TCP);
 
 		test_bind(addr_family, addr_port, 0);
 		test_bind(addr_family, addr_port + 0x80, EACCES);
@@ -165,12 +155,8 @@ static void run(void)
 		tst_res(TINFO, "Enable connect() access only on port %u",
 			*server_port);
 
-		apply_landlock_net_layer(
-			ruleset_attr,
-			sizeof(struct tst_landlock_ruleset_attr_abi4),
-			net_port_attr,
-			*server_port,
-			LANDLOCK_ACCESS_NET_CONNECT_TCP);
+		apply_landlock_net_layer(ruleset_attr, sizeof(struct tst_landlock_ruleset_attr_abi4),
+					 net_port_attr, *server_port, LANDLOCK_ACCESS_NET_CONNECT_TCP);
 
 		test_connect(addr_family, *server_port, 0);
 		test_connect(addr_family, *server_port + 0x80, EACCES);
@@ -189,7 +175,7 @@ static void setup(void)
 	addr_port = TST_GET_UNUSED_PORT(AF_INET, SOCK_STREAM);
 
 	server_port = SAFE_MMAP(NULL, sizeof(in_port_t), PROT_READ | PROT_WRITE,
-		MAP_SHARED | MAP_ANONYMOUS, -1, 0);
+				MAP_SHARED | MAP_ANONYMOUS, -1, 0);
 }
 
 static void cleanup(void)
diff --git a/testcases/kernel/syscalls/landlock/landlock09.c b/testcases/kernel/syscalls/landlock/landlock09.c
index 2e7f0021299152a1dbd0d7d7594487f551f04a24..09a762bb1b41b2caaddbc7a8316c47180508af8b 100644
--- a/testcases/kernel/syscalls/landlock/landlock09.c
+++ b/testcases/kernel/syscalls/landlock/landlock09.c
@@ -14,7 +14,7 @@
 #include "landlock_common.h"
 
 #define SOCKET_NAME "test.sock"
-#define ABSTRACT_SOCKET_NAME "\0"SOCKET_NAME
+#define ABSTRACT_SOCKET_NAME "\0" SOCKET_NAME
 #define SOCKET_LENGTH (offsetof(struct sockaddr_un, sun_path) + strlen(SOCKET_NAME) + 1)
 
 enum {
diff --git a/testcases/kernel/syscalls/landlock/landlock_common.h b/testcases/kernel/syscalls/landlock/landlock_common.h
index 8857745d6f1c1c30fc914924b8d0da381b36059f..dc63c0d86a5d0ce67abab6c23f20047402344d05 100644
--- a/testcases/kernel/syscalls/landlock/landlock_common.h
+++ b/testcases/kernel/syscalls/landlock/landlock_common.h
@@ -25,15 +25,11 @@ static inline int verify_landlock_is_enabled(void)
 {
 	int abi;
 
-	abi = tst_syscall(__NR_landlock_create_ruleset,
-		NULL, 0, LANDLOCK_CREATE_RULESET_VERSION);
+	abi = tst_syscall(__NR_landlock_create_ruleset, NULL, 0, LANDLOCK_CREATE_RULESET_VERSION);
 
 	if (abi < 0) {
-		if (errno == EOPNOTSUPP) {
-			tst_brk(TCONF, "Landlock is currently disabled. "
-				"Please enable it either via CONFIG_LSM or "
-				"'lsm' kernel parameter.");
-		}
+		if (errno == EOPNOTSUPP)
+			tst_brk(TCONF, "Landlock is currently disabled. Please enable it either via CONFIG_LSM or 'lsm' kernel parameter.");
 
 		tst_brk(TBROK | TERRNO, "landlock_create_ruleset error");
 	}
@@ -43,38 +39,26 @@ static inline int verify_landlock_is_enabled(void)
 	return abi;
 }
 
-static inline void apply_landlock_fs_rule(
-	struct landlock_path_beneath_attr *path_beneath_attr,
-	const int ruleset_fd,
-	const int access,
-	const char *path)
+static inline void apply_landlock_fs_rule(struct landlock_path_beneath_attr *path_beneath_attr,
+					  const int ruleset_fd, const int access, const char *path)
 {
 	path_beneath_attr->allowed_access = access;
 	path_beneath_attr->parent_fd = SAFE_OPEN(path, O_PATH | O_CLOEXEC);
 
-	SAFE_LANDLOCK_ADD_RULE(
-		ruleset_fd,
-		LANDLOCK_RULE_PATH_BENEATH,
-		path_beneath_attr,
-		0);
+	SAFE_LANDLOCK_ADD_RULE(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
+			       path_beneath_attr, 0);
 
 	SAFE_CLOSE(path_beneath_attr->parent_fd);
 }
 
-static inline void apply_landlock_net_rule(
-	struct landlock_net_port_attr *net_attr,
-	const int ruleset_fd,
-	const uint64_t port,
-	const uint64_t access)
+static inline void apply_landlock_net_rule(struct landlock_net_port_attr *net_attr,
+					   const int ruleset_fd, const uint64_t port,
+					   const uint64_t access)
 {
 	net_attr->port = port;
 	net_attr->allowed_access = access;
 
-	SAFE_LANDLOCK_ADD_RULE(
-		ruleset_fd,
-		LANDLOCK_RULE_NET_PORT,
-		net_attr,
-		0);
+	SAFE_LANDLOCK_ADD_RULE(ruleset_fd, LANDLOCK_RULE_NET_PORT, net_attr, 0);
 }
 
 static inline void enforce_ruleset(const int ruleset_fd)
@@ -83,11 +67,9 @@ static inline void enforce_ruleset(const int ruleset_fd)
 	SAFE_LANDLOCK_RESTRICT_SELF(ruleset_fd, 0);
 }
 
-static inline void apply_landlock_fs_layer(
-	void *ruleset_attr, size_t attr_size,
-	struct landlock_path_beneath_attr *path_beneath_attr,
-	const char *path,
-	const int access)
+static inline void apply_landlock_fs_layer(void *ruleset_attr, size_t attr_size,
+					   struct landlock_path_beneath_attr *path_beneath_attr,
+					   const char *path, const int access)
 {
 	int ruleset_fd;
 
@@ -99,11 +81,9 @@ static inline void apply_landlock_fs_layer(
 	SAFE_CLOSE(ruleset_fd);
 }
 
-static inline void apply_landlock_net_layer(
-	void *ruleset_attr, size_t attr_size,
-	struct landlock_net_port_attr *net_port_attr,
-	const in_port_t port,
-	const uint64_t access)
+static inline void apply_landlock_net_layer(void *ruleset_attr, size_t attr_size,
+					    struct landlock_net_port_attr *net_port_attr,
+					    const in_port_t port, const uint64_t access)
 {
 	int ruleset_fd;
 
@@ -115,8 +95,7 @@ static inline void apply_landlock_net_layer(
 	SAFE_CLOSE(ruleset_fd);
 }
 
-static inline void apply_landlock_scoped_layer(
-	void *ruleset_attr, size_t attr_size)
+static inline void apply_landlock_scoped_layer(void *ruleset_attr, size_t attr_size)
 {
 	int ruleset_fd;
 
@@ -126,8 +105,7 @@ static inline void apply_landlock_scoped_layer(
 	SAFE_CLOSE(ruleset_fd);
 }
 
-static inline in_port_t getsocket_port(struct socket_data *socket,
-	const int addr_family)
+static inline in_port_t getsocket_port(struct socket_data *socket, const int addr_family)
 {
 	struct sockaddr_in addr_ipv4;
 	struct sockaddr_in6 addr_ipv6;
@@ -158,30 +136,24 @@ static inline in_port_t getsocket_port(struct socket_data *socket,
 }
 
 static inline void create_socket(struct socket_data *socket,
-	const int addr_family, const in_port_t port)
+				 const int addr_family, const in_port_t port)
 {
 	memset(socket, 0, sizeof(struct socket_data));
 
 	switch (addr_family) {
 	case AF_INET:
-		if (!port) {
-			tst_init_sockaddr_inet_bin(&socket->addr_ipv4,
-				INADDR_ANY, 0);
-		} else {
-			tst_init_sockaddr_inet(&socket->addr_ipv4,
-				IPV4_LOCALHOST, port);
-		}
+		if (!port)
+			tst_init_sockaddr_inet_bin(&socket->addr_ipv4, INADDR_ANY, 0);
+		else
+			tst_init_sockaddr_inet(&socket->addr_ipv4, IPV4_LOCALHOST, port);
 
 		socket->address_size = sizeof(struct sockaddr_in);
 		break;
 	case AF_INET6:
-		if (!port) {
-			tst_init_sockaddr_inet6_bin(&socket->addr_ipv6,
-				&in6addr_any, 0);
-		} else {
-			tst_init_sockaddr_inet6(&socket->addr_ipv6,
-				IPV6_LOCALHOST, port);
-		}
+		if (!port)
+			tst_init_sockaddr_inet6_bin(&socket->addr_ipv6, &in6addr_any, 0);
+		else
+			tst_init_sockaddr_inet6(&socket->addr_ipv6, IPV6_LOCALHOST, port);
 
 		socket->address_size = sizeof(struct sockaddr_in6);
 		break;
@@ -194,7 +166,7 @@ static inline void create_socket(struct socket_data *socket,
 }
 
 static inline void getsocket_addr(struct socket_data *socket,
-	const int addr_family, struct sockaddr **addr)
+				  const int addr_family, struct sockaddr **addr)
 {
 	switch (addr_family) {
 	case AF_INET:
diff --git a/testcases/kernel/syscalls/landlock/landlock_tester.h b/testcases/kernel/syscalls/landlock/landlock_tester.h
index dcebc45cd785e7af284de9a8f27f048a40af2815..4e77e8a61fcdc1fe04f0a84819b68cbc0810d634 100644
--- a/testcases/kernel/syscalls/landlock/landlock_tester.h
+++ b/testcases/kernel/syscalls/landlock/landlock_tester.h
@@ -14,22 +14,22 @@
 #define SANDBOX_FOLDER	"sandbox"
 #define TESTAPP			"landlock_exec"
 
-#define FILE_EXEC		SANDBOX_FOLDER"/"TESTAPP
-#define FILE_READ		SANDBOX_FOLDER"/file_read"
-#define FILE_WRITE		SANDBOX_FOLDER"/file_write"
-#define FILE_REMOVE		SANDBOX_FOLDER"/file_remove"
-#define FILE_UNLINK		SANDBOX_FOLDER"/file_unlink"
-#define FILE_UNLINKAT	SANDBOX_FOLDER"/file_unlinkat"
-#define FILE_TRUNCATE	SANDBOX_FOLDER"/file_truncate"
-#define FILE_REGULAR	SANDBOX_FOLDER"/regular0"
-#define FILE_SOCKET		SANDBOX_FOLDER"/socket0"
-#define FILE_FIFO		SANDBOX_FOLDER"/fifo0"
-#define FILE_SYM0		SANDBOX_FOLDER"/symbolic0"
-#define FILE_SYM1		SANDBOX_FOLDER"/symbolic1"
-#define DIR_READDIR		SANDBOX_FOLDER"/dir_readdir"
-#define DIR_RMDIR		SANDBOX_FOLDER"/dir_rmdir"
-#define DEV_CHAR0		SANDBOX_FOLDER"/chardev0"
-#define DEV_BLK0		SANDBOX_FOLDER"/blkdev0"
+#define FILE_EXEC	SANDBOX_FOLDER "/" TESTAPP
+#define FILE_READ	SANDBOX_FOLDER "/file_read"
+#define FILE_WRITE	SANDBOX_FOLDER "/file_write"
+#define FILE_REMOVE	SANDBOX_FOLDER "/file_remove"
+#define FILE_UNLINK	SANDBOX_FOLDER "/file_unlink"
+#define FILE_UNLINKAT	SANDBOX_FOLDER "/file_unlinkat"
+#define FILE_TRUNCATE	SANDBOX_FOLDER "/file_truncate"
+#define FILE_REGULAR	SANDBOX_FOLDER "/regular0"
+#define FILE_SOCKET	SANDBOX_FOLDER "/socket0"
+#define FILE_FIFO	SANDBOX_FOLDER "/fifo0"
+#define FILE_SYM0	SANDBOX_FOLDER "/symbolic0"
+#define FILE_SYM1	SANDBOX_FOLDER "/symbolic1"
+#define DIR_READDIR	SANDBOX_FOLDER "/dir_readdir"
+#define DIR_RMDIR	SANDBOX_FOLDER "/dir_rmdir"
+#define DEV_CHAR0	SANDBOX_FOLDER "/chardev0"
+#define DEV_BLK0	SANDBOX_FOLDER "/blkdev0"
 
 #define ALL_RULES (\
 	LANDLOCK_ACCESS_FS_EXECUTE | \
@@ -50,9 +50,9 @@
 	LANDLOCK_ACCESS_FS_IOCTL_DEV)
 
 static char *readdir_files[] = {
-	DIR_READDIR"/file0",
-	DIR_READDIR"/file1",
-	DIR_READDIR"/file2",
+	DIR_READDIR "/file0",
+	DIR_READDIR "/file1",
+	DIR_READDIR "/file2",
 };
 
 static int dev_chr;
@@ -63,8 +63,7 @@ static int tester_get_all_fs_rules(void)
 	int abi;
 	int all_rules = ALL_RULES;
 
-	abi = SAFE_LANDLOCK_CREATE_RULESET(
-		NULL, 0, LANDLOCK_CREATE_RULESET_VERSION);
+	abi = SAFE_LANDLOCK_CREATE_RULESET(NULL, 0, LANDLOCK_CREATE_RULESET_VERSION);
 
 	if (abi < 2)
 		all_rules &= ~LANDLOCK_ACCESS_FS_REFER;
@@ -227,10 +226,10 @@ static void _test_readdir(const int result)
 			continue;
 
 		for (size_t i = 0; i < ARRAY_SIZE(readdir_files); i++) {
-			if (readdir_files[i] == NULL)
+			if (!readdir_files[i])
 				continue;
 
-			if (strstr(readdir_files[i], de->d_name) != NULL)
+			if (strstr(readdir_files[i], de->d_name))
 				files_counted++;
 		}
 	}
@@ -263,11 +262,7 @@ static void _test_rmfile(const int result)
 	}
 }
 
-static void _test_make(
-	const char *path,
-	const int type,
-	const int dev,
-	const int result)
+static void _test_make(const char *path, const int type, const int dev, const int result)
 {
 	tst_res(TINFO, "Test normal or special files creation");
 
@@ -314,8 +309,7 @@ static void _test_truncate(const int result)
 			SAFE_CLOSE(fd);
 		}
 
-		TST_EXP_FAIL(open(FILE_TRUNCATE, O_WRONLY | O_TRUNC, PERM_MODE),
-			EACCES);
+		TST_EXP_FAIL(open(FILE_TRUNCATE, O_WRONLY | O_TRUNC, PERM_MODE), EACCES);
 
 		if (TST_RET != -1)
 			SAFE_CLOSE(TST_RET);
@@ -346,7 +340,7 @@ static void tester_run_fs_rules(const int rules, const int result)
 		_test_make(FILE_REGULAR, S_IFREG, 0, result);
 
 	if (strcmp(tst_device->fs_type, "vfat") &&
-		strcmp(tst_device->fs_type, "exfat")) {
+	    strcmp(tst_device->fs_type, "exfat")) {
 		if (rules & LANDLOCK_ACCESS_FS_MAKE_CHAR)
 			_test_make(DEV_CHAR0, S_IFCHR, dev_chr, result);
 
@@ -366,9 +360,7 @@ static void tester_run_fs_rules(const int rules, const int result)
 	if (rules & LANDLOCK_ACCESS_FS_TRUNCATE) {
 		int abi;
 
-		abi = SAFE_LANDLOCK_CREATE_RULESET(
-			NULL, 0, LANDLOCK_CREATE_RULESET_VERSION);
-
+		abi = SAFE_LANDLOCK_CREATE_RULESET(NULL, 0, LANDLOCK_CREATE_RULESET_VERSION);
 		if (abi < 3) {
 			tst_res(TINFO, "Skip truncate test. Minimum ABI version is 3");
 			return;

---
base-commit: 0b891ea23ed7315afa12df92fe12f1218a420bde
change-id: 20260706-fix_make_check_landlock-38af9cbaed68

Best regards,
-- 
Andrea Cervesato <andrea.cervesato@suse.com>


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

Re: [LTP] landlock: fix make check warnings/errors

[linuxtestproject.agent]

Hi Andrea,

On Mon, 7 Jul 2026, Andrea Cervesato wrote:
> landlock: fix make check warnings/errors

> -		if (errno == EOPNOTSUPP) {
> -			tst_brk(TCONF, "Landlock is currently disabled. "
> -				"Please enable it either via CONFIG_LSM or "
> -				"'lsm' kernel parameter.");
> -		}
> +		if (errno == EOPNOTSUPP)
> +			tst_brk(TCONF, "Landlock is currently disabled. Please enable it either via CONFIG_LSM or 'lsm' kernel parameter.");

The new line in landlock_common.h is ~132 characters long. The
original multi-line string had an alignment warning, but this hunk
trades it for a line-over-80-characters warning, which checkpatch
will still flag.

Could the string be re-wrapped to satisfy the line-length limit,
for example:

    if (errno == EOPNOTSUPP)
        tst_brk(TCONF,
            "Landlock is currently disabled. Please "
            "enable it either via CONFIG_LSM or "
            "'lsm' kernel parameter.");

Verdict - Needs revision

---
Note:

The agent can sometimes produce false positives although often its
findings are genuine. If you find issues with the review, please
comment this email or ignore the suggestions.

Regards,
LTP AI Reviewer

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

Re: [LTP] [PATCH v2] landlock: fix make check warnings/errors

[Petr Vorel]

Hi Andrea,

Thanks for your effort!
Reviewed-by: Petr Vorel <pvorel@suse.cz>

https://lore.kernel.org/ltp/20260706200306.3982-1-linuxtestproject.agent@gmail.com/
Also, it'd be nice to teach the agent that splitting string into multiline
comments is worse than long lines.

Kind regards,
Petr

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

Re: [LTP] [PATCH v2] landlock: fix make check warnings/errors

[Andrea Cervesato via ltp]

Hi Petr,

> Hi Andrea,
> 
> Thanks for your effort!
> Reviewed-by: Petr Vorel <pvorel@suse.cz>
> 
> https://lore.kernel.org/ltp/20260706200306.3982-1-linuxtestproject.agent@gmail.com/
> Also, it'd be nice to teach the agent that splitting string into multiline
> comments is worse than long lines.

If you want to send a PR to the ltp-agent, this is a great exercise :-)

--
Andrea Cervesato
SUSE QE Automation Engineer Linux
andrea.cervesato@suse.com

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

Re: [LTP] [PATCH v2] landlock: fix make check warnings/errors

[Andrea Cervesato via ltp]

Merged, Thanks!

--
Andrea Cervesato
SUSE QE Automation Engineer Linux
andrea.cervesato@suse.com

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

Re: [LTP] [PATCH v2] landlock: fix make check warnings/errors

[Andrea Cervesato via ltp]

Merged, Thanks!

--
Andrea Cervesato
SUSE QE Automation Engineer Linux
andrea.cervesato@suse.com

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