tests: Cover directory-mode hardlink tracking

Add a test-lcfs.c unit test that builds a tmpdir containing a real
hardlink via lcfs_build() both with and without
LCFS_BUILD_TRACK_HARDLINKS, checking that the default preserves
today's nlink=1-for-everything behavior and that the new flag
produces a proper link_to/nlink=2 pair.

Also extend integration.sh with the exact repro from issue composefs#444
(dd + ln + mkcomposefs), checked via composefs-info dump rather than
a full mount since this doesn't need root or a kernel driver.

Assisted-by: AI
Signed-off-by: Colin Walters <walters@verbum.org>

Author: cgwalters

tests/integration.sh

@@ -56,6 +56,39 @@ run_test() {
 
 run_test /usr/bin "--no-nlink"
 
+# Regression test for https://github.com/composefs/composefs/issues/444:
+# building directly from a directory (as opposed to --from-file) used to
+# silently drop hardlinks, giving every file nlink=1 even if two paths
+# were hardlinked to each other. This is opt-in via --hardlinks, so also
+# confirm the (unchanged) default behavior.
+test_hardlinks() {
+    local dir=hardlink-test
+    rm -rf "${dir}"
+    mkdir -p "${dir}/src"
+    dd if=/dev/urandom of="${dir}/src/file1" bs=1024 count=4 status=none
+    ln "${dir}/src/file1" "${dir}/src/file2"
+
+    # Default (no --hardlinks): every path gets its own independent inode
+    # with nlink=1, matching this tool's historical behavior.
+    mkcomposefs "${dir}/src" "${dir}/default.cfs"
+    default_dump=$(composefs-info dump "${dir}/default.cfs")
+    test "$(echo "${default_dump}" | awk '$1=="/file1"{print $4}')" = "1"
+    test "$(echo "${default_dump}" | awk '$1=="/file2"{print $4}')" = "1"
+    ! echo "${default_dump}" | grep -q '^/file[12] [0-9]* @'
+
+    # --hardlinks: file1 and file2 are the same inode (nlink=2), with
+    # exactly one of the two recorded as a hardlink (the "@" marker from
+    # composefs-dump(5)) pointing at the other.
+    mkcomposefs --hardlinks "${dir}/src" "${dir}/hardlinks.cfs"
+    hl_dump=$(composefs-info dump "${dir}/hardlinks.cfs")
+    test "$(echo "${hl_dump}" | awk '$1=="/file1"{print $4}')" = "2"
+    test "$(echo "${hl_dump}" | awk '$1=="/file2"{print $4}')" = "2"
+    test "$(echo "${hl_dump}" | grep -c '^/file[12] [0-9]* @')" = "1"
+
+    rm -rf "${dir}"
+}
+test_hardlinks
+
 check_fsverity () {
     fsverity --version >/dev/null 2>&1 || return 1
     tmpfile=$(mktemp --tmpdir lcfs-fsverity.XXXXXX)

tests/test-lcfs.c

@@ -11,6 +11,9 @@
 #include <errno.h>
 #include <endian.h>
 #include <sys/stat.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <limits.h>
 
 static inline void lcfs_node_unrefp(struct lcfs_node_s **nodep)
 {
@@ -227,6 +230,82 @@ static void test_hardlinked_whiteout_load(void)
 	assert(errsv == EINVAL);
 }
 
+// Verifies that lcfs_build() only detects hardlinked regular files when
+// scanning a directory tree if LCFS_BUILD_TRACK_HARDLINKS is passed; by
+// default (matching historical behavior) every path gets its own
+// independent inode with nlink == 1.
+static void test_build_hardlinks(void)
+{
+	char tmpdir[] = "/tmp/test-build-hardlinks.XXXXXX";
+	assert(mkdtemp(tmpdir) != NULL);
+
+	char path1[PATH_MAX], path2[PATH_MAX];
+	snprintf(path1, sizeof(path1), "%s/file1", tmpdir);
+	snprintf(path2, sizeof(path2), "%s/file2", tmpdir);
+
+	int fd = open(path1, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+	assert(fd >= 0);
+	assert(write(fd, "hello", 5) == 5);
+	close(fd);
+
+	assert(link(path1, path2) == 0);
+
+	int dirfd = open(tmpdir, O_RDONLY | O_DIRECTORY);
+	assert(dirfd >= 0);
+
+	/* Without LCFS_BUILD_TRACK_HARDLINKS: today's default behavior is
+	 * that every path becomes an independent inode with nlink == 1. */
+	{
+		char *failed_path = NULL;
+		cleanup_node struct lcfs_node_s *root =
+			lcfs_build(dirfd, ".", 0, &failed_path);
+		assert(root != NULL);
+
+		struct lcfs_node_s *n1 = lcfs_node_lookup_child(root, "file1");
+		struct lcfs_node_s *n2 = lcfs_node_lookup_child(root, "file2");
+		assert(n1 != NULL);
+		assert(n2 != NULL);
+		assert(lcfs_node_get_hardlink_target(n1) == NULL);
+		assert(lcfs_node_get_hardlink_target(n2) == NULL);
+		assert(lcfs_node_get_nlink(n1) == 1);
+		assert(lcfs_node_get_nlink(n2) == 1);
+
+		assert(testwrite_node(root) == 0);
+	}
+
+	/* With LCFS_BUILD_TRACK_HARDLINKS: one of the two paths becomes a
+	 * hardlink to the other, and the target's nlink is bumped to 2. */
+	{
+		char *failed_path = NULL;
+		cleanup_node struct lcfs_node_s *root = lcfs_build(
+			dirfd, ".", LCFS_BUILD_TRACK_HARDLINKS, &failed_path);
+		assert(root != NULL);
+
+		struct lcfs_node_s *n1 = lcfs_node_lookup_child(root, "file1");
+		struct lcfs_node_s *n2 = lcfs_node_lookup_child(root, "file2");
+		assert(n1 != NULL);
+		assert(n2 != NULL);
+
+		/* Whichever of the two is visited first by readdir() becomes
+		 * the canonical inode; the other becomes a hardlink to it. */
+		struct lcfs_node_s *target1 = lcfs_node_get_hardlink_target(n1);
+		struct lcfs_node_s *target2 = lcfs_node_get_hardlink_target(n2);
+		assert((target1 == NULL) != (target2 == NULL));
+
+		struct lcfs_node_s *link_node = target1 != NULL ? n1 : n2;
+		struct lcfs_node_s *target_node = target1 != NULL ? n2 : n1;
+		assert(lcfs_node_get_hardlink_target(link_node) == target_node);
+		assert(lcfs_node_get_nlink(target_node) == 2);
+
+		assert(testwrite_node(root) == 0);
+	}
+
+	close(dirfd);
+	unlink(path1);
+	unlink(path2);
+	rmdir(tmpdir);
+}
+
 // Verifies that lcfs_fd_measure_fsverity fails on a fd without fsverity
 static void test_no_verity(void)
 {
@@ -255,4 +334,5 @@ int main(int argc, char **argv)
 	test_xattr_addremove();
 	test_xattr_doubleadd();
 	test_hardlinked_whiteout_load();
+	test_build_hardlinks();
 }