Unverified Commit a312c10c authored by Christian Brauner's avatar Christian Brauner
Browse files

Merge patch series "API for exporting connectable file handles to userspace" 

Amir Goldstein <amir73il@gmail.com> says:

These patches bring the NFS connectable file handles feature to
userspace servers.

They rely on Christian's and Aleksa's changes recently merged to v6.12.

The API I chose for encoding conenctable file handles is pretty
conventional (AT_HANDLE_CONNECTABLE).

open_by_handle_at(2) does not have AT_ flags argument, but also, I find
it more useful API that encoding a connectable file handle can mandate
the resolving of a connected fd, without having to opt-in for a
connected fd independently.

I chose to implemnent this by using upper bits in the handle type field
It may be that out-of-tree filesystems return a handle type with upper
bits set, but AFAIK, no in-tree filesystem does that.
I added some warnings just in case we encouter that.

I have written an fstest [1] and a man page draft [2] for the feature.

[1] https://github.com/amir73il/xfstests/commits/connectable-fh/
[2] https://github.com/amir73il/man-pages/commits/connectable-fh/

* patches from https://lore.kernel.org/r/20241011090023.655623-1-amir73il@gmail.com:
  fs: open_by_handle_at() support for decoding "explicit connectable" file handles
  fs: name_to_handle_at() support for "explicit connectable" file handles
  fs: prepare for "explicit connectable" file handles

Link: https://lore.kernel.org/r/20241011090023.655623-1-amir73il@gmail.com


Signed-off-by: default avatarChristian Brauner <brauner@kernel.org>
parents 8e929cb5 a20853ab

fs/exportfs/expfs.c

+15 −2
Original line number Diff line number Diff line
@@ -382,14 +382,24 @@ int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid, 
			     int *max_len, struct inode *parent, int flags)

{

	const struct export_operations *nop = inode->i_sb->s_export_op;

	enum fid_type type;



	if (!exportfs_can_encode_fh(nop, flags))

		return -EOPNOTSUPP;



	if (!nop && (flags & EXPORT_FH_FID))

		return exportfs_encode_ino64_fid(inode, fid, max_len);

		type = exportfs_encode_ino64_fid(inode, fid, max_len);

	else

		type = nop->encode_fh(inode, fid->raw, max_len, parent);



	if (type > 0 && FILEID_USER_FLAGS(type)) {

		pr_warn_once("%s: unexpected fh type value 0x%x from fstype %s.\n",

			     __func__, type, inode->i_sb->s_type->name);

		return -EINVAL;

	}



	return type;



	return nop->encode_fh(inode, fid->raw, max_len, parent);

}

EXPORT_SYMBOL_GPL(exportfs_encode_inode_fh);
@@ -436,6 +446,9 @@ exportfs_decode_fh_raw(struct vfsmount *mnt, struct fid *fid, int fh_len, 
	char nbuf[NAME_MAX+1];

	int err;



	if (fileid_type < 0 || FILEID_USER_FLAGS(fileid_type))

		return ERR_PTR(-EINVAL);



	/*

	 * Try to get any dentry for the given file handle from the filesystem.

	 */

fs/fhandle.c

+69 −6
Original line number Diff line number Diff line
@@ -31,6 +31,14 @@ static long do_sys_name_to_handle(const struct path *path, 
	if (!exportfs_can_encode_fh(path->dentry->d_sb->s_export_op, fh_flags))

		return -EOPNOTSUPP;



	/*

	 * A request to encode a connectable handle for a disconnected dentry

	 * is unexpected since AT_EMPTY_PATH is not allowed.

	 */

	if (fh_flags & EXPORT_FH_CONNECTABLE &&

	    WARN_ON(path->dentry->d_flags & DCACHE_DISCONNECTED))

		return -EINVAL;



	if (copy_from_user(&f_handle, ufh, sizeof(struct file_handle)))

		return -EFAULT;
@@ -45,7 +53,7 @@ static long do_sys_name_to_handle(const struct path *path, 
	/* convert handle size to multiple of sizeof(u32) */

	handle_dwords = f_handle.handle_bytes >> 2;



	/* we ask for a non connectable maybe decodeable file handle */

	/* Encode a possibly decodeable/connectable file handle */

	retval = exportfs_encode_fh(path->dentry,

				    (struct fid *)handle->f_handle,

				    &handle_dwords, fh_flags);
@@ -67,8 +75,23 @@ static long do_sys_name_to_handle(const struct path *path, 
		 * non variable part of the file_handle

		 */

		handle_bytes = 0;

	} else

	} else {

		/*

		 * When asked to encode a connectable file handle, encode this

		 * property in the file handle itself, so that we later know

		 * how to decode it.

		 * For sanity, also encode in the file handle if the encoded

		 * object is a directory and verify this during decode, because

		 * decoding directory file handles is quite different than

		 * decoding connectable non-directory file handles.

		 */

		if (fh_flags & EXPORT_FH_CONNECTABLE) {

			handle->handle_type |= FILEID_IS_CONNECTABLE;

			if (d_is_dir(path->dentry))

				fh_flags |= FILEID_IS_DIR;

		}

		retval = 0;

	}

	/* copy the mount id */

	if (unique_mntid) {

		if (put_user(real_mount(path->mnt)->mnt_id_unique,
@@ -109,15 +132,30 @@ SYSCALL_DEFINE5(name_to_handle_at, int, dfd, const char __user *, name, 
{

	struct path path;

	int lookup_flags;

	int fh_flags;

	int fh_flags = 0;

	int err;



	if (flag & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH | AT_HANDLE_FID |

		     AT_HANDLE_MNT_ID_UNIQUE))

		     AT_HANDLE_MNT_ID_UNIQUE | AT_HANDLE_CONNECTABLE))

		return -EINVAL;



	/*

	 * AT_HANDLE_FID means there is no intention to decode file handle

	 * AT_HANDLE_CONNECTABLE means there is an intention to decode a

	 * connected fd (with known path), so these flags are conflicting.

	 * AT_EMPTY_PATH could be used along with a dfd that refers to a

	 * disconnected non-directory, which cannot be used to encode a

	 * connectable file handle, because its parent is unknown.

	 */

	if (flag & AT_HANDLE_CONNECTABLE &&

	    flag & (AT_HANDLE_FID | AT_EMPTY_PATH))

		return -EINVAL;

	else if (flag & AT_HANDLE_FID)

		fh_flags |= EXPORT_FH_FID;

	else if (flag & AT_HANDLE_CONNECTABLE)

		fh_flags |= EXPORT_FH_CONNECTABLE;



	lookup_flags = (flag & AT_SYMLINK_FOLLOW) ? LOOKUP_FOLLOW : 0;

	fh_flags = (flag & AT_HANDLE_FID) ? EXPORT_FH_FID : 0;

	if (flag & AT_EMPTY_PATH)

		lookup_flags |= LOOKUP_EMPTY;

	err = user_path_at(dfd, name, lookup_flags, &path);
@@ -208,6 +246,12 @@ static int vfs_dentry_acceptable(void *context, struct dentry *dentry) 


	if (!(ctx->flags & HANDLE_CHECK_SUBTREE) || d == root)

		retval = 1;

	/*

	 * exportfs_decode_fh_raw() does not call acceptable() callback with

	 * a disconnected directory dentry, so we should have reached either

	 * mount fd directory or sb root.

	 */

	if (ctx->fh_flags & EXPORT_FH_DIR_ONLY)

		WARN_ON_ONCE(d != root && d != root->d_sb->s_root);

	dput(d);

	return retval;
@@ -307,6 +351,12 @@ static int handle_to_path(int mountdirfd, struct file_handle __user *ufh, 
		retval = -EINVAL;

		goto out_path;

	}

	if (f_handle.handle_type < 0 ||

	    FILEID_USER_FLAGS(f_handle.handle_type) & ~FILEID_VALID_USER_FLAGS) {

		retval = -EINVAL;

		goto out_path;

	}



	handle = kmalloc(struct_size(handle, f_handle, f_handle.handle_bytes),

			 GFP_KERNEL);

	if (!handle) {
@@ -322,6 +372,19 @@ static int handle_to_path(int mountdirfd, struct file_handle __user *ufh, 
		goto out_handle;

	}



	/*

	 * If handle was encoded with AT_HANDLE_CONNECTABLE, verify that we

	 * are decoding an fd with connected path, which is accessible from

	 * the mount fd path.

	 */

	if (f_handle.handle_type & FILEID_IS_CONNECTABLE) {

		ctx.fh_flags |= EXPORT_FH_CONNECTABLE;

		ctx.flags |= HANDLE_CHECK_SUBTREE;

	}

	if (f_handle.handle_type & FILEID_IS_DIR)

		ctx.fh_flags |= EXPORT_FH_DIR_ONLY;

	/* Filesystem code should not be exposed to user flags */

	handle->handle_type &= ~FILEID_USER_FLAGS_MASK;

	retval = do_handle_to_path(handle, path, &ctx);



out_handle:

include/linux/exportfs.h

+13 −0
Original line number Diff line number Diff line
@@ -160,6 +160,19 @@ struct fid { 
#define EXPORT_FH_FID		0x2 /* File handle may be non-decodeable */

#define EXPORT_FH_DIR_ONLY	0x4 /* Only decode file handle for a directory */



/*

 * Filesystems use only lower 8 bits of file_handle type for fid_type.

 * name_to_handle_at() uses upper 16 bits of type as user flags to be

 * interpreted by open_by_handle_at().

 */

#define FILEID_USER_FLAGS_MASK	0xffff0000

#define FILEID_USER_FLAGS(type) ((type) & FILEID_USER_FLAGS_MASK)



/* Flags supported in encoded handle_type that is exported to user */

#define FILEID_IS_CONNECTABLE	0x10000

#define FILEID_IS_DIR		0x20000

#define FILEID_VALID_USER_FLAGS	(FILEID_IS_CONNECTABLE | FILEID_IS_DIR)



/**

 * struct export_operations - for nfsd to communicate with file systems

 * @encode_fh:      encode a file handle fragment from a dentry

include/uapi/linux/fcntl.h

+1 −0
Original line number Diff line number Diff line
@@ -153,6 +153,7 @@ 
					   object identity and may not be

					   usable with open_by_handle_at(2). */

#define AT_HANDLE_MNT_ID_UNIQUE	0x001	/* Return the u64 unique mount ID. */

#define AT_HANDLE_CONNECTABLE	0x002	/* Request a connectable file handle */



#if defined(__KERNEL__)

#define AT_GETATTR_NOSEC	0x80000000