1 files changed, 160 insertions, 93 deletions

diff --git a/fs/read_write.c b/fs/read_write.c
index d4cb3183c99c..f792000a28e6 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -15,13 +15,15 @@
 #include <linux/module.h>
 #include <linux/syscalls.h>
 #include <linux/pagemap.h>
+#include "read_write.h"
 
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
 
 const struct file_operations generic_ro_fops = {
         .llseek         = generic_file_llseek,
-        .read           = generic_file_read,
+        .read           = do_sync_read,
+        .aio_read       = generic_file_aio_read,
         .mmap           = generic_file_readonly_mmap,
         .sendfile       = generic_file_sendfile,
 };
@@ -227,14 +229,20 @@ static void wait_on_retry_sync_kiocb(struct kiocb *iocb)
 
 ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
 {
+        struct iovec iov = { .iov_base = buf, .iov_len = len };
         struct kiocb kiocb;
         ssize_t ret;
 
         init_sync_kiocb(&kiocb, filp);
         kiocb.ki_pos = *ppos;
-        while (-EIOCBRETRY ==
-                (ret = filp->f_op->aio_read(&kiocb, buf, len, kiocb.ki_pos)))
+        kiocb.ki_left = len;
+
+        for (;;) {
+                ret = filp->f_op->aio_read(&kiocb, &iov, 1, kiocb.ki_pos);
+                if (ret != -EIOCBRETRY)
+                        break;
                 wait_on_retry_sync_kiocb(&kiocb);
+        }
 
         if (-EIOCBQUEUED == ret)
                 ret = wait_on_sync_kiocb(&kiocb);
@@ -279,14 +287,20 @@ EXPORT_SYMBOL(vfs_read);
 
 ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
 {
+        struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };
         struct kiocb kiocb;
         ssize_t ret;
 
         init_sync_kiocb(&kiocb, filp);
         kiocb.ki_pos = *ppos;
-        while (-EIOCBRETRY ==
-               (ret = filp->f_op->aio_write(&kiocb, buf, len, kiocb.ki_pos)))
+        kiocb.ki_left = len;
+
+        for (;;) {
+                ret = filp->f_op->aio_write(&kiocb, &iov, 1, kiocb.ki_pos);
+                if (ret != -EIOCBRETRY)
+                        break;
                 wait_on_retry_sync_kiocb(&kiocb);
+        }
 
         if (-EIOCBQUEUED == ret)
                 ret = wait_on_sync_kiocb(&kiocb);
@@ -438,78 +452,155 @@ unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to)
 
 EXPORT_UNUSED_SYMBOL(iov_shorten);  /*  June 2006  */
 
+ssize_t do_sync_readv_writev(struct file *filp, const struct iovec *iov,
+                unsigned long nr_segs, size_t len, loff_t *ppos, iov_fn_t fn)
+{
+        struct kiocb kiocb;
+        ssize_t ret;
+
+        init_sync_kiocb(&kiocb, filp);
+        kiocb.ki_pos = *ppos;
+        kiocb.ki_left = len;
+        kiocb.ki_nbytes = len;
+
+        for (;;) {
+                ret = fn(&kiocb, iov, nr_segs, kiocb.ki_pos);
+                if (ret != -EIOCBRETRY)
+                        break;
+                wait_on_retry_sync_kiocb(&kiocb);
+        }
+
+        if (ret == -EIOCBQUEUED)
+                ret = wait_on_sync_kiocb(&kiocb);
+        *ppos = kiocb.ki_pos;
+        return ret;
+}
+
+/* Do it by hand, with file-ops */
+ssize_t do_loop_readv_writev(struct file *filp, struct iovec *iov,
+                unsigned long nr_segs, loff_t *ppos, io_fn_t fn)
+{
+        struct iovec *vector = iov;
+        ssize_t ret = 0;
+
+        while (nr_segs > 0) {
+                void __user *base;
+                size_t len;
+                ssize_t nr;
+
+                base = vector->iov_base;
+                len = vector->iov_len;
+                vector++;
+                nr_segs--;
+
+                nr = fn(filp, base, len, ppos);
+
+                if (nr < 0) {
+                        if (!ret)
+                                ret = nr;
+                        break;
+                }
+                ret += nr;
+                if (nr != len)
+                        break;
+        }
+
+        return ret;
+}
+
 /* A write operation does a read from user space and vice versa */
 #define vrfy_dir(type) ((type) == READ ? VERIFY_WRITE : VERIFY_READ)
 
+ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
+                              unsigned long nr_segs, unsigned long fast_segs,
+                              struct iovec *fast_pointer,
+                              struct iovec **ret_pointer)
+  {
+        unsigned long seg;
+        ssize_t ret;
+        struct iovec *iov = fast_pointer;
+
+        /*
+         * SuS says "The readv() function *may* fail if the iovcnt argument
+         * was less than or equal to 0, or greater than {IOV_MAX}.  Linux has
+         * traditionally returned zero for zero segments, so...
+         */
+        if (nr_segs == 0) {
+                ret = 0;
+                goto out;
+        }
+
+        /*
+         * First get the "struct iovec" from user memory and
+         * verify all the pointers
+         */
+        if (nr_segs > UIO_MAXIOV) {
+                ret = -EINVAL;
+                goto out;
+        }
+        if (nr_segs > fast_segs) {
+                iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
+                if (iov == NULL) {
+                        ret = -ENOMEM;
+                        goto out;
+                }
+        }
+        if (copy_from_user(iov, uvector, nr_segs*sizeof(*uvector))) {
+                ret = -EFAULT;
+                goto out;
+        }
+
+        /*
+         * According to the Single Unix Specification we should return EINVAL
+         * if an element length is < 0 when cast to ssize_t or if the
+         * total length would overflow the ssize_t return value of the
+         * system call.
+         */
+        ret = 0;
+        for (seg = 0; seg < nr_segs; seg++) {
+                void __user *buf = iov[seg].iov_base;
+                ssize_t len = (ssize_t)iov[seg].iov_len;
+
+                /* see if we we're about to use an invalid len or if
+                 * it's about to overflow ssize_t */
+                if (len < 0 || (ret + len < ret)) {
+                        ret = -EINVAL;
+                        goto out;
+                }
+                if (unlikely(!access_ok(vrfy_dir(type), buf, len))) {
+                        ret = -EFAULT;
+                        goto out;
+                }
+
+                ret += len;
+        }
+out:
+        *ret_pointer = iov;
+        return ret;
+}
+
 static ssize_t do_readv_writev(int type, struct file *file,
                                const struct iovec __user * uvector,
                                unsigned long nr_segs, loff_t *pos)
 {
-        typedef ssize_t (*io_fn_t)(struct file *, char __user *, size_t, loff_t *);
-        typedef ssize_t (*iov_fn_t)(struct file *, const struct iovec *, unsigned long, loff_t *);
-
         size_t tot_len;
         struct iovec iovstack[UIO_FASTIOV];
-        struct iovec *iov=iovstack, *vector;
+        struct iovec *iov = iovstack;
         ssize_t ret;
-        int seg;
         io_fn_t fn;
         iov_fn_t fnv;
 
-        /*
-         * SuS says "The readv() function *may* fail if the iovcnt argument
-         * was less than or equal to 0, or greater than {IOV_MAX}.  Linux has
-         * traditionally returned zero for zero segments, so...
-         */
-        ret = 0;
-        if (nr_segs == 0)
+        if (!file->f_op) {
+                ret = -EINVAL;
                 goto out;
+        }
 
-        /*
-         * First get the "struct iovec" from user memory and
-         * verify all the pointers
-         */
-        ret = -EINVAL;
-        if (nr_segs > UIO_MAXIOV)
-                goto out;
-        if (!file->f_op)
-                goto out;
-        if (nr_segs > UIO_FASTIOV) {
-                ret = -ENOMEM;
-                iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
-                if (!iov)
-                        goto out;
-        }
-        ret = -EFAULT;
-        if (copy_from_user(iov, uvector, nr_segs*sizeof(*uvector)))
+        ret = rw_copy_check_uvector(type, uvector, nr_segs,
+                        ARRAY_SIZE(iovstack), iovstack, &iov);
+        if (ret <= 0)
                 goto out;
 
-        /*
-         * Single unix specification:
-         * We should -EINVAL if an element length is not >= 0 and fitting an
-         * ssize_t.  The total length is fitting an ssize_t
-         *
-         * Be careful here because iov_len is a size_t not an ssize_t
-         */
-        tot_len = 0;
-        ret = -EINVAL;
-        for (seg = 0; seg < nr_segs; seg++) {
-                void __user *buf = iov[seg].iov_base;
-                ssize_t len = (ssize_t)iov[seg].iov_len;
-
-                if (len < 0)    /* size_t not fitting an ssize_t .. */
-                        goto out;
-                if (unlikely(!access_ok(vrfy_dir(type), buf, len)))
-                        goto Efault;
-                tot_len += len;
-                if ((ssize_t)tot_len < 0) /* maths overflow on the ssize_t */
-                        goto out;
-        }
-        if (tot_len == 0) {
-                ret = 0;
-                goto out;
-        }
-
+        tot_len = ret;
         ret = rw_verify_area(type, file, pos, tot_len);
         if (ret < 0)
                 goto out;
@@ -520,39 +611,18 @@ static ssize_t do_readv_writev(int type, struct file *file,
         fnv = NULL;
         if (type == READ) {
                 fn = file->f_op->read;
-                fnv = file->f_op->readv;
+                fnv = file->f_op->aio_read;
         } else {
                 fn = (io_fn_t)file->f_op->write;
-                fnv = file->f_op->writev;
+                fnv = file->f_op->aio_write;
         }
-        if (fnv) {
-                ret = fnv(file, iov, nr_segs, pos);
-                goto out;
-        }
-
-        /* Do it by hand, with file-ops */
-        ret = 0;
-        vector = iov;
-        while (nr_segs > 0) {
-                void __user * base;
-                size_t len;
-                ssize_t nr;
 
-                base = vector->iov_base;
-                len = vector->iov_len;
-                vector++;
-                nr_segs--;
-
-                nr = fn(file, base, len, pos);
+        if (fnv)
+                ret = do_sync_readv_writev(file, iov, nr_segs, tot_len,
+                                                pos, fnv);
+        else
+                ret = do_loop_readv_writev(file, iov, nr_segs, pos, fn);
 
-                if (nr < 0) {
-                        if (!ret) ret = nr;
-                        break;
-                }
-                ret += nr;
-                if (nr != len)
-                        break;
-        }
 out:
         if (iov != iovstack)
                 kfree(iov);
@@ -563,9 +633,6 @@ out:
                         fsnotify_modify(file->f_dentry);
         }
         return ret;
-Efault:
-        ret = -EFAULT;
-        goto out;
 }
 
 ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
@@ -573,7 +640,7 @@ ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
 {
         if (!(file->f_mode & FMODE_READ))
                 return -EBADF;
-        if (!file->f_op || (!file->f_op->readv && !file->f_op->read))
+        if (!file->f_op || (!file->f_op->aio_read && !file->f_op->read))
                 return -EINVAL;
 
         return do_readv_writev(READ, file, vec, vlen, pos);
@@ -586,7 +653,7 @@ ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
 {
         if (!(file->f_mode & FMODE_WRITE))
                 return -EBADF;
-        if (!file->f_op || (!file->f_op->writev && !file->f_op->write))
+        if (!file->f_op || (!file->f_op->aio_write && !file->f_op->write))
                 return -EINVAL;
 
         return do_readv_writev(WRITE, file, vec, vlen, pos);