Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 87a3002a authored by Al Viro's avatar Al Viro
Browse files

vmsplice(): lift importing iovec into vmsplice(2) and compat counterpart 



... getting rid of transformations in the latter - just use
compat_import_iovec().

Signed-off-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
parent 4faa9996

fs/splice.c

+75 −69
Original line number 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

 * 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,

			     unsigned long nr_segs, unsigned int flags)

static long vmsplice_to_user(struct file *file, struct iov_iter *iter,

			     unsigned int flags)

{

	struct pipe_inode_info *pipe;

	struct splice_desc sd;

	long ret;

	struct iovec iovstack[UIO_FASTIOV];

	struct iovec *iov = iovstack;

	struct iov_iter iter;

	struct pipe_inode_info *pipe = get_pipe_info(file);

	struct splice_desc sd = {

		.total_len = iov_iter_count(iter),

		.flags = flags,

		.u.data = iter

	};

	long ret = 0;



	pipe = get_pipe_info(file);

	if (!pipe)

		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) {

		pipe_lock(pipe);

		ret = __splice_from_pipe(pipe, &sd, pipe_to_user);

		pipe_unlock(pipe);

	}



	kfree(iov);

	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

 * to file). In both cases the output is a pipe, naturally.

 */

static long vmsplice_to_pipe(struct file *file, const struct iovec __user *uiov,

			     unsigned long nr_segs, unsigned int flags)

static long vmsplice_to_pipe(struct file *file, struct iov_iter *iter,

			     unsigned int flags)

{

	struct pipe_inode_info *pipe;

	struct iovec iovstack[UIO_FASTIOV];

	struct iovec *iov = iovstack;

	struct iov_iter from;

	long ret;

	long ret = 0;

	unsigned buf_flag = 0;



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

		return -EBADF;



	ret = import_iovec(WRITE, uiov, nr_segs,

			   ARRAY_SIZE(iovstack), &iov, &from);

	if (ret < 0)

		return ret;



	pipe_lock(pipe);

	ret = wait_for_space(pipe, flags);

	if (!ret)

		ret = iter_to_pipe(&from, pipe, buf_flag);

		ret = iter_to_pipe(iter, pipe, buf_flag);

	pipe_unlock(pipe);

	if (ret > 0)

		wakeup_pipe_readers(pipe);

	kfree(iov);

	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

 * 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().

 *

 */

static long do_vmsplice(int fd, const struct iovec __user *iov,

			unsigned long nr_segs, unsigned int flags)

static long do_vmsplice(struct file *f, struct iov_iter *iter, unsigned int flags)

{

	struct fd f;

	long error;



	if (unlikely(flags & ~SPLICE_F_ALL))

		return -EINVAL;

	if (unlikely(nr_segs > UIO_MAXIOV))

		return -EINVAL;

	else if (unlikely(!nr_segs))

		return 0;



	error = -EBADF;

	f = fdget(fd);

	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);

	}

	if (!iov_iter_count(iter))

		return 0;



	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)

{

	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

COMPAT_SYSCALL_DEFINE4(vmsplice, int, fd, const struct compat_iovec __user *, iov32,

		    unsigned int, nr_segs, unsigned int, flags)

{

	unsigned i;

	struct iovec __user *iov;

	if (nr_segs > UIO_MAXIOV)

		return -EINVAL;

	iov = compat_alloc_user_space(nr_segs * sizeof(struct iovec));

	for (i = 0; i < nr_segs; i++) {

		struct compat_iovec v;

		if (get_user(v.iov_base, &iov32[i].iov_base) ||

		    get_user(v.iov_len, &iov32[i].iov_len) ||

		    put_user(compat_ptr(v.iov_base), &iov[i].iov_base) ||

		    put_user(v.iov_len, &iov[i].iov_len))

			return -EFAULT;

	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 = 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