Merge tag 'vfs-6.13.exportfs' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs (1675db5c) · Commits · git / linux-nf

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);
		@@ -207,6 +245,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;
		@@ -306,6 +350,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) {
		@@ -321,6 +371,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,5 +153,6 @@
		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 */

		#endif /* _UAPI_LINUX_FCNTL_H */