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: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/fs/splice.c b/fs/splice.c
index 005d09cf3fa879fd2fab8fd6a95433fefa7abc4d..e3d0ae5383e7a7f2b674d74612eabdbae2fec232 100644 (file)
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -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