39 files changed, 199 insertions, 263 deletions

diff --git a/fs/afs/write.c b/fs/afs/write.c
index 106e43db1115..11dd0526b96b 100644
--- a/fs/afs/write.c
+++ b/fs/afs/write.c
@@ -308,7 +308,7 @@ static void afs_kill_pages(struct afs_vnode *vnode, bool error,
         _enter("{%x:%u},%lx-%lx",
                vnode->fid.vid, vnode->fid.vnode, first, last);
 
-        pagevec_init(&pv, 0);
+        pagevec_init(&pv);
 
         do {
                 _debug("kill %lx-%lx", first, last);
@@ -497,20 +497,13 @@ static int afs_writepages_region(struct address_space *mapping,
         _enter(",,%lx,%lx,", index, end);
 
         do {
-                n = find_get_pages_tag(mapping, &index, PAGECACHE_TAG_DIRTY,
-                                       1, &page);
+                n = find_get_pages_range_tag(mapping, &index, end,
+                                        PAGECACHE_TAG_DIRTY, 1, &page);
                 if (!n)
                         break;
 
                 _debug("wback %lx", page->index);
 
-                if (page->index > end) {
-                        *_next = index;
-                        put_page(page);
-                        _leave(" = 0 [%lx]", *_next);
-                        return 0;
-                }
-
                 /* at this point we hold neither mapping->tree_lock nor lock on
                  * the page itself: the page may be truncated or invalidated
                  * (changing page->mapping to NULL), or even swizzled back from
@@ -609,7 +602,7 @@ void afs_pages_written_back(struct afs_vnode *vnode, struct afs_call *call)
 
         ASSERT(wb != NULL);
 
-        pagevec_init(&pv, 0);
+        pagevec_init(&pv);
 
         do {
                 _debug("done %lx-%lx", first, last);
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index adbbc017191c..16045ea86fc1 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -3797,7 +3797,7 @@ int btree_write_cache_pages(struct address_space *mapping,
         int scanned = 0;
         int tag;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
         if (wbc->range_cyclic) {
                 index = mapping->writeback_index; /* Start from prev offset */
                 end = -1;
@@ -3814,8 +3814,8 @@ retry:
         if (wbc->sync_mode == WB_SYNC_ALL)
                 tag_pages_for_writeback(mapping, index, end);
         while (!done && !nr_to_write_done && (index <= end) &&
-               (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag,
-                        min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1))) {
+               (nr_pages = pagevec_lookup_range_tag(&pvec, mapping, &index, end,
+                        tag))) {
                 unsigned i;
 
                 scanned = 1;
@@ -3825,11 +3825,6 @@ retry:
                         if (!PagePrivate(page))
                                 continue;
 
-                        if (!wbc->range_cyclic && page->index > end) {
-                                done = 1;
-                                break;
-                        }
-
                         spin_lock(&mapping->private_lock);
                         if (!PagePrivate(page)) {
                                 spin_unlock(&mapping->private_lock);
@@ -3941,7 +3936,7 @@ static int extent_write_cache_pages(struct address_space *mapping,
         if (!igrab(inode))
                 return 0;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
         if (wbc->range_cyclic) {
                 index = mapping->writeback_index; /* Start from prev offset */
                 end = -1;
@@ -3961,8 +3956,8 @@ retry:
                 tag_pages_for_writeback(mapping, index, end);
         done_index = index;
         while (!done && !nr_to_write_done && (index <= end) &&
-               (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag,
-                        min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1))) {
+                        (nr_pages = pagevec_lookup_range_tag(&pvec, mapping,
+                                                &index, end, tag))) {
                 unsigned i;
 
                 scanned = 1;
@@ -3987,12 +3982,6 @@ retry:
                                 continue;
                         }
 
-                        if (!wbc->range_cyclic && page->index > end) {
-                                done = 1;
-                                unlock_page(page);
-                                continue;
-                        }
-
                         if (wbc->sync_mode != WB_SYNC_NONE) {
                                 if (PageWriteback(page))
                                         flush_fn(data);
diff --git a/fs/buffer.c b/fs/buffer.c
index 1c18a22a6013..0736a6a2e2f0 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -1592,7 +1592,7 @@ void clean_bdev_aliases(struct block_device *bdev, sector_t block, sector_t len)
         struct buffer_head *head;
 
         end = (block + len - 1) >> (PAGE_SHIFT - bd_inode->i_blkbits);
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
         while (pagevec_lookup_range(&pvec, bd_mapping, &index, end)) {
                 count = pagevec_count(&pvec);
                 for (i = 0; i < count; i++) {
@@ -3514,7 +3514,7 @@ page_cache_seek_hole_data(struct inode *inode, loff_t offset, loff_t length,
         if (length <= 0)
                 return -ENOENT;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
 
         do {
                 unsigned nr_pages, i;
diff --git a/fs/cachefiles/rdwr.c b/fs/cachefiles/rdwr.c
index 18d7aa61ef0f..883bc7bb12c5 100644
--- a/fs/cachefiles/rdwr.c
+++ b/fs/cachefiles/rdwr.c
@@ -256,8 +256,7 @@ static int cachefiles_read_backing_file_one(struct cachefiles_object *object,
                         goto backing_page_already_present;
 
                 if (!newpage) {
-                        newpage = __page_cache_alloc(cachefiles_gfp |
-                                                     __GFP_COLD);
+                        newpage = __page_cache_alloc(cachefiles_gfp);
                         if (!newpage)
                                 goto nomem_monitor;
                 }
@@ -493,8 +492,7 @@ static int cachefiles_read_backing_file(struct cachefiles_object *object,
                                 goto backing_page_already_present;
 
                         if (!newpage) {
-                                newpage = __page_cache_alloc(cachefiles_gfp |
-                                                             __GFP_COLD);
+                                newpage = __page_cache_alloc(cachefiles_gfp);
                                 if (!newpage)
                                         goto nomem;
                         }
@@ -710,7 +708,7 @@ int cachefiles_read_or_alloc_pages(struct fscache_retrieval *op,
         /* calculate the shift required to use bmap */
         shift = PAGE_SHIFT - inode->i_sb->s_blocksize_bits;
 
-        pagevec_init(&pagevec, 0);
+        pagevec_init(&pagevec);
 
         op->op.flags &= FSCACHE_OP_KEEP_FLAGS;
         op->op.flags |= FSCACHE_OP_ASYNC;
@@ -844,7 +842,7 @@ int cachefiles_allocate_pages(struct fscache_retrieval *op,
 
         ret = cachefiles_has_space(cache, 0, *nr_pages);
         if (ret == 0) {
-                pagevec_init(&pagevec, 0);
+                pagevec_init(&pagevec);
 
                 list_for_each_entry(page, pages, lru) {
                         if (pagevec_add(&pagevec, page) == 0)
diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index 4d622654bfbc..dbf07051aacd 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -680,7 +680,7 @@ static void ceph_release_pages(struct page **pages, int num)
         struct pagevec pvec;
         int i;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
         for (i = 0; i < num; i++) {
                 if (pagevec_add(&pvec, pages[i]) == 0)
                         pagevec_release(&pvec);
@@ -811,7 +811,7 @@ static int ceph_writepages_start(struct address_space *mapping,
         if (fsc->mount_options->wsize < wsize)
                 wsize = fsc->mount_options->wsize;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
 
         start_index = wbc->range_cyclic ? mapping->writeback_index : 0;
         index = start_index;
@@ -870,15 +870,10 @@ retry:
                 max_pages = wsize >> PAGE_SHIFT;
 
 get_more_pages:
-                pvec_pages = min_t(unsigned, PAGEVEC_SIZE,
-                                   max_pages - locked_pages);
-                if (end - index < (u64)(pvec_pages - 1))
-                        pvec_pages = (unsigned)(end - index) + 1;
-
-                pvec_pages = pagevec_lookup_tag(&pvec, mapping, &index,
-                                                PAGECACHE_TAG_DIRTY,
-                                                pvec_pages);
-                dout("pagevec_lookup_tag got %d\n", pvec_pages);
+                pvec_pages = pagevec_lookup_range_nr_tag(&pvec, mapping, &index,
+                                                end, PAGECACHE_TAG_DIRTY,
+                                                max_pages - locked_pages);
+                dout("pagevec_lookup_range_tag got %d\n", pvec_pages);
                 if (!pvec_pages && !locked_pages)
                         break;
                 for (i = 0; i < pvec_pages && locked_pages < max_pages; i++) {
@@ -896,16 +891,6 @@ get_more_pages:
                                 unlock_page(page);
                                 continue;
                         }
-                        if (page->index > end) {
-                                dout("end of range %p\n", page);
-                                /* can't be range_cyclic (1st pass) because
-                                 * end == -1 in that case. */
-                                stop = true;
-                                if (ceph_wbc.head_snapc)
-                                        done = true;
-                                unlock_page(page);
-                                break;
-                        }
                         if (strip_unit_end && (page->index > strip_unit_end)) {
                                 dout("end of strip unit %p\n", page);
                                 unlock_page(page);
@@ -1177,8 +1162,7 @@ release_pvec_pages:
                         index = 0;
                         while ((index <= end) &&
                                (nr = pagevec_lookup_tag(&pvec, mapping, &index,
-                                                        PAGECACHE_TAG_WRITEBACK,
-                                                        PAGEVEC_SIZE))) {
+                                                PAGECACHE_TAG_WRITEBACK))) {
                                 for (i = 0; i < nr; i++) {
                                         page = pvec.pages[i];
                                         if (page_snap_context(page) != snapc)
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 92fdf9c35de2..df9f682708c6 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -1963,8 +1963,6 @@ wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
                           pgoff_t end, pgoff_t *index,
                           unsigned int *found_pages)
 {
-        unsigned int nr_pages;
-        struct page **pages;
         struct cifs_writedata *wdata;
 
         wdata = cifs_writedata_alloc((unsigned int)tofind,
@@ -1972,23 +1970,8 @@ wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
         if (!wdata)
                 return NULL;
 
-        /*
-         * find_get_pages_tag seems to return a max of 256 on each
-         * iteration, so we must call it several times in order to
-         * fill the array or the wsize is effectively limited to
-         * 256 * PAGE_SIZE.
-         */
-        *found_pages = 0;
-        pages = wdata->pages;
-        do {
-                nr_pages = find_get_pages_tag(mapping, index,
-                                              PAGECACHE_TAG_DIRTY, tofind,
-                                              pages);
-                *found_pages += nr_pages;
-                tofind -= nr_pages;
-                pages += nr_pages;
-        } while (nr_pages && tofind && *index <= end);
-
+        *found_pages = find_get_pages_range_tag(mapping, index, end,
+                                PAGECACHE_TAG_DIRTY, tofind, wdata->pages);
         return wdata;
 }
 
diff --git a/fs/dax.c b/fs/dax.c
index f3a44a7c14b3..3652b26a0048 100644
--- a/fs/dax.c
+++ b/fs/dax.c
@@ -565,7 +565,7 @@ static void *dax_insert_mapping_entry(struct address_space *mapping,
                 ret = __radix_tree_lookup(page_tree, index, &node, &slot);
                 WARN_ON_ONCE(ret != entry);
                 __radix_tree_replace(page_tree, node, slot,
-                                     new_entry, NULL, NULL);
+                                     new_entry, NULL);
                 entry = new_entry;
         }
 
@@ -614,6 +614,13 @@ static void dax_mapping_entry_mkclean(struct address_space *mapping,
                 if (follow_pte_pmd(vma->vm_mm, address, &start, &end, &ptep, &pmdp, &ptl))
                         continue;
 
+                /*
+                 * No need to call mmu_notifier_invalidate_range() as we are
+                 * downgrading page table protection not changing it to point
+                 * to a new page.
+                 *
+                 * See Documentation/vm/mmu_notifier.txt
+                 */
                 if (pmdp) {
 #ifdef CONFIG_FS_DAX_PMD
                         pmd_t pmd;
@@ -628,7 +635,6 @@ static void dax_mapping_entry_mkclean(struct address_space *mapping,
                         pmd = pmd_wrprotect(pmd);
                         pmd = pmd_mkclean(pmd);
                         set_pmd_at(vma->vm_mm, address, pmdp, pmd);
-                        mmu_notifier_invalidate_range(vma->vm_mm, start, end);
 unlock_pmd:
                         spin_unlock(ptl);
 #endif
@@ -643,7 +649,6 @@ unlock_pmd:
                         pte = pte_wrprotect(pte);
                         pte = pte_mkclean(pte);
                         set_pte_at(vma->vm_mm, address, ptep, pte);
-                        mmu_notifier_invalidate_range(vma->vm_mm, start, end);
 unlock_pte:
                         pte_unmap_unlock(ptep, ptl);
                 }
@@ -789,7 +794,7 @@ int dax_writeback_mapping_range(struct address_space *mapping,
 
         tag_pages_for_writeback(mapping, start_index, end_index);
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
         while (!done) {
                 pvec.nr = find_get_entries_tag(mapping, start_index,
                                 PAGECACHE_TAG_TOWRITE, PAGEVEC_SIZE,
diff --git a/fs/dcache.c b/fs/dcache.c
index bcc9f6981569..5c7df1df81ff 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -2705,8 +2705,6 @@ static void swap_names(struct dentry *dentry, struct dentry *target)
                          */
                         unsigned int i;
                         BUILD_BUG_ON(!IS_ALIGNED(DNAME_INLINE_LEN, sizeof(long)));
-                        kmemcheck_mark_initialized(dentry->d_iname, DNAME_INLINE_LEN);
-                        kmemcheck_mark_initialized(target->d_iname, DNAME_INLINE_LEN);
                         for (i = 0; i < DNAME_INLINE_LEN / sizeof(long); i++) {
                                 swap(((long *) &dentry->d_iname)[i],
                                      ((long *) &target->d_iname)[i]);
diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index 6b801186baa5..25aeaa7328ba 100644
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -660,7 +660,7 @@ static struct ecryptfs_cache_info {
         struct kmem_cache **cache;
         const char *name;
         size_t size;
-        unsigned long flags;
+        slab_flags_t flags;
         void (*ctor)(void *obj);
 } ecryptfs_cache_infos[] = {
         {
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 2633150e41b9..8d2b582fb141 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -1719,7 +1719,7 @@ static void mpage_release_unused_pages(struct mpage_da_data *mpd,
                 ext4_es_remove_extent(inode, start, last - start + 1);
         }
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
         while (index <= end) {
                 nr_pages = pagevec_lookup_range(&pvec, mapping, &index, end);
                 if (nr_pages == 0)
@@ -2345,7 +2345,7 @@ static int mpage_map_and_submit_buffers(struct mpage_da_data *mpd)
         lblk = start << bpp_bits;
         pblock = mpd->map.m_pblk;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
         while (start <= end) {
                 nr_pages = pagevec_lookup_range(&pvec, inode->i_mapping,
                                                 &start, end);
@@ -2616,12 +2616,12 @@ static int mpage_prepare_extent_to_map(struct mpage_da_data *mpd)
         else
                 tag = PAGECACHE_TAG_DIRTY;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
         mpd->map.m_len = 0;
         mpd->next_page = index;
         while (index <= end) {
-                nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag,
-                              min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
+                nr_pages = pagevec_lookup_range_tag(&pvec, mapping, &index, end,
+                                tag);
                 if (nr_pages == 0)
                         goto out;
 
@@ -2629,16 +2629,6 @@ static int mpage_prepare_extent_to_map(struct mpage_da_data *mpd)
                         struct page *page = pvec.pages[i];
 
                         /*
-                         * At this point, the page may be truncated or
-                         * invalidated (changing page->mapping to NULL), or
-                         * even swizzled back from swapper_space to tmpfs file
-                         * mapping. However, page->index will not change
-                         * because we have a reference on the page.
-                         */
-                        if (page->index > end)
-                                goto out;
-
-                        /*
                          * Accumulated enough dirty pages? This doesn't apply
                          * to WB_SYNC_ALL mode. For integrity sync we have to
                          * keep going because someone may be concurrently
diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 04fe1df052b2..0bb8e2c022d3 100644
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -305,25 +305,22 @@ long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
                                 long nr_to_write, enum iostat_type io_type)
 {
         struct address_space *mapping = META_MAPPING(sbi);
-        pgoff_t index = 0, end = ULONG_MAX, prev = ULONG_MAX;
+        pgoff_t index = 0, prev = ULONG_MAX;
         struct pagevec pvec;
         long nwritten = 0;
+        int nr_pages;
         struct writeback_control wbc = {
                 .for_reclaim = 0,
         };
         struct blk_plug plug;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
 
         blk_start_plug(&plug);
 
-        while (index <= end) {
-                int i, nr_pages;
-                nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
-                                PAGECACHE_TAG_DIRTY,
-                                min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
-                if (unlikely(nr_pages == 0))
-                        break;
+        while ((nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
+                                PAGECACHE_TAG_DIRTY))) {
+                int i;
 
                 for (i = 0; i < nr_pages; i++) {
                         struct page *page = pvec.pages[i];
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 36b535207c88..7b3ad5d8e2e9 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1635,7 +1635,7 @@ static int f2fs_write_cache_pages(struct address_space *mapping,
         int range_whole = 0;
         int tag;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
 
         if (get_dirty_pages(mapping->host) <=
                                 SM_I(F2FS_M_SB(mapping))->min_hot_blocks)
@@ -1669,8 +1669,8 @@ retry:
         while (!done && (index <= end)) {
                 int i;
 
-                nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag,
-                              min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1);
+                nr_pages = pagevec_lookup_range_tag(&pvec, mapping, &index, end,
+                                tag);
                 if (nr_pages == 0)
                         break;
 
@@ -1678,11 +1678,6 @@ retry:
                         struct page *page = pvec.pages[i];
                         bool submitted = false;
 
-                        if (page->index > end) {
-                                done = 1;
-                                break;
-                        }
-
                         done_index = page->index;
 retry_write:
                         lock_page(page);
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 517e112c8a9a..f78b76ec4707 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -313,18 +313,19 @@ int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 static pgoff_t __get_first_dirty_index(struct address_space *mapping,
                                                 pgoff_t pgofs, int whence)
 {
-        struct pagevec pvec;
+        struct page *page;
         int nr_pages;
 
         if (whence != SEEK_DATA)
                 return 0;
 
         /* find first dirty page index */
-        pagevec_init(&pvec, 0);
-        nr_pages = pagevec_lookup_tag(&pvec, mapping, &pgofs,
-                                        PAGECACHE_TAG_DIRTY, 1);
-        pgofs = nr_pages ? pvec.pages[0]->index : ULONG_MAX;
-        pagevec_release(&pvec);
+        nr_pages = find_get_pages_tag(mapping, &pgofs, PAGECACHE_TAG_DIRTY,
+                                      1, &page);
+        if (!nr_pages)
+                return ULONG_MAX;
+        pgofs = page->index;
+        put_page(page);
         return pgofs;
 }
 
diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index fca87835a1da..b33dac9592ca 100644
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -1277,21 +1277,17 @@ release_page:
 
 static struct page *last_fsync_dnode(struct f2fs_sb_info *sbi, nid_t ino)
 {
-        pgoff_t index, end;
+        pgoff_t index;
         struct pagevec pvec;
         struct page *last_page = NULL;
+        int nr_pages;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
         index = 0;
-        end = ULONG_MAX;
-
-        while (index <= end) {
-                int i, nr_pages;
-                nr_pages = pagevec_lookup_tag(&pvec, NODE_MAPPING(sbi), &index,
-                                PAGECACHE_TAG_DIRTY,
-                                min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
-                if (nr_pages == 0)
-                        break;
+
+        while ((nr_pages = pagevec_lookup_tag(&pvec, NODE_MAPPING(sbi), &index,
+                                PAGECACHE_TAG_DIRTY))) {
+                int i;
 
                 for (i = 0; i < nr_pages; i++) {
                         struct page *page = pvec.pages[i];
@@ -1425,13 +1421,14 @@ static int f2fs_write_node_page(struct page *page,
 int fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,
                         struct writeback_control *wbc, bool atomic)
 {
-        pgoff_t index, end;
+        pgoff_t index;
         pgoff_t last_idx = ULONG_MAX;
         struct pagevec pvec;
         int ret = 0;
         struct page *last_page = NULL;
         bool marked = false;
         nid_t ino = inode->i_ino;
+        int nr_pages;
 
         if (atomic) {
                 last_page = last_fsync_dnode(sbi, ino);
@@ -1439,17 +1436,12 @@ int fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,
                         return PTR_ERR_OR_ZERO(last_page);
         }
 retry:
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
         index = 0;
-        end = ULONG_MAX;
-
-        while (index <= end) {
-                int i, nr_pages;
-                nr_pages = pagevec_lookup_tag(&pvec, NODE_MAPPING(sbi), &index,
-                                PAGECACHE_TAG_DIRTY,
-                                min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
-                if (nr_pages == 0)
-                        break;
+
+        while ((nr_pages = pagevec_lookup_tag(&pvec, NODE_MAPPING(sbi), &index,
+                                PAGECACHE_TAG_DIRTY))) {
+                int i;
 
                 for (i = 0; i < nr_pages; i++) {
                         struct page *page = pvec.pages[i];
@@ -1548,25 +1540,21 @@ out:
 int sync_node_pages(struct f2fs_sb_info *sbi, struct writeback_control *wbc,
                                 bool do_balance, enum iostat_type io_type)
 {
-        pgoff_t index, end;
+        pgoff_t index;
         struct pagevec pvec;
         int step = 0;
         int nwritten = 0;
         int ret = 0;
+        int nr_pages;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
 
 next_step:
         index = 0;
-        end = ULONG_MAX;
-
-        while (index <= end) {
-                int i, nr_pages;
-                nr_pages = pagevec_lookup_tag(&pvec, NODE_MAPPING(sbi), &index,
-                                PAGECACHE_TAG_DIRTY,
-                                min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
-                if (nr_pages == 0)
-                        break;
+
+        while ((nr_pages = pagevec_lookup_tag(&pvec, NODE_MAPPING(sbi), &index,
+                                PAGECACHE_TAG_DIRTY))) {
+                int i;
 
                 for (i = 0; i < nr_pages; i++) {
                         struct page *page = pvec.pages[i];
@@ -1655,27 +1643,20 @@ out:
 
 int wait_on_node_pages_writeback(struct f2fs_sb_info *sbi, nid_t ino)
 {
-        pgoff_t index = 0, end = ULONG_MAX;
+        pgoff_t index = 0;
         struct pagevec pvec;
         int ret2, ret = 0;
+        int nr_pages;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
 
-        while (index <= end) {
-                int i, nr_pages;
-                nr_pages = pagevec_lookup_tag(&pvec, NODE_MAPPING(sbi), &index,
-                                PAGECACHE_TAG_WRITEBACK,
-                                min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
-                if (nr_pages == 0)
-                        break;
+        while ((nr_pages = pagevec_lookup_tag(&pvec, NODE_MAPPING(sbi), &index,
+                                PAGECACHE_TAG_WRITEBACK))) {
+                int i;
 
                 for (i = 0; i < nr_pages; i++) {
                         struct page *page = pvec.pages[i];
 
-                        /* until radix tree lookup accepts end_index */
-                        if (unlikely(page->index > end))
-                                continue;
-
                         if (ino && ino_of_node(page) == ino) {
                                 f2fs_wait_on_page_writeback(page, NODE, true);
                                 if (TestClearPageError(page))
diff --git a/fs/file_table.c b/fs/file_table.c
index 49e1f2f1a4cb..2dc9f38bd195 100644
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -312,7 +312,7 @@ void put_filp(struct file *file)
 void __init files_init(void)
 {
         filp_cachep = kmem_cache_create("filp", sizeof(struct file), 0,
-                        SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
+                        SLAB_HWCACHE_ALIGN | SLAB_PANIC | SLAB_ACCOUNT, NULL);
         percpu_counter_init(&nr_files, 0, GFP_KERNEL);
 }
 
diff --git a/fs/fscache/page.c b/fs/fscache/page.c
index 0ad3fd3ad0b4..961029e04027 100644
--- a/fs/fscache/page.c
+++ b/fs/fscache/page.c
@@ -1175,7 +1175,7 @@ void __fscache_uncache_all_inode_pages(struct fscache_cookie *cookie,
                 return;
         }
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
         next = 0;
         do {
                 if (!pagevec_lookup(&pvec, mapping, &next))
diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index a42d89371748..17f0d05bfd4c 100644
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -1636,7 +1636,7 @@ out_finish:
 
 static void fuse_retrieve_end(struct fuse_conn *fc, struct fuse_req *req)
 {
-        release_pages(req->pages, req->num_pages, false);
+        release_pages(req->pages, req->num_pages);
 }
 
 static int fuse_retrieve(struct fuse_conn *fc, struct inode *inode,
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index a79e320349cd..2f504d615d92 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -1273,9 +1273,9 @@ static int __init fuse_fs_init(void)
         int err;
 
         fuse_inode_cachep = kmem_cache_create("fuse_inode",
-                                              sizeof(struct fuse_inode), 0,
-                                              SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT,
-                                              fuse_inode_init_once);
+                        sizeof(struct fuse_inode), 0,
+                        SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT|SLAB_RECLAIM_ACCOUNT,
+                        fuse_inode_init_once);
         err = -ENOMEM;
         if (!fuse_inode_cachep)
                 goto out;
diff --git a/fs/gfs2/aops.c b/fs/gfs2/aops.c
index 68ed06962537..1daf15a1f00c 100644
--- a/fs/gfs2/aops.c
+++ b/fs/gfs2/aops.c
@@ -280,22 +280,6 @@ static int gfs2_write_jdata_pagevec(struct address_space *mapping,
         for(i = 0; i < nr_pages; i++) {
                 struct page *page = pvec->pages[i];
 
-                /*
-                 * At this point, the page may be truncated or
-                 * invalidated (changing page->mapping to NULL), or
-                 * even swizzled back from swapper_space to tmpfs file
-                 * mapping. However, page->index will not change
-                 * because we have a reference on the page.
-                 */
-                if (page->index > end) {
-                        /*
-                         * can't be range_cyclic (1st pass) because
-                         * end == -1 in that case.
-                         */
-                        ret = 1;
-                        break;
-                }
-
                 *done_index = page->index;
 
                 lock_page(page);
@@ -387,7 +371,7 @@ static int gfs2_write_cache_jdata(struct address_space *mapping,
         int range_whole = 0;
         int tag;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
         if (wbc->range_cyclic) {
                 writeback_index = mapping->writeback_index; /* prev offset */
                 index = writeback_index;
@@ -413,8 +397,8 @@ retry:
                 tag_pages_for_writeback(mapping, index, end);
         done_index = index;
         while (!done && (index <= end)) {
-                nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag,
-                              min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
+                nr_pages = pagevec_lookup_range_tag(&pvec, mapping, &index, end,
+                                tag);
                 if (nr_pages == 0)
                         break;
 
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index ed113ea17aff..1e76730aac0d 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -407,7 +407,7 @@ static void remove_inode_hugepages(struct inode *inode, loff_t lstart,
 
         memset(&pseudo_vma, 0, sizeof(struct vm_area_struct));
         pseudo_vma.vm_flags = (VM_HUGETLB | VM_MAYSHARE | VM_SHARED);
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
         next = start;
         while (next < end) {
                 /*
@@ -668,7 +668,6 @@ static int hugetlbfs_setattr(struct dentry *dentry, struct iattr *attr)
                 return error;
 
         if (ia_valid & ATTR_SIZE) {
-                error = -EINVAL;
                 if (attr->ia_size & ~huge_page_mask(h))
                         return -EINVAL;
                 error = hugetlb_vmtruncate(inode, attr->ia_size);
diff --git a/fs/nilfs2/btree.c b/fs/nilfs2/btree.c
index 06ffa135dfa6..16a7a67a11c9 100644
--- a/fs/nilfs2/btree.c
+++ b/fs/nilfs2/btree.c
@@ -2156,10 +2156,10 @@ static void nilfs_btree_lookup_dirty_buffers(struct nilfs_bmap *btree,
              level++)
                 INIT_LIST_HEAD(&lists[level]);
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
 
-        while (pagevec_lookup_tag(&pvec, btcache, &index, PAGECACHE_TAG_DIRTY,
-                                  PAGEVEC_SIZE)) {
+        while (pagevec_lookup_tag(&pvec, btcache, &index,
+                                        PAGECACHE_TAG_DIRTY)) {
                 for (i = 0; i < pagevec_count(&pvec); i++) {
                         bh = head = page_buffers(pvec.pages[i]);
                         do {
diff --git a/fs/nilfs2/page.c b/fs/nilfs2/page.c
index 8616c46d33da..68241512d7c1 100644
--- a/fs/nilfs2/page.c
+++ b/fs/nilfs2/page.c
@@ -255,10 +255,9 @@ int nilfs_copy_dirty_pages(struct address_space *dmap,
         pgoff_t index = 0;
         int err = 0;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
 repeat:
-        if (!pagevec_lookup_tag(&pvec, smap, &index, PAGECACHE_TAG_DIRTY,
-                                PAGEVEC_SIZE))
+        if (!pagevec_lookup_tag(&pvec, smap, &index, PAGECACHE_TAG_DIRTY))
                 return 0;
 
         for (i = 0; i < pagevec_count(&pvec); i++) {
@@ -310,7 +309,7 @@ void nilfs_copy_back_pages(struct address_space *dmap,
         pgoff_t index = 0;
         int err;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
 repeat:
         n = pagevec_lookup(&pvec, smap, &index);
         if (!n)
@@ -374,10 +373,10 @@ void nilfs_clear_dirty_pages(struct address_space *mapping, bool silent)
         unsigned int i;
         pgoff_t index = 0;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
 
-        while (pagevec_lookup_tag(&pvec, mapping, &index, PAGECACHE_TAG_DIRTY,
-                                  PAGEVEC_SIZE)) {
+        while (pagevec_lookup_tag(&pvec, mapping, &index,
+                                        PAGECACHE_TAG_DIRTY)) {
                 for (i = 0; i < pagevec_count(&pvec); i++) {
                         struct page *page = pvec.pages[i];
 
@@ -519,7 +518,7 @@ unsigned long nilfs_find_uncommitted_extent(struct inode *inode,
         index = start_blk >> (PAGE_SHIFT - inode->i_blkbits);
         nblocks_in_page = 1U << (PAGE_SHIFT - inode->i_blkbits);
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
 
 repeat:
         pvec.nr = find_get_pages_contig(inode->i_mapping, index, PAGEVEC_SIZE,
diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c
index 70ded52dc1dd..f65392fecb5c 100644
--- a/fs/nilfs2/segment.c
+++ b/fs/nilfs2/segment.c
@@ -708,21 +708,17 @@ static size_t nilfs_lookup_dirty_data_buffers(struct inode *inode,
                 index = start >> PAGE_SHIFT;
                 last = end >> PAGE_SHIFT;
         }
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
  repeat:
         if (unlikely(index > last) ||
-            !pagevec_lookup_tag(&pvec, mapping, &index, PAGECACHE_TAG_DIRTY,
-                                min_t(pgoff_t, last - index,
-                                      PAGEVEC_SIZE - 1) + 1))
+            !pagevec_lookup_range_tag(&pvec, mapping, &index, last,
+                                PAGECACHE_TAG_DIRTY))
                 return ndirties;
 
         for (i = 0; i < pagevec_count(&pvec); i++) {
                 struct buffer_head *bh, *head;
                 struct page *page = pvec.pages[i];
 
-                if (unlikely(page->index > last))
-                        break;
-
                 lock_page(page);
                 if (!page_has_buffers(page))
                         create_empty_buffers(page, i_blocksize(inode), 0);
@@ -757,10 +753,10 @@ static void nilfs_lookup_dirty_node_buffers(struct inode *inode,
         unsigned int i;
         pgoff_t index = 0;
 
-        pagevec_init(&pvec, 0);
+        pagevec_init(&pvec);
 
-        while (pagevec_lookup_tag(&pvec, mapping, &index, PAGECACHE_TAG_DIRTY,
-                                  PAGEVEC_SIZE)) {
+        while (pagevec_lookup_tag(&pvec, mapping, &index,
+                                        PAGECACHE_TAG_DIRTY)) {
                 for (i = 0; i < pagevec_count(&pvec); i++) {
                         bh = head = page_buffers(pvec.pages[i]);
                         do {
diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
index addd7c5f2d3e..ab5105f9767e 100644
--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -3585,8 +3585,6 @@ static int ocfs2_merge_rec_left(struct ocfs2_path *right_path,
                  * The easy case - we can just plop the record right in.
                  */
                 *left_rec = *split_rec;
-
-                has_empty_extent = 0;
         } else
                 le16_add_cpu(&left_rec->e_leaf_clusters, split_clusters);
 
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 88a31e9340a0..d1516327b787 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -134,6 +134,19 @@ bail:
         return err;
 }
 
+static int ocfs2_lock_get_block(struct inode *inode, sector_t iblock,
+                    struct buffer_head *bh_result, int create)
+{
+        int ret = 0;
+        struct ocfs2_inode_info *oi = OCFS2_I(inode);
+
+        down_read(&oi->ip_alloc_sem);
+        ret = ocfs2_get_block(inode, iblock, bh_result, create);
+        up_read(&oi->ip_alloc_sem);
+
+        return ret;
+}
+
 int ocfs2_get_block(struct inode *inode, sector_t iblock,
                     struct buffer_head *bh_result, int create)
 {
@@ -2128,7 +2141,7 @@ static void ocfs2_dio_free_write_ctx(struct inode *inode,
  * called like this: dio->get_blocks(dio->inode, fs_startblk,
  *                                      fs_count, map_bh, dio->rw == WRITE);
  */
-static int ocfs2_dio_get_block(struct inode *inode, sector_t iblock,
+static int ocfs2_dio_wr_get_block(struct inode *inode, sector_t iblock,
                                struct buffer_head *bh_result, int create)
 {
         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
@@ -2154,12 +2167,9 @@ static int ocfs2_dio_get_block(struct inode *inode, sector_t iblock,
          * while file size will be changed.
          */
         if (pos + total_len <= i_size_read(inode)) {
-                down_read(&oi->ip_alloc_sem);
-                /* This is the fast path for re-write. */
-                ret = ocfs2_get_block(inode, iblock, bh_result, create);
-
-                up_read(&oi->ip_alloc_sem);
 
+                /* This is the fast path for re-write. */
+                ret = ocfs2_lock_get_block(inode, iblock, bh_result, create);
                 if (buffer_mapped(bh_result) &&
                     !buffer_new(bh_result) &&
                     ret == 0)
@@ -2424,9 +2434,9 @@ static ssize_t ocfs2_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
                 return 0;
 
         if (iov_iter_rw(iter) == READ)
-                get_block = ocfs2_get_block;
+                get_block = ocfs2_lock_get_block;
         else
-                get_block = ocfs2_dio_get_block;
+                get_block = ocfs2_dio_wr_get_block;
 
         return __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev,
                                     iter, get_block,
diff --git a/fs/ocfs2/buffer_head_io.h b/fs/ocfs2/buffer_head_io.h
index b97bcc6dde7c..b1bb70c8ca4d 100644
--- a/fs/ocfs2/buffer_head_io.h
+++ b/fs/ocfs2/buffer_head_io.h
@@ -28,9 +28,6 @@
 
 #include <linux/buffer_head.h>
 
-void ocfs2_end_buffer_io_sync(struct buffer_head *bh,
-                             int uptodate);
-
 int ocfs2_write_block(struct ocfs2_super          *osb,
                       struct buffer_head  *bh,
                       struct ocfs2_caching_info   *ci);
diff --git a/fs/ocfs2/cluster/heartbeat.h b/fs/ocfs2/cluster/heartbeat.h
index 3ef5137dc362..a9e67efc0004 100644
--- a/fs/ocfs2/cluster/heartbeat.h
+++ b/fs/ocfs2/cluster/heartbeat.h
@@ -79,10 +79,8 @@ void o2hb_fill_node_map(unsigned long *map,
                         unsigned bytes);
 void o2hb_exit(void);
 int o2hb_init(void);
-int o2hb_check_node_heartbeating(u8 node_num);
 int o2hb_check_node_heartbeating_no_sem(u8 node_num);
 int o2hb_check_node_heartbeating_from_callback(u8 node_num);
-int o2hb_check_local_node_heartbeating(void);
 void o2hb_stop_all_regions(void);
 int o2hb_get_all_regions(char *region_uuids, u8 numregions);
 int o2hb_global_heartbeat_active(void);
diff --git a/fs/ocfs2/cluster/nodemanager.c b/fs/ocfs2/cluster/nodemanager.c
index a51200ece93d..da64c3a20eeb 100644
--- a/fs/ocfs2/cluster/nodemanager.c
+++ b/fs/ocfs2/cluster/nodemanager.c
@@ -40,6 +40,9 @@ char *o2nm_fence_method_desc[O2NM_FENCE_METHODS] = {
                 "panic",        /* O2NM_FENCE_PANIC */
 };
 
+static inline void o2nm_lock_subsystem(void);
+static inline void o2nm_unlock_subsystem(void);
+
 struct o2nm_node *o2nm_get_node_by_num(u8 node_num)
 {
         struct o2nm_node *node = NULL;
@@ -181,7 +184,10 @@ static struct o2nm_cluster *to_o2nm_cluster_from_node(struct o2nm_node *node)
 {
         /* through the first node_set .parent
          * mycluster/nodes/mynode == o2nm_cluster->o2nm_node_group->o2nm_node */
-        return to_o2nm_cluster(node->nd_item.ci_parent->ci_parent);
+        if (node->nd_item.ci_parent)
+                return to_o2nm_cluster(node->nd_item.ci_parent->ci_parent);
+        else
+                return NULL;
 }
 
 enum {
@@ -194,7 +200,7 @@ static ssize_t o2nm_node_num_store(struct config_item *item, const char *page,
                                    size_t count)
 {
         struct o2nm_node *node = to_o2nm_node(item);
-        struct o2nm_cluster *cluster = to_o2nm_cluster_from_node(node);
+        struct o2nm_cluster *cluster;
         unsigned long tmp;
         char *p = (char *)page;
         int ret = 0;
@@ -214,6 +220,13 @@ static ssize_t o2nm_node_num_store(struct config_item *item, const char *page,
             !test_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes))
                 return -EINVAL; /* XXX */
 
+        o2nm_lock_subsystem();
+        cluster = to_o2nm_cluster_from_node(node);
+        if (!cluster) {
+                o2nm_unlock_subsystem();
+                return -EINVAL;
+        }
+
         write_lock(&cluster->cl_nodes_lock);
         if (cluster->cl_nodes[tmp])
                 ret = -EEXIST;
@@ -226,6 +239,8 @@ static ssize_t o2nm_node_num_store(struct config_item *item, const char *page,
                 set_bit(tmp, cluster->cl_nodes_bitmap);
         }
         write_unlock(&cluster->cl_nodes_lock);
+        o2nm_unlock_subsystem();
+
         if (ret)
                 return ret;
 
@@ -269,7 +284,7 @@ static ssize_t o2nm_node_ipv4_address_store(struct config_item *item,
                                             size_t count)
 {
         struct o2nm_node *node = to_o2nm_node(item);
-        struct o2nm_cluster *cluster = to_o2nm_cluster_from_node(node);
+        struct o2nm_cluster *cluster;
         int ret, i;
         struct rb_node **p, *parent;
         unsigned int octets[4];
@@ -286,6 +301,13 @@ static ssize_t o2nm_node_ipv4_address_store(struct config_item *item,
                 be32_add_cpu(&ipv4_addr, octets[i] << (i * 8));
         }
 
+        o2nm_lock_subsystem();
+        cluster = to_o2nm_cluster_from_node(node);
+        if (!cluster) {
+                o2nm_unlock_subsystem();
+                return -EINVAL;
+        }
+
         ret = 0;
         write_lock(&cluster->cl_nodes_lock);
         if (o2nm_node_ip_tree_lookup(cluster, ipv4_addr, &p, &parent))
@@ -298,6 +320,8 @@ static ssize_t o2nm_node_ipv4_address_store(struct config_item *item,
                 rb_insert_color(&node->nd_ip_node, &cluster->cl_node_ip_tree);
         }
         write_unlock(&cluster->cl_nodes_lock);
+        o2nm_unlock_subsystem();
+
         if (ret)
                 return ret;
 
@@ -315,7 +339,7 @@ static ssize_t o2nm_node_local_store(struct config_item *item, const char *page,
                                      size_t count)
 {
         struct o2nm_node *node = to_o2nm_node(item);
-        struct o2nm_cluster *cluster = to_o2nm_cluster_from_node(node);
+        struct o2nm_cluster *cluster;
         unsigned long tmp;
         char *p = (char *)page;
         ssize_t ret;
@@ -333,17 +357,26 @@ static ssize_t o2nm_node_local_store(struct config_item *item, const char *page,
             !test_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes))
                 return -EINVAL; /* XXX */
 
+        o2nm_lock_subsystem();
+        cluster = to_o2nm_cluster_from_node(node);
+        if (!cluster) {
+                ret = -EINVAL;
+                goto out;
+        }
+
         /* the only failure case is trying to set a new local node
          * when a different one is already set */
         if (tmp && tmp == cluster->cl_has_local &&
-            cluster->cl_local_node != node->nd_num)
-                return -EBUSY;
+            cluster->cl_local_node != node->nd_num) {
+                ret = -EBUSY;
+                goto out;
+        }
 
         /* bring up the rx thread if we're setting the new local node. */
         if (tmp && !cluster->cl_has_local) {
                 ret = o2net_start_listening(node);
                 if (ret)
-                        return ret;
+                        goto out;
         }
 
         if (!tmp && cluster->cl_has_local &&
@@ -358,7 +391,11 @@ static ssize_t o2nm_node_local_store(struct config_item *item, const char *page,
                 cluster->cl_local_node = node->nd_num;
         }
 
-        return count;
+        ret = count;
+
+out:
+        o2nm_unlock_subsystem();
+        return ret;
 }
 
 CONFIGFS_ATTR(o2nm_node_, num);
@@ -738,6 +775,16 @@ static struct o2nm_cluster_group o2nm_cluster_group = {
         },
 };
 
+static inline void o2nm_lock_subsystem(void)
+{
+        mutex_lock(&o2nm_cluster_group.cs_subsys.su_mutex);
+}
+
+static inline void o2nm_unlock_subsystem(void)
+{
+        mutex_unlock(&o2nm_cluster_group.cs_subsys.su_mutex);
+}
+
 int o2nm_depend_item(struct config_item *item)
 {
         return configfs_depend_item(&o2nm_cluster_group.cs_subsys, item);
diff --git a/fs/ocfs2/dlm/dlmdomain.c b/fs/ocfs2/dlm/dlmdomain.c
index a2b19fbdcf46..e1fea149f50b 100644
--- a/fs/ocfs2/dlm/dlmdomain.c
+++ b/fs/ocfs2/dlm/dlmdomain.c
@@ -394,7 +394,6 @@ int dlm_domain_fully_joined(struct dlm_ctxt *dlm)
 static void dlm_destroy_dlm_worker(struct dlm_ctxt *dlm)
 {
         if (dlm->dlm_worker) {
-                flush_workqueue(dlm->dlm_worker);
                 destroy_workqueue(dlm->dlm_worker);
                 dlm->dlm_worker = NULL;
         }
diff --git a/fs/ocfs2/dlm/dlmmaster.c b/fs/ocfs2/dlm/dlmmaster.c
index 3e04279446e8..9c3e0f13ca87 100644
--- a/fs/ocfs2/dlm/dlmmaster.c
+++ b/fs/ocfs2/dlm/dlmmaster.c
@@ -2616,7 +2616,9 @@ static int dlm_migrate_lockres(struct dlm_ctxt *dlm,
          * otherwise the assert_master from the new
          * master will destroy this.
          */
-        dlm_get_mle_inuse(mle);
+        if (ret != -EEXIST)
+                dlm_get_mle_inuse(mle);
+
         spin_unlock(&dlm->master_lock);
         spin_unlock(&dlm->spinlock);
 
diff --git a/fs/ocfs2/dlm/dlmrecovery.c b/fs/ocfs2/dlm/dlmrecovery.c
index 74407c6dd592..ec8f75813beb 100644
--- a/fs/ocfs2/dlm/dlmrecovery.c
+++ b/fs/ocfs2/dlm/dlmrecovery.c
@@ -2419,6 +2419,7 @@ static void dlm_do_local_recovery_cleanup(struct dlm_ctxt *dlm, u8 dead_node)
                                         dlm_lockres_put(res);
                                         continue;
                                 }
+                                dlm_move_lockres_to_recovery_list(dlm, res);
                         } else if (res->owner == dlm->node_num) {
                                 dlm_free_dead_locks(dlm, res, dead_node);
                                 __dlm_lockres_calc_usage(dlm, res);
diff --git a/fs/ocfs2/dlmfs/dlmfs.c b/fs/ocfs2/dlmfs/dlmfs.c
index 988137de08f5..9c7c18c0e129 100644
--- a/fs/ocfs2/dlmfs/dlmfs.c
+++ b/fs/ocfs2/dlmfs/dlmfs.c
@@ -670,7 +670,6 @@ static void __exit exit_dlmfs_fs(void)
 {
         unregister_filesystem(&dlmfs_fs_type);
 
-        flush_workqueue(user_dlm_worker);
         destroy_workqueue(user_dlm_worker);
 
         /*
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 6e41fc8fabbe..dc455d45a66a 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -1161,6 +1161,13 @@ int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
         }
         size_change = S_ISREG(inode->i_mode) && attr->ia_valid & ATTR_SIZE;
         if (size_change) {
+                /*
+                 * Here we should wait dio to finish before inode lock
+                 * to avoid a deadlock between ocfs2_setattr() and
+                 * ocfs2_dio_end_io_write()
+                 */
+                inode_dio_wait(inode);
+
                 status = ocfs2_rw_lock(inode, 1);
                 if (status < 0) {
                         mlog_errno(status);
@@ -1200,8 +1207,6 @@ int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
                 if (status)
                         goto bail_unlock;
 
-                inode_dio_wait(inode);
-
                 if (i_size_read(inode) >= attr->ia_size) {
                         if (ocfs2_should_order_data(inode)) {
                                 status = ocfs2_begin_ordered_truncate(inode,
diff --git a/fs/ocfs2/suballoc.c b/fs/ocfs2/suballoc.c
index 71f22c8fbffd..9f0b95abc09f 100644
--- a/fs/ocfs2/suballoc.c
+++ b/fs/ocfs2/suballoc.c
@@ -1147,12 +1147,9 @@ int ocfs2_reserve_cluster_bitmap_bits(struct ocfs2_super *osb,
                                              GLOBAL_BITMAP_SYSTEM_INODE,
                                              OCFS2_INVALID_SLOT, NULL,
                                              ALLOC_NEW_GROUP);
-        if (status < 0 && status != -ENOSPC) {
+        if (status < 0 && status != -ENOSPC)
                 mlog_errno(status);
-                goto bail;
-        }
 
-bail:
         return status;
 }
 
diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index 80733496b22a..040bbb6a6e4b 100644
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -2521,10 +2521,8 @@ static void ocfs2_delete_osb(struct ocfs2_super *osb)
         /* This function assumes that the caller has the main osb resource */
 
         /* ocfs2_initializer_super have already created this workqueue */
-        if (osb->ocfs2_wq) {
-                flush_workqueue(osb->ocfs2_wq);
+        if (osb->ocfs2_wq)
                 destroy_workqueue(osb->ocfs2_wq);
-        }
 
         ocfs2_free_slot_info(osb);
 
diff --git a/fs/ocfs2/super.h b/fs/ocfs2/super.h
index b023e4f3d740..d4550c8bbc41 100644
--- a/fs/ocfs2/super.h
+++ b/fs/ocfs2/super.h
@@ -26,9 +26,6 @@
 #ifndef OCFS2_SUPER_H
 #define OCFS2_SUPER_H
 
-int ocfs2_publish_get_mount_state(struct ocfs2_super *osb,
-                                  int node_num);
-
 __printf(3, 4)
 int __ocfs2_error(struct super_block *sb, const char *function,
                    const char *fmt, ...);
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 6744bd706ecf..875231c36cb3 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -26,7 +26,7 @@
 
 void task_mem(struct seq_file *m, struct mm_struct *mm)
 {
-        unsigned long text, lib, swap, ptes, pmds, anon, file, shmem;
+        unsigned long text, lib, swap, anon, file, shmem;
         unsigned long hiwater_vm, total_vm, hiwater_rss, total_rss;
 
         anon = get_mm_counter(mm, MM_ANONPAGES);
@@ -50,8 +50,6 @@ void task_mem(struct seq_file *m, struct mm_struct *mm)
         text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK)) >> 10;
         lib = (mm->exec_vm << (PAGE_SHIFT-10)) - text;
         swap = get_mm_counter(mm, MM_SWAPENTS);
-        ptes = PTRS_PER_PTE * sizeof(pte_t) * atomic_long_read(&mm->nr_ptes);
-        pmds = PTRS_PER_PMD * sizeof(pmd_t) * mm_nr_pmds(mm);
         seq_printf(m,
                 "VmPeak:\t%8lu kB\n"
                 "VmSize:\t%8lu kB\n"
@@ -67,7 +65,6 @@ void task_mem(struct seq_file *m, struct mm_struct *mm)
                 "VmExe:\t%8lu kB\n"
                 "VmLib:\t%8lu kB\n"
                 "VmPTE:\t%8lu kB\n"
-                "VmPMD:\t%8lu kB\n"
                 "VmSwap:\t%8lu kB\n",
                 hiwater_vm << (PAGE_SHIFT-10),
                 total_vm << (PAGE_SHIFT-10),
@@ -80,8 +77,7 @@ void task_mem(struct seq_file *m, struct mm_struct *mm)
                 shmem << (PAGE_SHIFT-10),
                 mm->data_vm << (PAGE_SHIFT-10),
                 mm->stack_vm << (PAGE_SHIFT-10), text, lib,
-                ptes >> 10,
-                pmds >> 10,
+                mm_pgtables_bytes(mm) >> 10,
                 swap << (PAGE_SHIFT-10));
         hugetlb_report_usage(m, mm);
 }
diff --git a/fs/userfaultfd.c b/fs/userfaultfd.c
index f46d133c0949..ac9a4e65ca49 100644
--- a/fs/userfaultfd.c
+++ b/fs/userfaultfd.c
@@ -668,7 +668,7 @@ int dup_userfaultfd(struct vm_area_struct *vma, struct list_head *fcs)
                 ctx->features = octx->features;
                 ctx->released = false;
                 ctx->mm = vma->vm_mm;
-                atomic_inc(&ctx->mm->mm_count);
+                mmgrab(ctx->mm);
 
                 userfaultfd_ctx_get(octx);
                 fctx->orig = octx;
diff --git a/fs/xfs/kmem.h b/fs/xfs/kmem.h
index 758f37ac5ad3..4b87472f35bc 100644
--- a/fs/xfs/kmem.h
+++ b/fs/xfs/kmem.h
@@ -104,7 +104,7 @@ kmem_zone_init(int size, char *zone_name)
 }
 
 static inline kmem_zone_t *
-kmem_zone_init_flags(int size, char *zone_name, unsigned long flags,
+kmem_zone_init_flags(int size, char *zone_name, slab_flags_t flags,
                      void (*construct)(void *))
 {
         return kmem_cache_create(zone_name, size, 0, flags, construct);