vmsplice(): lift importing iovec into vmsplice(2) and compat counterpart (87a3002a) · Commits · e / devices / android_kernel_oneplus_sm7250

fs/splice.c

+75 −69

Original line number	Original line	Diff line number	Diff line
	@@ -1242,38 +1242,26 @@ static int pipe_to_user(struct pipe_inode_info pipe, struct pipe_buffer buf,
	* For lack of a better implementation, implement vmsplice() to userspace		* For lack of a better implementation, implement vmsplice() to userspace
	* as a simple copy of the pipes pages to the user iov.		* as a simple copy of the pipes pages to the user iov.
	*/		*/
	static long vmsplice_to_user(struct file file, const struct iovec __user uiov,		static long vmsplice_to_user(struct file file, struct iov_iter iter,
	unsigned long nr_segs, unsigned int flags)		unsigned int flags)
	{		{
	struct pipe_inode_info *pipe;		struct pipe_inode_info *pipe = get_pipe_info(file);
	struct splice_desc sd;		struct splice_desc sd = {
	long ret;		.total_len = iov_iter_count(iter),
	struct iovec iovstack[UIO_FASTIOV];		.flags = flags,
	struct iovec *iov = iovstack;		.u.data = iter
	struct iov_iter iter;		};
			long ret = 0;

	pipe = get_pipe_info(file);
	if (!pipe)		if (!pipe)
	return -EBADF;		return -EBADF;

	ret = import_iovec(READ, uiov, nr_segs,
	ARRAY_SIZE(iovstack), &iov, &iter);
	if (ret < 0)
	return ret;

	sd.total_len = iov_iter_count(&iter);
	sd.len = 0;
	sd.flags = flags;
	sd.u.data = &iter;
	sd.pos = 0;

	if (sd.total_len) {		if (sd.total_len) {
	pipe_lock(pipe);		pipe_lock(pipe);
	ret = __splice_from_pipe(pipe, &sd, pipe_to_user);		ret = __splice_from_pipe(pipe, &sd, pipe_to_user);
	pipe_unlock(pipe);		pipe_unlock(pipe);
	}		}

	kfree(iov);
	return ret;		return ret;
	}		}

	@@ -1282,14 +1270,11 @@ static long vmsplice_to_user(struct file file, const struct iovec __user uiov,
	* as splice-from-memory, where the regular splice is splice-from-file (or		* as splice-from-memory, where the regular splice is splice-from-file (or
	* to file). In both cases the output is a pipe, naturally.		* to file). In both cases the output is a pipe, naturally.
	*/		*/
	static long vmsplice_to_pipe(struct file file, const struct iovec __user uiov,		static long vmsplice_to_pipe(struct file file, struct iov_iter iter,
	unsigned long nr_segs, unsigned int flags)		unsigned int flags)
	{		{
	struct pipe_inode_info *pipe;		struct pipe_inode_info *pipe;
	struct iovec iovstack[UIO_FASTIOV];		long ret = 0;
	struct iovec *iov = iovstack;
	struct iov_iter from;
	long ret;
	unsigned buf_flag = 0;		unsigned buf_flag = 0;

	if (flags & SPLICE_F_GIFT)		if (flags & SPLICE_F_GIFT)
	@@ -1299,22 +1284,31 @@ static long vmsplice_to_pipe(struct file file, const struct iovec __user uiov,
	if (!pipe)		if (!pipe)
	return -EBADF;		return -EBADF;

	ret = import_iovec(WRITE, uiov, nr_segs,
	ARRAY_SIZE(iovstack), &iov, &from);
	if (ret < 0)
	return ret;

	pipe_lock(pipe);		pipe_lock(pipe);
	ret = wait_for_space(pipe, flags);		ret = wait_for_space(pipe, flags);
	if (!ret)		if (!ret)
	ret = iter_to_pipe(&from, pipe, buf_flag);		ret = iter_to_pipe(iter, pipe, buf_flag);
	pipe_unlock(pipe);		pipe_unlock(pipe);
	if (ret > 0)		if (ret > 0)
	wakeup_pipe_readers(pipe);		wakeup_pipe_readers(pipe);
	kfree(iov);
	return ret;		return ret;
	}		}

			static int vmsplice_type(struct fd f, int *type)
			{
			if (!f.file)
			return -EBADF;
			if (f.file->f_mode & FMODE_WRITE) {
			*type = WRITE;
			} else if (f.file->f_mode & FMODE_READ) {
			*type = READ;
			} else {
			fdput(f);
			return -EBADF;
			}
			return 0;
			}

	/*		/*
	* Note that vmsplice only really supports true splicing _from_ user memory		* Note that vmsplice only really supports true splicing _from_ user memory
	* to a pipe, not the other way around. Splicing from user memory is a simple		* to a pipe, not the other way around. Splicing from user memory is a simple
	@@ -1331,57 +1325,69 @@ static long vmsplice_to_pipe(struct file file, const struct iovec __user uiov,
	* Currently we punt and implement it as a normal copy, see pipe_to_user().		* Currently we punt and implement it as a normal copy, see pipe_to_user().
	*		*
	*/		*/
	static long do_vmsplice(int fd, const struct iovec __user *iov,		static long do_vmsplice(struct file f, struct iov_iter iter, unsigned int flags)
	unsigned long nr_segs, unsigned int flags)
	{		{
	struct fd f;
	long error;

	if (unlikely(flags & ~SPLICE_F_ALL))		if (unlikely(flags & ~SPLICE_F_ALL))
	return -EINVAL;		return -EINVAL;
	if (unlikely(nr_segs > UIO_MAXIOV))
	return -EINVAL;
	else if (unlikely(!nr_segs))
	return 0;

	error = -EBADF;		if (!iov_iter_count(iter))
	f = fdget(fd);		return 0;
	if (f.file) {
	if (f.file->f_mode & FMODE_WRITE)
	error = vmsplice_to_pipe(f.file, iov, nr_segs, flags);
	else if (f.file->f_mode & FMODE_READ)
	error = vmsplice_to_user(f.file, iov, nr_segs, flags);

	fdput(f);
	}

	return error;		if (iov_iter_rw(iter) == WRITE)
			return vmsplice_to_pipe(f, iter, flags);
			else
			return vmsplice_to_user(f, iter, flags);
	}		}

	SYSCALL_DEFINE4(vmsplice, int, fd, const struct iovec __user *, iov,		SYSCALL_DEFINE4(vmsplice, int, fd, const struct iovec __user *, uiov,
	unsigned long, nr_segs, unsigned int, flags)		unsigned long, nr_segs, unsigned int, flags)
	{		{
	return do_vmsplice(fd, iov, nr_segs, flags);		struct iovec iovstack[UIO_FASTIOV];
			struct iovec *iov = iovstack;
			struct iov_iter iter;
			long error;
			struct fd f;
			int type;

			f = fdget(fd);
			error = vmsplice_type(f, &type);
			if (error)
			return error;

			error = import_iovec(type, uiov, nr_segs,
			ARRAY_SIZE(iovstack), &iov, &iter);
			if (!error) {
			error = do_vmsplice(f.file, &iter, flags);
			kfree(iov);
			}
			fdput(f);
			return error;
	}		}

	#ifdef CONFIG_COMPAT		#ifdef CONFIG_COMPAT
	COMPAT_SYSCALL_DEFINE4(vmsplice, int, fd, const struct compat_iovec __user *, iov32,		COMPAT_SYSCALL_DEFINE4(vmsplice, int, fd, const struct compat_iovec __user *, iov32,
	unsigned int, nr_segs, unsigned int, flags)		unsigned int, nr_segs, unsigned int, flags)
	{		{
	unsigned i;		struct iovec iovstack[UIO_FASTIOV];
	struct iovec __user *iov;		struct iovec *iov = iovstack;
	if (nr_segs > UIO_MAXIOV)		struct iov_iter iter;
	return -EINVAL;		long error;
	iov = compat_alloc_user_space(nr_segs * sizeof(struct iovec));		struct fd f;
	for (i = 0; i < nr_segs; i++) {		int type;
	struct compat_iovec v;
	if (get_user(v.iov_base, &iov32[i].iov_base) \|\|		f = fdget(fd);
	get_user(v.iov_len, &iov32[i].iov_len) \|\|		error = vmsplice_type(f, &type);
	put_user(compat_ptr(v.iov_base), &iov[i].iov_base) \|\|		if (error)
	put_user(v.iov_len, &iov[i].iov_len))		return error;
	return -EFAULT;
			error = compat_import_iovec(type, iov32, nr_segs,
			ARRAY_SIZE(iovstack), &iov, &iter);
			if (!error) {
			error = do_vmsplice(f.file, &iter, flags);
			kfree(iov);
	}		}
	return do_vmsplice(fd, iov, nr_segs, flags);		fdput(f);
			return error;
	}		}
	#endif		#endif