5 files changed, 51 insertions, 75 deletions

diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index a0cf3e56fe20..4794923c410c 100644
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -279,7 +279,7 @@ static inline void btrfs_inode_block_unlocked_dio(struct inode *inode)
 
 static inline void btrfs_inode_resume_unlocked_dio(struct inode *inode)
 {
-        smp_mb__before_clear_bit();
+        smp_mb__before_atomic();
         clear_bit(BTRFS_INODE_READDIO_NEED_LOCK,
                   &BTRFS_I(inode)->runtime_flags);
 }
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 23398ad430a0..a389820d158b 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -3523,7 +3523,7 @@ lock_extent_buffer_for_io(struct extent_buffer *eb,
 static void end_extent_buffer_writeback(struct extent_buffer *eb)
 {
         clear_bit(EXTENT_BUFFER_WRITEBACK, &eb->bflags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(&eb->bflags, EXTENT_BUFFER_WRITEBACK);
 }
 
@@ -4576,7 +4576,8 @@ static void check_buffer_tree_ref(struct extent_buffer *eb)
         spin_unlock(&eb->refs_lock);
 }
 
-static void mark_extent_buffer_accessed(struct extent_buffer *eb)
+static void mark_extent_buffer_accessed(struct extent_buffer *eb,
+                struct page *accessed)
 {
         unsigned long num_pages, i;
 
@@ -4585,7 +4586,8 @@ static void mark_extent_buffer_accessed(struct extent_buffer *eb)
         num_pages = num_extent_pages(eb->start, eb->len);
         for (i = 0; i < num_pages; i++) {
                 struct page *p = extent_buffer_page(eb, i);
-                mark_page_accessed(p);
+                if (p != accessed)
+                        mark_page_accessed(p);
         }
 }
 
@@ -4599,7 +4601,7 @@ struct extent_buffer *find_extent_buffer(struct btrfs_fs_info *fs_info,
                                start >> PAGE_CACHE_SHIFT);
         if (eb && atomic_inc_not_zero(&eb->refs)) {
                 rcu_read_unlock();
-                mark_extent_buffer_accessed(eb);
+                mark_extent_buffer_accessed(eb, NULL);
                 return eb;
         }
         rcu_read_unlock();
@@ -4694,7 +4696,7 @@ struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,
                                 spin_unlock(&mapping->private_lock);
                                 unlock_page(p);
                                 page_cache_release(p);
-                                mark_extent_buffer_accessed(exists);
+                                mark_extent_buffer_accessed(exists, p);
                                 goto free_eb;
                         }
 
@@ -4709,7 +4711,6 @@ struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,
                 attach_extent_buffer_page(eb, p);
                 spin_unlock(&mapping->private_lock);
                 WARN_ON(PageDirty(p));
-                mark_page_accessed(p);
                 eb->pages[i] = p;
                 if (!PageUptodate(p))
                         uptodate = 0;
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index ad7c05909a49..1f2b99cb55ea 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -448,7 +448,7 @@ static noinline int btrfs_copy_from_user(loff_t pos, int num_pages,
                 write_bytes -= copied;
                 total_copied += copied;
 
-                /* Return to btrfs_file_aio_write to fault page */
+                /* Return to btrfs_file_write_iter to fault page */
                 if (unlikely(copied == 0))
                         break;
 
@@ -471,11 +471,12 @@ static void btrfs_drop_pages(struct page **pages, size_t num_pages)
         for (i = 0; i < num_pages; i++) {
                 /* page checked is some magic around finding pages that
                  * have been modified without going through btrfs_set_page_dirty
-                 * clear it here
+                 * clear it here. There should be no need to mark the pages
+                 * accessed as prepare_pages should have marked them accessed
+                 * in prepare_pages via find_or_create_page()
                  */
                 ClearPageChecked(pages[i]);
                 unlock_page(pages[i]);
-                mark_page_accessed(pages[i]);
                 page_cache_release(pages[i]);
         }
 }
@@ -1674,27 +1675,22 @@ again:
 }
 
 static ssize_t __btrfs_direct_write(struct kiocb *iocb,
-                                    const struct iovec *iov,
-                                    unsigned long nr_segs, loff_t pos,
-                                    size_t count, size_t ocount)
+                                    struct iov_iter *from,
+                                    loff_t pos)
 {
         struct file *file = iocb->ki_filp;
-        struct iov_iter i;
         ssize_t written;
         ssize_t written_buffered;
         loff_t endbyte;
         int err;
 
-        written = generic_file_direct_write(iocb, iov, &nr_segs, pos,
-                                            count, ocount);
+        written = generic_file_direct_write(iocb, from, pos);
 
-        if (written < 0 || written == count)
+        if (written < 0 || !iov_iter_count(from))
                 return written;
 
         pos += written;
-        count -= written;
-        iov_iter_init(&i, iov, nr_segs, count, written);
-        written_buffered = __btrfs_buffered_write(file, &i, pos);
+        written_buffered = __btrfs_buffered_write(file, from, pos);
         if (written_buffered < 0) {
                 err = written_buffered;
                 goto out;
@@ -1729,9 +1725,8 @@ static void update_time_for_write(struct inode *inode)
                 inode_inc_iversion(inode);
 }
 
-static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
-                                    const struct iovec *iov,
-                                    unsigned long nr_segs, loff_t pos)
+static ssize_t btrfs_file_write_iter(struct kiocb *iocb,
+                                    struct iov_iter *from)
 {
         struct file *file = iocb->ki_filp;
         struct inode *inode = file_inode(file);
@@ -1740,18 +1735,12 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
         u64 end_pos;
         ssize_t num_written = 0;
         ssize_t err = 0;
-        size_t count, ocount;
+        size_t count = iov_iter_count(from);
         bool sync = (file->f_flags & O_DSYNC) || IS_SYNC(file->f_mapping->host);
+        loff_t pos = iocb->ki_pos;
 
         mutex_lock(&inode->i_mutex);
 
-        err = generic_segment_checks(iov, &nr_segs, &ocount, VERIFY_READ);
-        if (err) {
-                mutex_unlock(&inode->i_mutex);
-                goto out;
-        }
-        count = ocount;
-
         current->backing_dev_info = inode->i_mapping->backing_dev_info;
         err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
         if (err) {
@@ -1764,6 +1753,8 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
                 goto out;
         }
 
+        iov_iter_truncate(from, count);
+
         err = file_remove_suid(file);
         if (err) {
                 mutex_unlock(&inode->i_mutex);
@@ -1805,14 +1796,9 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
                 atomic_inc(&BTRFS_I(inode)->sync_writers);
 
         if (unlikely(file->f_flags & O_DIRECT)) {
-                num_written = __btrfs_direct_write(iocb, iov, nr_segs,
-                                                   pos, count, ocount);
+                num_written = __btrfs_direct_write(iocb, from, pos);
         } else {
-                struct iov_iter i;
-
-                iov_iter_init(&i, iov, nr_segs, count, num_written);
-
-                num_written = __btrfs_buffered_write(file, &i, pos);
+                num_written = __btrfs_buffered_write(file, from, pos);
                 if (num_written > 0)
                         iocb->ki_pos = pos + num_written;
         }
@@ -2739,11 +2725,11 @@ out:
 
 const struct file_operations btrfs_file_operations = {
         .llseek         = btrfs_file_llseek,
-        .read           = do_sync_read,
-        .write          = do_sync_write,
-        .aio_read       = generic_file_aio_read,
+        .read           = new_sync_read,
+        .write          = new_sync_write,
+        .read_iter      = generic_file_read_iter,
         .splice_read    = generic_file_splice_read,
-        .aio_write      = btrfs_file_aio_write,
+        .write_iter     = btrfs_file_write_iter,
         .mmap           = btrfs_file_mmap,
         .open           = generic_file_open,
         .release        = btrfs_release_file,
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 6b65fab27a1a..3668048e16f8 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -7199,7 +7199,7 @@ static void btrfs_end_dio_bio(struct bio *bio, int err)
                  * before atomic variable goto zero, we must make sure
                  * dip->errors is perceived to be set.
                  */
-                smp_mb__before_atomic_dec();
+                smp_mb__before_atomic();
         }
 
         /* if there are more bios still pending for this dio, just exit */
@@ -7379,7 +7379,7 @@ out_err:
          * before atomic variable goto zero, we must
          * make sure dip->errors is perceived to be set.
          */
-        smp_mb__before_atomic_dec();
+        smp_mb__before_atomic();
         if (atomic_dec_and_test(&dip->pending_bios))
                 bio_io_error(dip->orig_bio);
 
@@ -7464,39 +7464,30 @@ free_ordered:
 }
 
 static ssize_t check_direct_IO(struct btrfs_root *root, int rw, struct kiocb *iocb,
-                        const struct iovec *iov, loff_t offset,
-                        unsigned long nr_segs)
+                        const struct iov_iter *iter, loff_t offset)
 {
         int seg;
         int i;
-        size_t size;
-        unsigned long addr;
         unsigned blocksize_mask = root->sectorsize - 1;
         ssize_t retval = -EINVAL;
-        loff_t end = offset;
 
         if (offset & blocksize_mask)
                 goto out;
 
-        /* Check the memory alignment.  Blocks cannot straddle pages */
-        for (seg = 0; seg < nr_segs; seg++) {
-                addr = (unsigned long)iov[seg].iov_base;
-                size = iov[seg].iov_len;
-                end += size;
-                if ((addr & blocksize_mask) || (size & blocksize_mask))
-                        goto out;
-
-                /* If this is a write we don't need to check anymore */
-                if (rw & WRITE)
-                        continue;
+        if (iov_iter_alignment(iter) & blocksize_mask)
+                goto out;
 
-                /*
-                 * Check to make sure we don't have duplicate iov_base's in this
-                 * iovec, if so return EINVAL, otherwise we'll get csum errors
-                 * when reading back.
-                 */
-                for (i = seg + 1; i < nr_segs; i++) {
-                        if (iov[seg].iov_base == iov[i].iov_base)
+        /* If this is a write we don't need to check anymore */
+        if (rw & WRITE)
+                return 0;
+        /*
+         * Check to make sure we don't have duplicate iov_base's in this
+         * iovec, if so return EINVAL, otherwise we'll get csum errors
+         * when reading back.
+         */
+        for (seg = 0; seg < iter->nr_segs; seg++) {
+                for (i = seg + 1; i < iter->nr_segs; i++) {
+                        if (iter->iov[seg].iov_base == iter->iov[i].iov_base)
                                 goto out;
                 }
         }
@@ -7506,8 +7497,7 @@ out:
 }
 
 static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
-                        const struct iovec *iov, loff_t offset,
-                        unsigned long nr_segs)
+                        struct iov_iter *iter, loff_t offset)
 {
         struct file *file = iocb->ki_filp;
         struct inode *inode = file->f_mapping->host;
@@ -7517,12 +7507,11 @@ static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
         bool relock = false;
         ssize_t ret;
 
-        if (check_direct_IO(BTRFS_I(inode)->root, rw, iocb, iov,
-                            offset, nr_segs))
+        if (check_direct_IO(BTRFS_I(inode)->root, rw, iocb, iter, offset))
                 return 0;
 
         atomic_inc(&inode->i_dio_count);
-        smp_mb__after_atomic_inc();
+        smp_mb__after_atomic();
 
         /*
          * The generic stuff only does filemap_write_and_wait_range, which
@@ -7530,7 +7519,7 @@ static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
          * we need to flush the dirty pages again to make absolutely sure
          * that any outstanding dirty pages are on disk.
          */
-        count = iov_length(iov, nr_segs);
+        count = iov_iter_count(iter);
         if (test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
                      &BTRFS_I(inode)->runtime_flags))
                 filemap_fdatawrite_range(inode->i_mapping, offset, count);
@@ -7557,7 +7546,7 @@ static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
 
         ret = __blockdev_direct_IO(rw, iocb, inode,
                         BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev,
-                        iov, offset, nr_segs, btrfs_get_blocks_direct, NULL,
+                        iter, offset, btrfs_get_blocks_direct, NULL,
                         btrfs_submit_direct, flags);
         if (rw & WRITE) {
                 if (ret < 0 && ret != -EIOCBQUEUED)
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 6ea15469c63f..0d321c23069a 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -643,7 +643,7 @@ static int create_snapshot(struct btrfs_root *root, struct inode *dir,
                 return -EINVAL;
 
         atomic_inc(&root->will_be_snapshoted);
-        smp_mb__after_atomic_inc();
+        smp_mb__after_atomic();
         btrfs_wait_nocow_write(root);
 
         ret = btrfs_start_delalloc_inodes(root, 0);