All of lore.kernel.org
 help / color / mirror / Atom feed
* [pseudo][PATCH RFC] ports/linux: Wrap name_to_handle_at() and open_by_handle_at()
@ 2026-11-12 17:52 Mark Hatle
  2026-11-16 17:59 ` [yocto-patches] " Mark Hatle
  0 siblings, 1 reply; 2+ messages in thread
From: Mark Hatle @ 2026-11-12 17:52 UTC (permalink / raw)
  To: yocto-patches

open_by_handle_at() was not wrapped, so pseudo never learned the path of
the descriptor it returns, and *at() calls relative to it failed.  It
also needs CAP_DAC_READ_SEARCH, so under pseudo it failed with EPERM
anyway.

Always emulate it: check the arguments as the kernel does, then search
below mount_fd with nftw() for a file that name_to_handle_at(), which
needs no privilege, encodes to the same handle, and open it.  A symlink
is only opened with O_PATH, and a handle that isn't found gives ESTALE,
as with the kernel.  The descriptor's path is then recorded.

name_to_handle_at() is wrapped to resolve its path like other wrappers,
so it works in a chroot.  It only follows a final symlink with
AT_SYMLINK_FOLLOW.  Both are also handled when called through syscall().

[YOCTO #16380]

Reported-by: Richard Purdie <richard.purdie@linuxfoundation.org>
AI-Generated: Uses GitHub Copilot
Signed-off-by: Mark Hatle <mark.hatle@amd.com>
---
This is sent as an RFC for review.  I don't understand this workflow
enough to know what the LLM helped me implement is actualy correct or
not.  I do know it matches the behavior and man pages as I understand
them, but I don't know of any real-world test cases I can use to verify
the behavior.

Any comments would be appreciated!

 ports/linux/guts/name_to_handle_at.c |  32 +++++
 ports/linux/guts/open_by_handle_at.c |  59 +++++++++
 ports/linux/pseudo_wrappers.c        | 145 ++++++++++++++++++++++
 ports/linux/wrapfuncs.in             |   2 +
 test/test-name_to_handle_at.c        | 107 ++++++++++++++++
 test/test-name_to_handle_at.sh       |  21 ++++
 test/test-open_by_handle_at.c        | 174 +++++++++++++++++++++++++++
 test/test-open_by_handle_at.sh       |  22 ++++
 8 files changed, 562 insertions(+)
 create mode 100644 ports/linux/guts/name_to_handle_at.c
 create mode 100644 ports/linux/guts/open_by_handle_at.c
 create mode 100644 test/test-name_to_handle_at.c
 create mode 100755 test/test-name_to_handle_at.sh
 create mode 100644 test/test-open_by_handle_at.c
 create mode 100755 test/test-open_by_handle_at.sh

diff --git a/ports/linux/guts/name_to_handle_at.c b/ports/linux/guts/name_to_handle_at.c
new file mode 100644
index 0000000..1d600ff
--- /dev/null
+++ b/ports/linux/guts/name_to_handle_at.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026 Yocto Project
+ * guts/COPYRIGHT for information.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-only
+ *
+ * int name_to_handle_at(int dirfd, const char *name, struct file_handle *handle, int *mount_id, int flags)
+ *	int rc = -1;
+ */
+
+	const char *path;
+
+	/* Encoding a handle needs no privilege, so the real call does it;
+	 * pseudo only has to resolve the path (chroot, dirfd).  Real handles
+	 * also let open_by_handle_at() find the file by encoding candidates
+	 * and comparing.
+	 *
+	 * name isn't canonicalized by the wrapper, as name_to_handle_at()
+	 * only follows a final symlink with AT_SYMLINK_FOLLOW, and rejects
+	 * the AT_SYMLINK_NOFOLLOW the generated code adds for an empty path.
+	 */
+	if (name && !*name && (flags & AT_EMPTY_PATH)) {
+		rc = real_name_to_handle_at(dirfd, name, handle, mount_id, flags);
+	} else {
+		path = pseudo_root_path(__func__, __LINE__, dirfd, name,
+			(flags & AT_SYMLINK_FOLLOW) ? 0 : AT_SYMLINK_NOFOLLOW);
+		rc = real_name_to_handle_at(AT_FDCWD, path, handle, mount_id, flags);
+	}
+
+/*	return rc;
+ * }
+ */
diff --git a/ports/linux/guts/open_by_handle_at.c b/ports/linux/guts/open_by_handle_at.c
new file mode 100644
index 0000000..08b77fa
--- /dev/null
+++ b/ports/linux/guts/open_by_handle_at.c
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026 Yocto Project
+ * guts/COPYRIGHT for information.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-only
+ *
+ * int open_by_handle_at(int mount_fd, struct file_handle *handle, int flags)
+ *	int rc = -1;
+ */
+
+	PSEUDO_STATBUF buf;
+	char procpath[32];
+	char *path;
+	ssize_t len;
+	int save_errno;
+
+	/* always emulated, as decoding a handle needs privilege */
+	rc = pseudo_open_by_handle(mount_fd, handle, flags);
+	if (rc == -1)
+		return rc;
+	save_errno = errno;
+
+	/* A handle names an inode, not a path.  Record the path the kernel
+	 * reports for the descriptor, if it still names the same file, so
+	 * that calls using the descriptor, including *at() calls relative
+	 * to it, can be resolved.
+	 */
+	snprintf(procpath, sizeof(procpath), "/proc/self/fd/%d", rc);
+	path = malloc(pseudo_path_max());
+	if (path) {
+		len = real_readlink(procpath, path, pseudo_path_max() - 1);
+		if (len > 0 && path[0] == '/') {
+			path[len] = '\0';
+			if (!pseudo_client_path_matches_fd(path, rc, 1)) {
+				free(path);
+				path = NULL;
+			}
+		} else {
+			free(path);
+			path = NULL;
+		}
+	}
+
+	if (path) {
+		if (base_fstat(rc, &buf) != -1)
+			pseudo_client_op(OP_OPEN, 0, rc, -1, path, &buf);
+		else
+			pseudo_client_op(OP_OPEN, 0, rc, -1, path, 0);
+		free(path);
+	} else {
+		pseudo_debug(PDBGF_FILE, "open_by_handle_at: no path for fd %d\n", rc);
+		/* drop any path left over from a close pseudo didn't see */
+		pseudo_client_op(OP_CLOSE, 0, rc, -1, 0, 0);
+	}
+	errno = save_errno;
+
+/*	return rc;
+ * }
+ */
diff --git a/ports/linux/pseudo_wrappers.c b/ports/linux/pseudo_wrappers.c
index e8a2780..a573abb 100644
--- a/ports/linux/pseudo_wrappers.c
+++ b/ports/linux/pseudo_wrappers.c
@@ -54,6 +54,121 @@ int pseudo_capset(cap_user_header_t hdrp, const cap_user_data_t datap) {
 	return 0;
 }
 
+/* open_by_handle_at() emulation.
+ *
+ * The kernel only decodes a file handle for a caller with
+ * CAP_DAC_READ_SEARCH, which a pseudo "root" doesn't have, so search
+ * below mount_fd for the file instead.  name_to_handle_at() needs no
+ * privilege, so a file matches if it encodes to the same handle.
+ */
+/* include/linux/exportfs.h */
+#define PSEUDO_FILEID_USER_FLAGS 0xffff0000U
+#define PSEUDO_FILEID_IS_CONNECTABLE 0x10000
+#define PSEUDO_FILEID_IS_DIR 0x20000
+#define PSEUDO_FILEID_VALID_USER_FLAGS (PSEUDO_FILEID_IS_CONNECTABLE | PSEUDO_FILEID_IS_DIR)
+#ifndef AT_HANDLE_CONNECTABLE
+#define AT_HANDLE_CONNECTABLE 0x002
+#endif
+
+/* nftw() has no context argument */
+static struct {
+	const struct file_handle *handle;
+	int encode_flags;
+	char *path;
+	PSEUDO_STATBUF st;
+} pseudo_handle_search;
+
+static int
+pseudo_handle_search_visit(const char *path, const struct stat64 *sb, int typeflag, struct FTW *ftw) {
+	union {
+		struct file_handle fh;
+		char space[sizeof(struct file_handle) + MAX_HANDLE_SZ];
+	} h;
+	int mount_id;
+
+	(void) ftw;
+	if (typeflag == FTW_NS)
+		return 0;
+	h.fh.handle_bytes = MAX_HANDLE_SZ;
+	if (real_name_to_handle_at(AT_FDCWD, path, &h.fh, &mount_id, pseudo_handle_search.encode_flags) == -1 ||
+	    h.fh.handle_type != pseudo_handle_search.handle->handle_type ||
+	    h.fh.handle_bytes != pseudo_handle_search.handle->handle_bytes ||
+	    memcmp(h.fh.f_handle, pseudo_handle_search.handle->f_handle, h.fh.handle_bytes))
+		return 0;
+	pseudo_handle_search.path = strdup(path);
+	pseudo_handle_search.st = *sb;
+	return 1;
+}
+
+/* Check the arguments as the kernel does (fs/fhandle.c), then find and
+ * open the file.
+ */
+static int
+pseudo_open_by_handle(int mount_fd, const struct file_handle *handle, int flags) {
+	char *root = NULL;
+	char procpath[32];
+	PSEUDO_STATBUF st;
+	ssize_t len;
+	int fd = -1;
+
+	if (!handle) {
+		errno = EFAULT;
+		return -1;
+	}
+	if (handle->handle_bytes == 0 || handle->handle_bytes > MAX_HANDLE_SZ ||
+	    handle->handle_type < 0 ||
+	    ((unsigned int) handle->handle_type & PSEUDO_FILEID_USER_FLAGS & ~PSEUDO_FILEID_VALID_USER_FLAGS)) {
+		errno = EINVAL;
+		return -1;
+	}
+	if (mount_fd < 0 && mount_fd != AT_FDCWD) {
+		errno = EBADF;
+		return -1;
+	}
+	if (base_fstatat(mount_fd, "", &st, AT_EMPTY_PATH) == -1)
+		return -1;
+
+	root = malloc(pseudo_path_max());
+	if (!root)
+		return -1;
+	if (mount_fd == AT_FDCWD) {
+		if (!real_getcwd(root, pseudo_path_max()))
+			goto out;
+	} else {
+		snprintf(procpath, sizeof(procpath), "/proc/self/fd/%d", mount_fd);
+		len = real_readlink(procpath, root, pseudo_path_max() - 1);
+		if (len <= 0 || root[0] != '/') {
+			errno = ESTALE;
+			goto out;
+		}
+		root[len] = '\0';
+	}
+
+	memset(&pseudo_handle_search, 0, sizeof(pseudo_handle_search));
+	pseudo_handle_search.handle = handle;
+	pseudo_handle_search.encode_flags = (handle->handle_type & PSEUDO_FILEID_IS_CONNECTABLE) ? AT_HANDLE_CONNECTABLE : 0;
+	real_nftw64(root, pseudo_handle_search_visit, 16, FTW_PHYS | FTW_MOUNT);
+	if (!pseudo_handle_search.path) {
+		errno = ESTALE;
+		goto out;
+	}
+
+	/* as the kernel, a symlink is only opened with O_PATH */
+	fd = real_openat(AT_FDCWD, pseudo_handle_search.path, (flags & ~(O_CREAT | O_EXCL)) | O_NOFOLLOW);
+	/* the path could have been replaced since it was checked */
+	if (fd != -1 && (base_fstat(fd, &st) == -1 ||
+	    st.st_dev != pseudo_handle_search.st.st_dev || st.st_ino != pseudo_handle_search.st.st_ino)) {
+		real_close(fd);
+		fd = -1;
+		errno = ESTALE;
+	}
+	free(pseudo_handle_search.path);
+	pseudo_handle_search.path = NULL;
+out:
+	free(root);
+	return fd;
+}
+
 long
 syscall(long number, ...) {
 	long rc = -1;
@@ -175,6 +290,36 @@ syscall(long number, ...) {
 #error SYS_open_tree_attr not defined
 #endif
 
+#ifdef SYS_name_to_handle_at
+	if (number == SYS_name_to_handle_at) {
+		pseudo_debug(PDBGF_SYSCALL, "syscall, faking name_to_handle_at.\n");
+		va_start(ap, number);
+		int dirfd = va_arg(ap, int);
+		const char *name = va_arg(ap, const char *);
+		struct file_handle *handle = va_arg(ap, struct file_handle *);
+		int *mount_id = va_arg(ap, int *);
+		int flags = va_arg(ap, int);
+
+		return wrap_name_to_handle_at(dirfd, name, handle, mount_id, flags);
+	}
+#else
+#error SYS_name_to_handle_at not defined
+#endif
+
+#ifdef SYS_open_by_handle_at
+	if (number == SYS_open_by_handle_at) {
+		pseudo_debug(PDBGF_SYSCALL, "syscall, faking open_by_handle_at.\n");
+		va_start(ap, number);
+		int mount_fd = va_arg(ap, int);
+		struct file_handle *handle = va_arg(ap, struct file_handle *);
+		int flags = va_arg(ap, int);
+
+		return wrap_open_by_handle_at(mount_fd, handle, flags);
+	}
+#else
+#error SYS_open_by_handle_at not defined
+#endif
+
 #ifdef SYS_renameat2
         /* Call out wrapper, expanding the variable arguments first */
 	if (number == SYS_renameat2) {
diff --git a/ports/linux/wrapfuncs.in b/ports/linux/wrapfuncs.in
index a682383..1874b60 100644
--- a/ports/linux/wrapfuncs.in
+++ b/ports/linux/wrapfuncs.in
@@ -12,6 +12,8 @@ int openat(int dirfd, const char *path, int flags, ...{mode_t mode}); /* flags=(
 int __openat_2(int dirfd, const char *path, int flags); /* flags=((flags&O_NOFOLLOW)||((flags&(O_CREAT|O_EXCL))==(O_CREAT|O_EXCL))), noignore_path=1 */
 int open_tree(int dirfd, const char *path, unsigned int flags); /* preserve_paths=1, noignore_path=1 */
 int open_tree_attr(int dirfd, const char *path, unsigned int flags, struct mount_attr *attr, size_t size); /* preserve_paths=1, noignore_path=1*/
+int name_to_handle_at(int dirfd, const char *name, struct file_handle *handle, int *mount_id, int flags);
+int open_by_handle_at(int mount_fd, struct file_handle *handle, int flags);
 int mknod(const char *path, mode_t mode, dev_t dev); /* real_func=pseudo_mknod, path_lock=1 */
 int mknodat(int dirfd, const char *path, mode_t mode, dev_t dev); /* real_func=pseudo_mknodat, path_lock=1 */
 int __xmknod(int ver, const char *path, mode_t mode, dev_t *dev); /* flags=AT_SYMLINK_NOFOLLOW, path_lock=1 */
diff --git a/test/test-name_to_handle_at.c b/test/test-name_to_handle_at.c
new file mode 100644
index 0000000..0f9e2e7
--- /dev/null
+++ b/test/test-name_to_handle_at.c
@@ -0,0 +1,107 @@
+/*
+ * Test that name_to_handle_at() resolves paths the way pseudo does,
+ * including inside a chroot, and only follows a final symlink with
+ * AT_SYMLINK_FOLLOW.
+ * SPDX-License-Identifier: LGPL-2.1-only
+ *
+ * Returns 77 if the filesystem doesn't support file handles.
+ */
+#define _GNU_SOURCE
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+static struct file_handle *
+get_handle(int dirfd, const char *name, int flags, int use_syscall) {
+	struct file_handle *fh = malloc(sizeof(*fh) + MAX_HANDLE_SZ);
+	int mount_id, rc;
+
+	if (!fh)
+		return NULL;
+	fh->handle_bytes = MAX_HANDLE_SZ;
+	if (use_syscall)
+		rc = syscall(SYS_name_to_handle_at, dirfd, name, fh, &mount_id, flags);
+	else
+		rc = name_to_handle_at(dirfd, name, fh, &mount_id, flags);
+	if (rc == -1) {
+		if (errno == EOPNOTSUPP || errno == ENOSYS) {
+			printf("name_to_handle_at not supported: %s\n", strerror(errno));
+			exit(77);
+		}
+		printf("name_to_handle_at(%d, '%s', %#x): %s\n", dirfd, name, flags, strerror(errno));
+		free(fh);
+		return NULL;
+	}
+	return fh;
+}
+
+static int
+same(const struct file_handle *a, const struct file_handle *b) {
+	return a && b && a->handle_bytes == b->handle_bytes &&
+		a->handle_type == b->handle_type &&
+		!memcmp(a->f_handle, b->f_handle, a->handle_bytes);
+}
+
+int
+main(int argc, char *argv[]) {
+	struct file_handle *file, *link, *h;
+	char path[4096];
+	int fd, rc = 0;
+
+	if (argc != 2) {
+		fprintf(stderr, "usage: %s <chrootdir>\n", argv[0]);
+		return 2;
+	}
+
+	snprintf(path, sizeof(path), "%s/file", argv[1]);
+	file = get_handle(AT_FDCWD, path, 0, 0);
+	snprintf(path, sizeof(path), "%s/link", argv[1]);
+	link = get_handle(AT_FDCWD, path, 0, 0);
+	if (!file || !link)
+		return 1;
+	if (same(file, link)) {
+		printf("handle for a symlink matches its target\n");
+		return 1;
+	}
+
+	if (chroot(argv[1]) == -1 || chdir("/") == -1) {
+		perror("chroot");
+		return 1;
+	}
+
+	if (!same(get_handle(AT_FDCWD, "/file", 0, 0), file)) {
+		printf("/file inside the chroot has the wrong handle\n");
+		rc = 1;
+	}
+	if (!same(get_handle(AT_FDCWD, "/link", 0, 0), link)) {
+		printf("/link without AT_SYMLINK_FOLLOW has the wrong handle\n");
+		rc = 1;
+	}
+	if (!same(get_handle(AT_FDCWD, "/link", AT_SYMLINK_FOLLOW, 0), file)) {
+		printf("/link with AT_SYMLINK_FOLLOW has the wrong handle\n");
+		rc = 1;
+	}
+	if (!same(get_handle(AT_FDCWD, "/file", 0, 1), file)) {
+		printf("/file through syscall() has the wrong handle\n");
+		rc = 1;
+	}
+
+	fd = open("/file", O_RDONLY);
+	if (fd == -1) {
+		perror("open /file");
+		return 1;
+	}
+	h = get_handle(fd, "", AT_EMPTY_PATH, 0);
+	if (!same(h, file)) {
+		printf("AT_EMPTY_PATH has the wrong handle\n");
+		rc = 1;
+	}
+	close(fd);
+
+	return rc;
+}
diff --git a/test/test-name_to_handle_at.sh b/test/test-name_to_handle_at.sh
new file mode 100755
index 0000000..351b0cb
--- /dev/null
+++ b/test/test-name_to_handle_at.sh
@@ -0,0 +1,21 @@
+#!/bin/sh
+#
+# Test name_to_handle_at() path resolution, including inside a chroot.
+# SPDX-License-Identifier: LGPL-2.1-only
+#
+# rc 77 indicates the filesystem doesn't support file handles, so report
+# skipped (255).
+
+dir=$(pwd)/name_to_handle_at_test
+trap 'rm -rf "$dir"' 0
+rm -rf "$dir"
+mkdir -p "$dir"
+touch "$dir/file"
+ln -s file "$dir/link"
+
+./test/test-name_to_handle_at "$dir"
+rc=$?
+if [ "$rc" -eq 77 ]; then
+	exit 255
+fi
+exit $rc
diff --git a/test/test-open_by_handle_at.c b/test/test-open_by_handle_at.c
new file mode 100644
index 0000000..a05b9d7
--- /dev/null
+++ b/test/test-open_by_handle_at.c
@@ -0,0 +1,174 @@
+/*
+ * Test open_by_handle_at() under pseudo.  The kernel needs privilege to
+ * decode a file handle, so pseudo finds and opens the file itself.
+ * SPDX-License-Identifier: LGPL-2.1-only
+ *
+ * Returns 77 if the filesystem doesn't support file handles.
+ */
+#define _GNU_SOURCE
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+static int failed;
+
+#define FAIL(...) do { printf(__VA_ARGS__); failed = 1; } while (0)
+
+static struct file_handle *
+handle_for(const char *path, int flags) {
+	struct file_handle *fh = malloc(sizeof(*fh) + MAX_HANDLE_SZ);
+	int mount_id;
+
+	if (!fh)
+		exit(1);
+	fh->handle_bytes = MAX_HANDLE_SZ;
+	if (name_to_handle_at(AT_FDCWD, path, fh, &mount_id, flags) == -1) {
+		if (errno == EOPNOTSUPP || errno == ENOSYS) {
+			printf("name_to_handle_at not supported: %s\n", strerror(errno));
+			exit(77);
+		}
+		printf("name_to_handle_at(%s): %s\n", path, strerror(errno));
+		exit(1);
+	}
+	return fh;
+}
+
+/* Make the handle in another process, so this one can't have
+ * remembered where it came from.
+ */
+static struct file_handle *
+handle_from_child(const char *path) {
+	struct file_handle *fh = malloc(sizeof(*fh) + MAX_HANDLE_SZ);
+	int pipefd[2], status;
+	pid_t pid;
+
+	if (!fh || pipe(pipefd) == -1)
+		exit(1);
+	pid = fork();
+	if (pid == -1)
+		exit(1);
+	if (pid == 0) {
+		struct file_handle *child = handle_for(path, 0);
+		ssize_t len = sizeof(*child) + child->handle_bytes;
+		_exit(write(pipefd[1], child, len) == len ? 0 : 1);
+	}
+	close(pipefd[1]);
+	if (read(pipefd[0], fh, sizeof(*fh) + MAX_HANDLE_SZ) < (ssize_t) sizeof(*fh))
+		exit(1);
+	close(pipefd[0]);
+	if (waitpid(pid, &status, 0) == -1 || !WIFEXITED(status) || WEXITSTATUS(status))
+		exit(WIFEXITED(status) ? WEXITSTATUS(status) : 1);
+	return fh;
+}
+
+static void
+check_dirfd(const char *how, int dirfd) {
+	struct stat st;
+
+	if (dirfd == -1) {
+		FAIL("%s: open_by_handle_at: %s\n", how, strerror(errno));
+		return;
+	}
+	if (fstatat(dirfd, "file", &st, 0) == -1)
+		FAIL("%s: fstatat: %s\n", how, strerror(errno));
+	else if (st.st_uid != 123 || st.st_gid != 456)
+		FAIL("%s: file owned by %d:%d, expected 123:456\n",
+			how, (int) st.st_uid, (int) st.st_gid);
+	close(dirfd);
+}
+
+int
+main(int argc, char *argv[]) {
+	struct file_handle *fh;
+	char path[4096], buf[16];
+	struct stat st;
+	int mount_fd, fd;
+	ssize_t len;
+
+	if (argc != 2) {
+		fprintf(stderr, "usage: %s <dir>\n", argv[0]);
+		return 2;
+	}
+	mount_fd = open(argv[1], O_RDONLY | O_DIRECTORY);
+	if (mount_fd == -1) {
+		perror("open");
+		return 1;
+	}
+
+	/* a directory handle, used for *at() calls */
+	snprintf(path, sizeof(path), "%s/dir/file", argv[1]);
+	if (chown(path, 123, 456) == -1) {
+		perror("chown");
+		return 1;
+	}
+	snprintf(path, sizeof(path), "%s/dir", argv[1]);
+	fh = handle_for(path, 0);
+	check_dirfd("function", open_by_handle_at(mount_fd, fh, O_RDONLY | O_DIRECTORY));
+	check_dirfd("syscall", syscall(SYS_open_by_handle_at, mount_fd, fh, O_RDONLY | O_DIRECTORY));
+	free(fh);
+
+	/* a file below mount_fd that this process never named */
+	snprintf(path, sizeof(path), "%s/dir/sub/data", argv[1]);
+	fh = handle_from_child(path);
+	fd = open_by_handle_at(mount_fd, fh, O_RDONLY);
+	if (fd == -1) {
+		FAIL("data: open_by_handle_at: %s\n", strerror(errno));
+	} else {
+		len = read(fd, buf, sizeof(buf) - 1);
+		buf[len > 0 ? len : 0] = '\0';
+		if (strcmp(buf, "hello\n"))
+			FAIL("data: read '%s'\n", buf);
+		close(fd);
+	}
+	free(fh);
+
+	/* mount_fd itself */
+	fh = handle_from_child(argv[1]);
+	fd = open_by_handle_at(mount_fd, fh, O_RDONLY | O_DIRECTORY);
+	if (fd == -1)
+		FAIL("mount_fd: open_by_handle_at: %s\n", strerror(errno));
+	else
+		close(fd);
+	free(fh);
+
+	/* a symlink only opens with O_PATH, as the link itself */
+	snprintf(path, sizeof(path), "%s/dir/link", argv[1]);
+	fh = handle_from_child(path);
+	fd = open_by_handle_at(mount_fd, fh, O_RDONLY);
+	if (fd != -1 || errno != ELOOP)
+		FAIL("link: expected ELOOP, got %d (%s)\n", fd, strerror(errno));
+	fd = open_by_handle_at(mount_fd, fh, O_PATH);
+	if (fd == -1)
+		FAIL("link: O_PATH: %s\n", strerror(errno));
+	else if (fstat(fd, &st) == -1 || !S_ISLNK(st.st_mode))
+		FAIL("link: O_PATH didn't open the symlink\n");
+	if (fd != -1)
+		close(fd);
+	free(fh);
+
+	/* a deleted file */
+	snprintf(path, sizeof(path), "%s/gone", argv[1]);
+	fh = handle_from_child(path);
+	unlink(path);
+	fd = open_by_handle_at(mount_fd, fh, O_RDONLY);
+	if (fd != -1 || errno != ESTALE)
+		FAIL("gone: expected ESTALE, got %d (%s)\n", fd, strerror(errno));
+	if (fd != -1)
+		close(fd);
+
+	/* the kernel's own argument checks still apply */
+	fh->handle_bytes = 0;
+	fd = open_by_handle_at(mount_fd, fh, O_RDONLY);
+	if (fd != -1 || errno != EINVAL)
+		FAIL("empty handle: expected EINVAL, got %d (%s)\n", fd, strerror(errno));
+	free(fh);
+
+	return failed;
+}
diff --git a/test/test-open_by_handle_at.sh b/test/test-open_by_handle_at.sh
new file mode 100755
index 0000000..ef4a9f7
--- /dev/null
+++ b/test/test-open_by_handle_at.sh
@@ -0,0 +1,22 @@
+#!/bin/sh
+#
+# Test open_by_handle_at() under pseudo.
+# SPDX-License-Identifier: LGPL-2.1-only
+#
+# rc 77 indicates the filesystem doesn't support file handles, so report
+# skipped (255).
+
+dir=$(pwd)/open_by_handle_at_test
+trap 'rm -rf "$dir"' 0
+rm -rf "$dir"
+mkdir -p "$dir/dir/sub"
+touch "$dir/dir/file" "$dir/gone"
+echo hello > "$dir/dir/sub/data"
+ln -s file "$dir/dir/link"
+
+./test/test-open_by_handle_at "$dir"
+rc=$?
+if [ "$rc" -eq 77 ]; then
+	exit 255
+fi
+exit $rc
-- 
2.34.1


^ permalink raw reply related	[flat|nested] 2+ messages in thread

* Re: [yocto-patches] [pseudo][PATCH RFC] ports/linux: Wrap name_to_handle_at() and open_by_handle_at()
  2026-11-12 17:52 [pseudo][PATCH RFC] ports/linux: Wrap name_to_handle_at() and open_by_handle_at() Mark Hatle
@ 2026-11-16 17:59 ` Mark Hatle
  0 siblings, 0 replies; 2+ messages in thread
From: Mark Hatle @ 2026-11-16 17:59 UTC (permalink / raw)
  To: yocto-patches

I have decided to push this work to master.  It's going to require re-world 
testing to know if this causes issues or not, we'll resolve any issues through 
the normal bug/pull request process.

--Mark

On 11/12/26 11:52 AM, Mark Hatle via yocto-patches wrote:
> open_by_handle_at() was not wrapped, so pseudo never learned the path of
> the descriptor it returns, and *at() calls relative to it failed.  It
> also needs CAP_DAC_READ_SEARCH, so under pseudo it failed with EPERM
> anyway.
> 
> Always emulate it: check the arguments as the kernel does, then search
> below mount_fd with nftw() for a file that name_to_handle_at(), which
> needs no privilege, encodes to the same handle, and open it.  A symlink
> is only opened with O_PATH, and a handle that isn't found gives ESTALE,
> as with the kernel.  The descriptor's path is then recorded.
> 
> name_to_handle_at() is wrapped to resolve its path like other wrappers,
> so it works in a chroot.  It only follows a final symlink with
> AT_SYMLINK_FOLLOW.  Both are also handled when called through syscall().
> 
> [YOCTO #16380]
> 
> Reported-by: Richard Purdie <richard.purdie@linuxfoundation.org>
> AI-Generated: Uses GitHub Copilot
> Signed-off-by: Mark Hatle <mark.hatle@amd.com>
> ---
> This is sent as an RFC for review.  I don't understand this workflow
> enough to know what the LLM helped me implement is actualy correct or
> not.  I do know it matches the behavior and man pages as I understand
> them, but I don't know of any real-world test cases I can use to verify
> the behavior.
> 
> Any comments would be appreciated!
> 
>   ports/linux/guts/name_to_handle_at.c |  32 +++++
>   ports/linux/guts/open_by_handle_at.c |  59 +++++++++
>   ports/linux/pseudo_wrappers.c        | 145 ++++++++++++++++++++++
>   ports/linux/wrapfuncs.in             |   2 +
>   test/test-name_to_handle_at.c        | 107 ++++++++++++++++
>   test/test-name_to_handle_at.sh       |  21 ++++
>   test/test-open_by_handle_at.c        | 174 +++++++++++++++++++++++++++
>   test/test-open_by_handle_at.sh       |  22 ++++
>   8 files changed, 562 insertions(+)
>   create mode 100644 ports/linux/guts/name_to_handle_at.c
>   create mode 100644 ports/linux/guts/open_by_handle_at.c
>   create mode 100644 test/test-name_to_handle_at.c
>   create mode 100755 test/test-name_to_handle_at.sh
>   create mode 100644 test/test-open_by_handle_at.c
>   create mode 100755 test/test-open_by_handle_at.sh
> 
> diff --git a/ports/linux/guts/name_to_handle_at.c b/ports/linux/guts/name_to_handle_at.c
> new file mode 100644
> index 0000000..1d600ff
> --- /dev/null
> +++ b/ports/linux/guts/name_to_handle_at.c
> @@ -0,0 +1,32 @@
> +/*
> + * Copyright (c) 2026 Yocto Project
> + * guts/COPYRIGHT for information.
> + *
> + * SPDX-License-Identifier: LGPL-2.1-only
> + *
> + * int name_to_handle_at(int dirfd, const char *name, struct file_handle *handle, int *mount_id, int flags)
> + *	int rc = -1;
> + */
> +
> +	const char *path;
> +
> +	/* Encoding a handle needs no privilege, so the real call does it;
> +	 * pseudo only has to resolve the path (chroot, dirfd).  Real handles
> +	 * also let open_by_handle_at() find the file by encoding candidates
> +	 * and comparing.
> +	 *
> +	 * name isn't canonicalized by the wrapper, as name_to_handle_at()
> +	 * only follows a final symlink with AT_SYMLINK_FOLLOW, and rejects
> +	 * the AT_SYMLINK_NOFOLLOW the generated code adds for an empty path.
> +	 */
> +	if (name && !*name && (flags & AT_EMPTY_PATH)) {
> +		rc = real_name_to_handle_at(dirfd, name, handle, mount_id, flags);
> +	} else {
> +		path = pseudo_root_path(__func__, __LINE__, dirfd, name,
> +			(flags & AT_SYMLINK_FOLLOW) ? 0 : AT_SYMLINK_NOFOLLOW);
> +		rc = real_name_to_handle_at(AT_FDCWD, path, handle, mount_id, flags);
> +	}
> +
> +/*	return rc;
> + * }
> + */
> diff --git a/ports/linux/guts/open_by_handle_at.c b/ports/linux/guts/open_by_handle_at.c
> new file mode 100644
> index 0000000..08b77fa
> --- /dev/null
> +++ b/ports/linux/guts/open_by_handle_at.c
> @@ -0,0 +1,59 @@
> +/*
> + * Copyright (c) 2026 Yocto Project
> + * guts/COPYRIGHT for information.
> + *
> + * SPDX-License-Identifier: LGPL-2.1-only
> + *
> + * int open_by_handle_at(int mount_fd, struct file_handle *handle, int flags)
> + *	int rc = -1;
> + */
> +
> +	PSEUDO_STATBUF buf;
> +	char procpath[32];
> +	char *path;
> +	ssize_t len;
> +	int save_errno;
> +
> +	/* always emulated, as decoding a handle needs privilege */
> +	rc = pseudo_open_by_handle(mount_fd, handle, flags);
> +	if (rc == -1)
> +		return rc;
> +	save_errno = errno;
> +
> +	/* A handle names an inode, not a path.  Record the path the kernel
> +	 * reports for the descriptor, if it still names the same file, so
> +	 * that calls using the descriptor, including *at() calls relative
> +	 * to it, can be resolved.
> +	 */
> +	snprintf(procpath, sizeof(procpath), "/proc/self/fd/%d", rc);
> +	path = malloc(pseudo_path_max());
> +	if (path) {
> +		len = real_readlink(procpath, path, pseudo_path_max() - 1);
> +		if (len > 0 && path[0] == '/') {
> +			path[len] = '\0';
> +			if (!pseudo_client_path_matches_fd(path, rc, 1)) {
> +				free(path);
> +				path = NULL;
> +			}
> +		} else {
> +			free(path);
> +			path = NULL;
> +		}
> +	}
> +
> +	if (path) {
> +		if (base_fstat(rc, &buf) != -1)
> +			pseudo_client_op(OP_OPEN, 0, rc, -1, path, &buf);
> +		else
> +			pseudo_client_op(OP_OPEN, 0, rc, -1, path, 0);
> +		free(path);
> +	} else {
> +		pseudo_debug(PDBGF_FILE, "open_by_handle_at: no path for fd %d\n", rc);
> +		/* drop any path left over from a close pseudo didn't see */
> +		pseudo_client_op(OP_CLOSE, 0, rc, -1, 0, 0);
> +	}
> +	errno = save_errno;
> +
> +/*	return rc;
> + * }
> + */
> diff --git a/ports/linux/pseudo_wrappers.c b/ports/linux/pseudo_wrappers.c
> index e8a2780..a573abb 100644
> --- a/ports/linux/pseudo_wrappers.c
> +++ b/ports/linux/pseudo_wrappers.c
> @@ -54,6 +54,121 @@ int pseudo_capset(cap_user_header_t hdrp, const cap_user_data_t datap) {
>   	return 0;
>   }
>   
> +/* open_by_handle_at() emulation.
> + *
> + * The kernel only decodes a file handle for a caller with
> + * CAP_DAC_READ_SEARCH, which a pseudo "root" doesn't have, so search
> + * below mount_fd for the file instead.  name_to_handle_at() needs no
> + * privilege, so a file matches if it encodes to the same handle.
> + */
> +/* include/linux/exportfs.h */
> +#define PSEUDO_FILEID_USER_FLAGS 0xffff0000U
> +#define PSEUDO_FILEID_IS_CONNECTABLE 0x10000
> +#define PSEUDO_FILEID_IS_DIR 0x20000
> +#define PSEUDO_FILEID_VALID_USER_FLAGS (PSEUDO_FILEID_IS_CONNECTABLE | PSEUDO_FILEID_IS_DIR)
> +#ifndef AT_HANDLE_CONNECTABLE
> +#define AT_HANDLE_CONNECTABLE 0x002
> +#endif
> +
> +/* nftw() has no context argument */
> +static struct {
> +	const struct file_handle *handle;
> +	int encode_flags;
> +	char *path;
> +	PSEUDO_STATBUF st;
> +} pseudo_handle_search;
> +
> +static int
> +pseudo_handle_search_visit(const char *path, const struct stat64 *sb, int typeflag, struct FTW *ftw) {
> +	union {
> +		struct file_handle fh;
> +		char space[sizeof(struct file_handle) + MAX_HANDLE_SZ];
> +	} h;
> +	int mount_id;
> +
> +	(void) ftw;
> +	if (typeflag == FTW_NS)
> +		return 0;
> +	h.fh.handle_bytes = MAX_HANDLE_SZ;
> +	if (real_name_to_handle_at(AT_FDCWD, path, &h.fh, &mount_id, pseudo_handle_search.encode_flags) == -1 ||
> +	    h.fh.handle_type != pseudo_handle_search.handle->handle_type ||
> +	    h.fh.handle_bytes != pseudo_handle_search.handle->handle_bytes ||
> +	    memcmp(h.fh.f_handle, pseudo_handle_search.handle->f_handle, h.fh.handle_bytes))
> +		return 0;
> +	pseudo_handle_search.path = strdup(path);
> +	pseudo_handle_search.st = *sb;
> +	return 1;
> +}
> +
> +/* Check the arguments as the kernel does (fs/fhandle.c), then find and
> + * open the file.
> + */
> +static int
> +pseudo_open_by_handle(int mount_fd, const struct file_handle *handle, int flags) {
> +	char *root = NULL;
> +	char procpath[32];
> +	PSEUDO_STATBUF st;
> +	ssize_t len;
> +	int fd = -1;
> +
> +	if (!handle) {
> +		errno = EFAULT;
> +		return -1;
> +	}
> +	if (handle->handle_bytes == 0 || handle->handle_bytes > MAX_HANDLE_SZ ||
> +	    handle->handle_type < 0 ||
> +	    ((unsigned int) handle->handle_type & PSEUDO_FILEID_USER_FLAGS & ~PSEUDO_FILEID_VALID_USER_FLAGS)) {
> +		errno = EINVAL;
> +		return -1;
> +	}
> +	if (mount_fd < 0 && mount_fd != AT_FDCWD) {
> +		errno = EBADF;
> +		return -1;
> +	}
> +	if (base_fstatat(mount_fd, "", &st, AT_EMPTY_PATH) == -1)
> +		return -1;
> +
> +	root = malloc(pseudo_path_max());
> +	if (!root)
> +		return -1;
> +	if (mount_fd == AT_FDCWD) {
> +		if (!real_getcwd(root, pseudo_path_max()))
> +			goto out;
> +	} else {
> +		snprintf(procpath, sizeof(procpath), "/proc/self/fd/%d", mount_fd);
> +		len = real_readlink(procpath, root, pseudo_path_max() - 1);
> +		if (len <= 0 || root[0] != '/') {
> +			errno = ESTALE;
> +			goto out;
> +		}
> +		root[len] = '\0';
> +	}
> +
> +	memset(&pseudo_handle_search, 0, sizeof(pseudo_handle_search));
> +	pseudo_handle_search.handle = handle;
> +	pseudo_handle_search.encode_flags = (handle->handle_type & PSEUDO_FILEID_IS_CONNECTABLE) ? AT_HANDLE_CONNECTABLE : 0;
> +	real_nftw64(root, pseudo_handle_search_visit, 16, FTW_PHYS | FTW_MOUNT);
> +	if (!pseudo_handle_search.path) {
> +		errno = ESTALE;
> +		goto out;
> +	}
> +
> +	/* as the kernel, a symlink is only opened with O_PATH */
> +	fd = real_openat(AT_FDCWD, pseudo_handle_search.path, (flags & ~(O_CREAT | O_EXCL)) | O_NOFOLLOW);
> +	/* the path could have been replaced since it was checked */
> +	if (fd != -1 && (base_fstat(fd, &st) == -1 ||
> +	    st.st_dev != pseudo_handle_search.st.st_dev || st.st_ino != pseudo_handle_search.st.st_ino)) {
> +		real_close(fd);
> +		fd = -1;
> +		errno = ESTALE;
> +	}
> +	free(pseudo_handle_search.path);
> +	pseudo_handle_search.path = NULL;
> +out:
> +	free(root);
> +	return fd;
> +}
> +
>   long
>   syscall(long number, ...) {
>   	long rc = -1;
> @@ -175,6 +290,36 @@ syscall(long number, ...) {
>   #error SYS_open_tree_attr not defined
>   #endif
>   
> +#ifdef SYS_name_to_handle_at
> +	if (number == SYS_name_to_handle_at) {
> +		pseudo_debug(PDBGF_SYSCALL, "syscall, faking name_to_handle_at.\n");
> +		va_start(ap, number);
> +		int dirfd = va_arg(ap, int);
> +		const char *name = va_arg(ap, const char *);
> +		struct file_handle *handle = va_arg(ap, struct file_handle *);
> +		int *mount_id = va_arg(ap, int *);
> +		int flags = va_arg(ap, int);
> +
> +		return wrap_name_to_handle_at(dirfd, name, handle, mount_id, flags);
> +	}
> +#else
> +#error SYS_name_to_handle_at not defined
> +#endif
> +
> +#ifdef SYS_open_by_handle_at
> +	if (number == SYS_open_by_handle_at) {
> +		pseudo_debug(PDBGF_SYSCALL, "syscall, faking open_by_handle_at.\n");
> +		va_start(ap, number);
> +		int mount_fd = va_arg(ap, int);
> +		struct file_handle *handle = va_arg(ap, struct file_handle *);
> +		int flags = va_arg(ap, int);
> +
> +		return wrap_open_by_handle_at(mount_fd, handle, flags);
> +	}
> +#else
> +#error SYS_open_by_handle_at not defined
> +#endif
> +
>   #ifdef SYS_renameat2
>           /* Call out wrapper, expanding the variable arguments first */
>   	if (number == SYS_renameat2) {
> diff --git a/ports/linux/wrapfuncs.in b/ports/linux/wrapfuncs.in
> index a682383..1874b60 100644
> --- a/ports/linux/wrapfuncs.in
> +++ b/ports/linux/wrapfuncs.in
> @@ -12,6 +12,8 @@ int openat(int dirfd, const char *path, int flags, ...{mode_t mode}); /* flags=(
>   int __openat_2(int dirfd, const char *path, int flags); /* flags=((flags&O_NOFOLLOW)||((flags&(O_CREAT|O_EXCL))==(O_CREAT|O_EXCL))), noignore_path=1 */
>   int open_tree(int dirfd, const char *path, unsigned int flags); /* preserve_paths=1, noignore_path=1 */
>   int open_tree_attr(int dirfd, const char *path, unsigned int flags, struct mount_attr *attr, size_t size); /* preserve_paths=1, noignore_path=1*/
> +int name_to_handle_at(int dirfd, const char *name, struct file_handle *handle, int *mount_id, int flags);
> +int open_by_handle_at(int mount_fd, struct file_handle *handle, int flags);
>   int mknod(const char *path, mode_t mode, dev_t dev); /* real_func=pseudo_mknod, path_lock=1 */
>   int mknodat(int dirfd, const char *path, mode_t mode, dev_t dev); /* real_func=pseudo_mknodat, path_lock=1 */
>   int __xmknod(int ver, const char *path, mode_t mode, dev_t *dev); /* flags=AT_SYMLINK_NOFOLLOW, path_lock=1 */
> diff --git a/test/test-name_to_handle_at.c b/test/test-name_to_handle_at.c
> new file mode 100644
> index 0000000..0f9e2e7
> --- /dev/null
> +++ b/test/test-name_to_handle_at.c
> @@ -0,0 +1,107 @@
> +/*
> + * Test that name_to_handle_at() resolves paths the way pseudo does,
> + * including inside a chroot, and only follows a final symlink with
> + * AT_SYMLINK_FOLLOW.
> + * SPDX-License-Identifier: LGPL-2.1-only
> + *
> + * Returns 77 if the filesystem doesn't support file handles.
> + */
> +#define _GNU_SOURCE
> +
> +#include <errno.h>
> +#include <fcntl.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <sys/syscall.h>
> +#include <unistd.h>
> +
> +static struct file_handle *
> +get_handle(int dirfd, const char *name, int flags, int use_syscall) {
> +	struct file_handle *fh = malloc(sizeof(*fh) + MAX_HANDLE_SZ);
> +	int mount_id, rc;
> +
> +	if (!fh)
> +		return NULL;
> +	fh->handle_bytes = MAX_HANDLE_SZ;
> +	if (use_syscall)
> +		rc = syscall(SYS_name_to_handle_at, dirfd, name, fh, &mount_id, flags);
> +	else
> +		rc = name_to_handle_at(dirfd, name, fh, &mount_id, flags);
> +	if (rc == -1) {
> +		if (errno == EOPNOTSUPP || errno == ENOSYS) {
> +			printf("name_to_handle_at not supported: %s\n", strerror(errno));
> +			exit(77);
> +		}
> +		printf("name_to_handle_at(%d, '%s', %#x): %s\n", dirfd, name, flags, strerror(errno));
> +		free(fh);
> +		return NULL;
> +	}
> +	return fh;
> +}
> +
> +static int
> +same(const struct file_handle *a, const struct file_handle *b) {
> +	return a && b && a->handle_bytes == b->handle_bytes &&
> +		a->handle_type == b->handle_type &&
> +		!memcmp(a->f_handle, b->f_handle, a->handle_bytes);
> +}
> +
> +int
> +main(int argc, char *argv[]) {
> +	struct file_handle *file, *link, *h;
> +	char path[4096];
> +	int fd, rc = 0;
> +
> +	if (argc != 2) {
> +		fprintf(stderr, "usage: %s <chrootdir>\n", argv[0]);
> +		return 2;
> +	}
> +
> +	snprintf(path, sizeof(path), "%s/file", argv[1]);
> +	file = get_handle(AT_FDCWD, path, 0, 0);
> +	snprintf(path, sizeof(path), "%s/link", argv[1]);
> +	link = get_handle(AT_FDCWD, path, 0, 0);
> +	if (!file || !link)
> +		return 1;
> +	if (same(file, link)) {
> +		printf("handle for a symlink matches its target\n");
> +		return 1;
> +	}
> +
> +	if (chroot(argv[1]) == -1 || chdir("/") == -1) {
> +		perror("chroot");
> +		return 1;
> +	}
> +
> +	if (!same(get_handle(AT_FDCWD, "/file", 0, 0), file)) {
> +		printf("/file inside the chroot has the wrong handle\n");
> +		rc = 1;
> +	}
> +	if (!same(get_handle(AT_FDCWD, "/link", 0, 0), link)) {
> +		printf("/link without AT_SYMLINK_FOLLOW has the wrong handle\n");
> +		rc = 1;
> +	}
> +	if (!same(get_handle(AT_FDCWD, "/link", AT_SYMLINK_FOLLOW, 0), file)) {
> +		printf("/link with AT_SYMLINK_FOLLOW has the wrong handle\n");
> +		rc = 1;
> +	}
> +	if (!same(get_handle(AT_FDCWD, "/file", 0, 1), file)) {
> +		printf("/file through syscall() has the wrong handle\n");
> +		rc = 1;
> +	}
> +
> +	fd = open("/file", O_RDONLY);
> +	if (fd == -1) {
> +		perror("open /file");
> +		return 1;
> +	}
> +	h = get_handle(fd, "", AT_EMPTY_PATH, 0);
> +	if (!same(h, file)) {
> +		printf("AT_EMPTY_PATH has the wrong handle\n");
> +		rc = 1;
> +	}
> +	close(fd);
> +
> +	return rc;
> +}
> diff --git a/test/test-name_to_handle_at.sh b/test/test-name_to_handle_at.sh
> new file mode 100755
> index 0000000..351b0cb
> --- /dev/null
> +++ b/test/test-name_to_handle_at.sh
> @@ -0,0 +1,21 @@
> +#!/bin/sh
> +#
> +# Test name_to_handle_at() path resolution, including inside a chroot.
> +# SPDX-License-Identifier: LGPL-2.1-only
> +#
> +# rc 77 indicates the filesystem doesn't support file handles, so report
> +# skipped (255).
> +
> +dir=$(pwd)/name_to_handle_at_test
> +trap 'rm -rf "$dir"' 0
> +rm -rf "$dir"
> +mkdir -p "$dir"
> +touch "$dir/file"
> +ln -s file "$dir/link"
> +
> +./test/test-name_to_handle_at "$dir"
> +rc=$?
> +if [ "$rc" -eq 77 ]; then
> +	exit 255
> +fi
> +exit $rc
> diff --git a/test/test-open_by_handle_at.c b/test/test-open_by_handle_at.c
> new file mode 100644
> index 0000000..a05b9d7
> --- /dev/null
> +++ b/test/test-open_by_handle_at.c
> @@ -0,0 +1,174 @@
> +/*
> + * Test open_by_handle_at() under pseudo.  The kernel needs privilege to
> + * decode a file handle, so pseudo finds and opens the file itself.
> + * SPDX-License-Identifier: LGPL-2.1-only
> + *
> + * Returns 77 if the filesystem doesn't support file handles.
> + */
> +#define _GNU_SOURCE
> +
> +#include <errno.h>
> +#include <fcntl.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <sys/stat.h>
> +#include <sys/syscall.h>
> +#include <sys/wait.h>
> +#include <unistd.h>
> +
> +static int failed;
> +
> +#define FAIL(...) do { printf(__VA_ARGS__); failed = 1; } while (0)
> +
> +static struct file_handle *
> +handle_for(const char *path, int flags) {
> +	struct file_handle *fh = malloc(sizeof(*fh) + MAX_HANDLE_SZ);
> +	int mount_id;
> +
> +	if (!fh)
> +		exit(1);
> +	fh->handle_bytes = MAX_HANDLE_SZ;
> +	if (name_to_handle_at(AT_FDCWD, path, fh, &mount_id, flags) == -1) {
> +		if (errno == EOPNOTSUPP || errno == ENOSYS) {
> +			printf("name_to_handle_at not supported: %s\n", strerror(errno));
> +			exit(77);
> +		}
> +		printf("name_to_handle_at(%s): %s\n", path, strerror(errno));
> +		exit(1);
> +	}
> +	return fh;
> +}
> +
> +/* Make the handle in another process, so this one can't have
> + * remembered where it came from.
> + */
> +static struct file_handle *
> +handle_from_child(const char *path) {
> +	struct file_handle *fh = malloc(sizeof(*fh) + MAX_HANDLE_SZ);
> +	int pipefd[2], status;
> +	pid_t pid;
> +
> +	if (!fh || pipe(pipefd) == -1)
> +		exit(1);
> +	pid = fork();
> +	if (pid == -1)
> +		exit(1);
> +	if (pid == 0) {
> +		struct file_handle *child = handle_for(path, 0);
> +		ssize_t len = sizeof(*child) + child->handle_bytes;
> +		_exit(write(pipefd[1], child, len) == len ? 0 : 1);
> +	}
> +	close(pipefd[1]);
> +	if (read(pipefd[0], fh, sizeof(*fh) + MAX_HANDLE_SZ) < (ssize_t) sizeof(*fh))
> +		exit(1);
> +	close(pipefd[0]);
> +	if (waitpid(pid, &status, 0) == -1 || !WIFEXITED(status) || WEXITSTATUS(status))
> +		exit(WIFEXITED(status) ? WEXITSTATUS(status) : 1);
> +	return fh;
> +}
> +
> +static void
> +check_dirfd(const char *how, int dirfd) {
> +	struct stat st;
> +
> +	if (dirfd == -1) {
> +		FAIL("%s: open_by_handle_at: %s\n", how, strerror(errno));
> +		return;
> +	}
> +	if (fstatat(dirfd, "file", &st, 0) == -1)
> +		FAIL("%s: fstatat: %s\n", how, strerror(errno));
> +	else if (st.st_uid != 123 || st.st_gid != 456)
> +		FAIL("%s: file owned by %d:%d, expected 123:456\n",
> +			how, (int) st.st_uid, (int) st.st_gid);
> +	close(dirfd);
> +}
> +
> +int
> +main(int argc, char *argv[]) {
> +	struct file_handle *fh;
> +	char path[4096], buf[16];
> +	struct stat st;
> +	int mount_fd, fd;
> +	ssize_t len;
> +
> +	if (argc != 2) {
> +		fprintf(stderr, "usage: %s <dir>\n", argv[0]);
> +		return 2;
> +	}
> +	mount_fd = open(argv[1], O_RDONLY | O_DIRECTORY);
> +	if (mount_fd == -1) {
> +		perror("open");
> +		return 1;
> +	}
> +
> +	/* a directory handle, used for *at() calls */
> +	snprintf(path, sizeof(path), "%s/dir/file", argv[1]);
> +	if (chown(path, 123, 456) == -1) {
> +		perror("chown");
> +		return 1;
> +	}
> +	snprintf(path, sizeof(path), "%s/dir", argv[1]);
> +	fh = handle_for(path, 0);
> +	check_dirfd("function", open_by_handle_at(mount_fd, fh, O_RDONLY | O_DIRECTORY));
> +	check_dirfd("syscall", syscall(SYS_open_by_handle_at, mount_fd, fh, O_RDONLY | O_DIRECTORY));
> +	free(fh);
> +
> +	/* a file below mount_fd that this process never named */
> +	snprintf(path, sizeof(path), "%s/dir/sub/data", argv[1]);
> +	fh = handle_from_child(path);
> +	fd = open_by_handle_at(mount_fd, fh, O_RDONLY);
> +	if (fd == -1) {
> +		FAIL("data: open_by_handle_at: %s\n", strerror(errno));
> +	} else {
> +		len = read(fd, buf, sizeof(buf) - 1);
> +		buf[len > 0 ? len : 0] = '\0';
> +		if (strcmp(buf, "hello\n"))
> +			FAIL("data: read '%s'\n", buf);
> +		close(fd);
> +	}
> +	free(fh);
> +
> +	/* mount_fd itself */
> +	fh = handle_from_child(argv[1]);
> +	fd = open_by_handle_at(mount_fd, fh, O_RDONLY | O_DIRECTORY);
> +	if (fd == -1)
> +		FAIL("mount_fd: open_by_handle_at: %s\n", strerror(errno));
> +	else
> +		close(fd);
> +	free(fh);
> +
> +	/* a symlink only opens with O_PATH, as the link itself */
> +	snprintf(path, sizeof(path), "%s/dir/link", argv[1]);
> +	fh = handle_from_child(path);
> +	fd = open_by_handle_at(mount_fd, fh, O_RDONLY);
> +	if (fd != -1 || errno != ELOOP)
> +		FAIL("link: expected ELOOP, got %d (%s)\n", fd, strerror(errno));
> +	fd = open_by_handle_at(mount_fd, fh, O_PATH);
> +	if (fd == -1)
> +		FAIL("link: O_PATH: %s\n", strerror(errno));
> +	else if (fstat(fd, &st) == -1 || !S_ISLNK(st.st_mode))
> +		FAIL("link: O_PATH didn't open the symlink\n");
> +	if (fd != -1)
> +		close(fd);
> +	free(fh);
> +
> +	/* a deleted file */
> +	snprintf(path, sizeof(path), "%s/gone", argv[1]);
> +	fh = handle_from_child(path);
> +	unlink(path);
> +	fd = open_by_handle_at(mount_fd, fh, O_RDONLY);
> +	if (fd != -1 || errno != ESTALE)
> +		FAIL("gone: expected ESTALE, got %d (%s)\n", fd, strerror(errno));
> +	if (fd != -1)
> +		close(fd);
> +
> +	/* the kernel's own argument checks still apply */
> +	fh->handle_bytes = 0;
> +	fd = open_by_handle_at(mount_fd, fh, O_RDONLY);
> +	if (fd != -1 || errno != EINVAL)
> +		FAIL("empty handle: expected EINVAL, got %d (%s)\n", fd, strerror(errno));
> +	free(fh);
> +
> +	return failed;
> +}
> diff --git a/test/test-open_by_handle_at.sh b/test/test-open_by_handle_at.sh
> new file mode 100755
> index 0000000..ef4a9f7
> --- /dev/null
> +++ b/test/test-open_by_handle_at.sh
> @@ -0,0 +1,22 @@
> +#!/bin/sh
> +#
> +# Test open_by_handle_at() under pseudo.
> +# SPDX-License-Identifier: LGPL-2.1-only
> +#
> +# rc 77 indicates the filesystem doesn't support file handles, so report
> +# skipped (255).
> +
> +dir=$(pwd)/open_by_handle_at_test
> +trap 'rm -rf "$dir"' 0
> +rm -rf "$dir"
> +mkdir -p "$dir/dir/sub"
> +touch "$dir/dir/file" "$dir/gone"
> +echo hello > "$dir/dir/sub/data"
> +ln -s file "$dir/dir/link"
> +
> +./test/test-open_by_handle_at "$dir"
> +rc=$?
> +if [ "$rc" -eq 77 ]; then
> +	exit 255
> +fi
> +exit $rc

^ permalink raw reply	[flat|nested] 2+ messages in thread

end of thread, other threads:[~2026-11-16 17:59 UTC | newest]

Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-12 17:52 [pseudo][PATCH RFC] ports/linux: Wrap name_to_handle_at() and open_by_handle_at() Mark Hatle
2026-11-16 17:59 ` [yocto-patches] " Mark Hatle

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.