Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux

[firefly-linux-kernel-4.4.55.git] / fs / ncpfs / file.c

diff --git a/fs/ncpfs/file.c b/fs/ncpfs/file.c
index 1dd7007f974dd97fb0df6d036f85b1f0f9950842..011324ce9df21181d6983f1fe81c659e1120a814 100644 (file)
--- a/fs/ncpfs/file.c
+++ b/fs/ncpfs/file.c
@@ -98,30 +98,24 @@ out:
 }
 
 static ssize_t
-ncp_file_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
+ncp_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
 {
+       struct file *file = iocb->ki_filp;
        struct inode *inode = file_inode(file);
        size_t already_read = 0;
-       off_t pos;
+       off_t pos = iocb->ki_pos;
        size_t bufsize;
        int error;
-       void* freepage;
+       void *freepage;
        size_t freelen;
 
        ncp_dbg(1, "enter %pD2\n", file);
 
-       pos = *ppos;
-
-       if ((ssize_t) count < 0) {
-               return -EINVAL;
-       }
-       if (!count)
+       if (!iov_iter_count(to))
                return 0;
        if (pos > inode->i_sb->s_maxbytes)
                return 0;
-       if (pos + count > inode->i_sb->s_maxbytes) {
-               count = inode->i_sb->s_maxbytes - pos;
-       }
+       iov_iter_truncate(to, inode->i_sb->s_maxbytes - pos);
 
        error = ncp_make_open(inode, O_RDONLY);
        if (error) {
@@ -138,31 +132,29 @@ ncp_file_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
                goto outrel;
        error = 0;
        /* First read in as much as possible for each bufsize. */
-       while (already_read < count) {
+       while (iov_iter_count(to)) {
                int read_this_time;
-               size_t to_read = min_t(unsigned int,
+               size_t to_read = min_t(size_t,
                                     bufsize - (pos % bufsize),
-                                    count - already_read);
+                                    iov_iter_count(to));
 
                error = ncp_read_bounce(NCP_SERVER(inode),
                                NCP_FINFO(inode)->file_handle,
-                               pos, to_read, buf, &read_this_time, 
+                               pos, to_read, to, &read_this_time, 
                                freepage, freelen);
                if (error) {
                        error = -EIO;   /* NW errno -> Linux errno */
                        break;
                }
                pos += read_this_time;
-               buf += read_this_time;
                already_read += read_this_time;
 
-               if (read_this_time != to_read) {
+               if (read_this_time != to_read)
                        break;
-               }
        }
        vfree(freepage);
 
-       *ppos = pos;
+       iocb->ki_pos = pos;
 
        file_accessed(file);
 
@@ -173,42 +165,21 @@ outrel:
 }
 
 static ssize_t
-ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
+ncp_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 {
+       struct file *file = iocb->ki_filp;
        struct inode *inode = file_inode(file);
        size_t already_written = 0;
-       off_t pos;
        size_t bufsize;
        int errno;
-       void* bouncebuffer;
+       void *bouncebuffer;
+       off_t pos;
 
        ncp_dbg(1, "enter %pD2\n", file);
-       if ((ssize_t) count < 0)
-               return -EINVAL;
-       pos = *ppos;
-       if (file->f_flags & O_APPEND) {
-               pos = i_size_read(inode);
-       }
+       errno = generic_write_checks(iocb, from);
+       if (errno <= 0)
+               return errno;
 
-       if (pos + count > MAX_NON_LFS && !(file->f_flags&O_LARGEFILE)) {
-               if (pos >= MAX_NON_LFS) {
-                       return -EFBIG;
-               }
-               if (count > MAX_NON_LFS - (u32)pos) {
-                       count = MAX_NON_LFS - (u32)pos;
-               }
-       }
-       if (pos >= inode->i_sb->s_maxbytes) {
-               if (count || pos > inode->i_sb->s_maxbytes) {
-                       return -EFBIG;
-               }
-       }
-       if (pos + count > inode->i_sb->s_maxbytes) {
-               count = inode->i_sb->s_maxbytes - pos;
-       }
-       
-       if (!count)
-               return 0;
        errno = ncp_make_open(inode, O_WRONLY);
        if (errno) {
                ncp_dbg(1, "open failed, error=%d\n", errno);
@@ -216,8 +187,6 @@ ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *
        }
        bufsize = NCP_SERVER(inode)->buffer_size;
 
-       already_written = 0;
-
        errno = file_update_time(file);
        if (errno)
                goto outrel;
@@ -227,13 +196,14 @@ ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *
                errno = -EIO;   /* -ENOMEM */
                goto outrel;
        }
-       while (already_written < count) {
+       pos = iocb->ki_pos;
+       while (iov_iter_count(from)) {
                int written_this_time;
-               size_t to_write = min_t(unsigned int,
+               size_t to_write = min_t(size_t,
                                      bufsize - (pos % bufsize),
-                                     count - already_written);
+                                     iov_iter_count(from));
 
-               if (copy_from_user(bouncebuffer, buf, to_write)) {
+               if (copy_from_iter(bouncebuffer, to_write, from) != to_write) {
                        errno = -EFAULT;
                        break;
                }
@@ -244,16 +214,14 @@ ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *
                        break;
                }
                pos += written_this_time;
-               buf += written_this_time;
                already_written += written_this_time;
 
-               if (written_this_time != to_write) {
+               if (written_this_time != to_write)
                        break;
-               }
        }
        vfree(bouncebuffer);
 
-       *ppos = pos;
+       iocb->ki_pos = pos;
 
        if (pos > i_size_read(inode)) {
                mutex_lock(&inode->i_mutex);
@@ -277,8 +245,8 @@ static int ncp_release(struct inode *inode, struct file *file) {
 const struct file_operations ncp_file_operations =
 {
        .llseek         = generic_file_llseek,
-       .read           = ncp_file_read,
-       .write          = ncp_file_write,
+       .read_iter      = ncp_file_read_iter,
+       .write_iter     = ncp_file_write_iter,
        .unlocked_ioctl = ncp_ioctl,
 #ifdef CONFIG_COMPAT
        .compat_ioctl   = ncp_compat_ioctl,