Merge branch 'akpm' (patches from Andrew)

Merge more fixes from Andrew Morton:
 "17 fixes"

Mostly mm fixes and one ocfs2 locking fix.

* emailed patches from Andrew Morton <akpm@linux-foundation.org>:
  mm: memcontrol: fix network errors from failing __GFP_ATOMIC charges
  mm/memory_hotplug: fix updating the node span
  scripts/gdb: fix debugging modules compiled with hot/cold partitioning
  mm: slab: make page_cgroup_ino() to recognize non-compound slab pages properly
  MAINTAINERS: update information for "MEMORY MANAGEMENT"
  dump_stack: avoid the livelock of the dump_lock
  zswap: add Vitaly to the maintainers list
  mm/page_alloc.c: ratelimit allocation failure warnings more aggressively
  mm/khugepaged: fix might_sleep() warn with CONFIG_HIGHPTE=y
  mm, vmstat: reduce zone->lock holding time by /proc/pagetypeinfo
  mm, vmstat: hide /proc/pagetypeinfo from normal users
  mm/mmu_notifiers: use the right return code for WARN_ON
  ocfs2: protect extent tree in ocfs2_prepare_inode_for_write()
  mm: thp: handle page cache THP correctly in PageTransCompoundMap
  mm, meminit: recalculate pcpu batch and high limits after init completes
  mm/gup_benchmark: fix MAP_HUGETLB case
  mm: memcontrol: fix NULL-ptr deref in percpu stats flush

15 files changed, 188 insertions, 79 deletions

diff --git a/MAINTAINERS b/MAINTAINERS
index cba1095547fd..2a427d1e9f01 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -10519,8 +10519,12 @@ F:	mm/memblock.c
 F:      Documentation/core-api/boot-time-mm.rst
 
 MEMORY MANAGEMENT
+M:      Andrew Morton <akpm@linux-foundation.org>
 L:      linux-mm@kvack.org
 W:      http://www.linux-mm.org
+T:      quilt https://ozlabs.org/~akpm/mmotm/
+T:      quilt https://ozlabs.org/~akpm/mmots/
+T:      git git://github.com/hnaz/linux-mm.git
 S:      Maintained
 F:      include/linux/mm.h
 F:      include/linux/gfp.h
@@ -18034,6 +18038,7 @@ F:	Documentation/vm/zsmalloc.rst
 ZSWAP COMPRESSED SWAP CACHING
 M:      Seth Jennings <sjenning@redhat.com>
 M:      Dan Streetman <ddstreet@ieee.org>
+M:      Vitaly Wool <vitaly.wool@konsulko.com>
 L:      linux-mm@kvack.org
 S:      Maintained
 F:      mm/zswap.c
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 53939bf9d7d2..9876db52913a 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -2098,53 +2098,89 @@ static int ocfs2_is_io_unaligned(struct inode *inode, size_t count, loff_t pos)
         return 0;
 }
 
-static int ocfs2_prepare_inode_for_refcount(struct inode *inode,
-                                            struct file *file,
-                                            loff_t pos, size_t count,
-                                            int *meta_level)
+static int ocfs2_inode_lock_for_extent_tree(struct inode *inode,
+                                            struct buffer_head **di_bh,
+                                            int meta_level,
+                                            int overwrite_io,
+                                            int write_sem,
+                                            int wait)
 {
-        int ret;
-        struct buffer_head *di_bh = NULL;
-        u32 cpos = pos >> OCFS2_SB(inode->i_sb)->s_clustersize_bits;
-        u32 clusters =
-                ocfs2_clusters_for_bytes(inode->i_sb, pos + count) - cpos;
+        int ret = 0;
 
-        ret = ocfs2_inode_lock(inode, &di_bh, 1);
-        if (ret) {
-                mlog_errno(ret);
+        if (wait)
+                ret = ocfs2_inode_lock(inode, NULL, meta_level);
+        else
+                ret = ocfs2_try_inode_lock(inode,
+                        overwrite_io ? NULL : di_bh, meta_level);
+        if (ret < 0)
                 goto out;
+
+        if (wait) {
+                if (write_sem)
+                        down_write(&OCFS2_I(inode)->ip_alloc_sem);
+                else
+                        down_read(&OCFS2_I(inode)->ip_alloc_sem);
+        } else {
+                if (write_sem)
+                        ret = down_write_trylock(&OCFS2_I(inode)->ip_alloc_sem);
+                else
+                        ret = down_read_trylock(&OCFS2_I(inode)->ip_alloc_sem);
+
+                if (!ret) {
+                        ret = -EAGAIN;
+                        goto out_unlock;
+                }
         }
 
-        *meta_level = 1;
+        return ret;
 
-        ret = ocfs2_refcount_cow(inode, di_bh, cpos, clusters, UINT_MAX);
-        if (ret)
-                mlog_errno(ret);
+out_unlock:
+        brelse(*di_bh);
+        ocfs2_inode_unlock(inode, meta_level);
 out:
-        brelse(di_bh);
         return ret;
 }
 
+static void ocfs2_inode_unlock_for_extent_tree(struct inode *inode,
+                                               struct buffer_head **di_bh,
+                                               int meta_level,
+                                               int write_sem)
+{
+        if (write_sem)
+                up_write(&OCFS2_I(inode)->ip_alloc_sem);
+        else
+                up_read(&OCFS2_I(inode)->ip_alloc_sem);
+
+        brelse(*di_bh);
+        *di_bh = NULL;
+
+        if (meta_level >= 0)
+                ocfs2_inode_unlock(inode, meta_level);
+}
+
 static int ocfs2_prepare_inode_for_write(struct file *file,
                                          loff_t pos, size_t count, int wait)
 {
         int ret = 0, meta_level = 0, overwrite_io = 0;
+        int write_sem = 0;
         struct dentry *dentry = file->f_path.dentry;
         struct inode *inode = d_inode(dentry);
         struct buffer_head *di_bh = NULL;
+        u32 cpos;
+        u32 clusters;
 
         /*
          * We start with a read level meta lock and only jump to an ex
          * if we need to make modifications here.
          */
         for(;;) {
-                if (wait)
-                        ret = ocfs2_inode_lock(inode, NULL, meta_level);
-                else
-                        ret = ocfs2_try_inode_lock(inode,
-                                overwrite_io ? NULL : &di_bh, meta_level);
+                ret = ocfs2_inode_lock_for_extent_tree(inode,
+                                                       &di_bh,
+                                                       meta_level,
+                                                       overwrite_io,
+                                                       write_sem,
+                                                       wait);
                 if (ret < 0) {
-                        meta_level = -1;
                         if (ret != -EAGAIN)
                                 mlog_errno(ret);
                         goto out;
@@ -2156,15 +2192,8 @@ static int ocfs2_prepare_inode_for_write(struct file *file,
                  */
                 if (!wait && !overwrite_io) {
                         overwrite_io = 1;
-                        if (!down_read_trylock(&OCFS2_I(inode)->ip_alloc_sem)) {
-                                ret = -EAGAIN;
-                                goto out_unlock;
-                        }
 
                         ret = ocfs2_overwrite_io(inode, di_bh, pos, count);
-                        brelse(di_bh);
-                        di_bh = NULL;
-                        up_read(&OCFS2_I(inode)->ip_alloc_sem);
                         if (ret < 0) {
                                 if (ret != -EAGAIN)
                                         mlog_errno(ret);
@@ -2183,7 +2212,10 @@ static int ocfs2_prepare_inode_for_write(struct file *file,
                  * set inode->i_size at the end of a write. */
                 if (should_remove_suid(dentry)) {
                         if (meta_level == 0) {
-                                ocfs2_inode_unlock(inode, meta_level);
+                                ocfs2_inode_unlock_for_extent_tree(inode,
+                                                                   &di_bh,
+                                                                   meta_level,
+                                                                   write_sem);
                                 meta_level = 1;
                                 continue;
                         }
@@ -2197,18 +2229,32 @@ static int ocfs2_prepare_inode_for_write(struct file *file,
 
                 ret = ocfs2_check_range_for_refcount(inode, pos, count);
                 if (ret == 1) {
-                        ocfs2_inode_unlock(inode, meta_level);
-                        meta_level = -1;
-
-                        ret = ocfs2_prepare_inode_for_refcount(inode,
-                                                               file,
-                                                               pos,
-                                                               count,
-                                                               &meta_level);
+                        ocfs2_inode_unlock_for_extent_tree(inode,
+                                                           &di_bh,
+                                                           meta_level,
+                                                           write_sem);
+                        ret = ocfs2_inode_lock_for_extent_tree(inode,
+                                                               &di_bh,
+                                                               meta_level,
+                                                               overwrite_io,
+                                                               1,
+                                                               wait);
+                        write_sem = 1;
+                        if (ret < 0) {
+                                if (ret != -EAGAIN)
+                                        mlog_errno(ret);
+                                goto out;
+                        }
+
+                        cpos = pos >> OCFS2_SB(inode->i_sb)->s_clustersize_bits;
+                        clusters =
+                                ocfs2_clusters_for_bytes(inode->i_sb, pos + count) - cpos;
+                        ret = ocfs2_refcount_cow(inode, di_bh, cpos, clusters, UINT_MAX);
                 }
 
                 if (ret < 0) {
-                        mlog_errno(ret);
+                        if (ret != -EAGAIN)
+                                mlog_errno(ret);
                         goto out_unlock;
                 }
 
@@ -2219,10 +2265,10 @@ out_unlock:
         trace_ocfs2_prepare_inode_for_write(OCFS2_I(inode)->ip_blkno,
                                             pos, count, wait);
 
-        brelse(di_bh);
-
-        if (meta_level >= 0)
-                ocfs2_inode_unlock(inode, meta_level);
+        ocfs2_inode_unlock_for_extent_tree(inode,
+                                           &di_bh,
+                                           meta_level,
+                                           write_sem);
 
 out:
         return ret;
diff --git a/include/linux/mm.h b/include/linux/mm.h
index cc292273e6ba..a2adf95b3f9c 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -695,11 +695,6 @@ static inline void *kvcalloc(size_t n, size_t size, gfp_t flags)
 
 extern void kvfree(const void *addr);
 
-static inline atomic_t *compound_mapcount_ptr(struct page *page)
-{
-        return &page[1].compound_mapcount;
-}
-
 static inline int compound_mapcount(struct page *page)
 {
         VM_BUG_ON_PAGE(!PageCompound(page), page);
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 2222fa795284..270aa8fd2800 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -221,6 +221,11 @@ struct page {
 #endif
 } _struct_page_alignment;
 
+static inline atomic_t *compound_mapcount_ptr(struct page *page)
+{
+        return &page[1].compound_mapcount;
+}
+
 /*
  * Used for sizing the vmemmap region on some architectures
  */
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index f91cb8898ff0..1bf83c8fcaa7 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -622,12 +622,28 @@ static inline int PageTransCompound(struct page *page)
  *
  * Unlike PageTransCompound, this is safe to be called only while
  * split_huge_pmd() cannot run from under us, like if protected by the
- * MMU notifier, otherwise it may result in page->_mapcount < 0 false
+ * MMU notifier, otherwise it may result in page->_mapcount check false
  * positives.
+ *
+ * We have to treat page cache THP differently since every subpage of it
+ * would get _mapcount inc'ed once it is PMD mapped.  But, it may be PTE
+ * mapped in the current process so comparing subpage's _mapcount to
+ * compound_mapcount to filter out PTE mapped case.
  */
 static inline int PageTransCompoundMap(struct page *page)
 {
-        return PageTransCompound(page) && atomic_read(&page->_mapcount) < 0;
+        struct page *head;
+
+        if (!PageTransCompound(page))
+                return 0;
+
+        if (PageAnon(page))
+                return atomic_read(&page->_mapcount) < 0;
+
+        head = compound_head(page);
+        /* File THP is PMD mapped and not PTE mapped */
+        return atomic_read(&page->_mapcount) ==
+               atomic_read(compound_mapcount_ptr(head));
 }
 
 /*
diff --git a/lib/dump_stack.c b/lib/dump_stack.c
index 5cff72f18c4a..33ffbf308853 100644
--- a/lib/dump_stack.c
+++ b/lib/dump_stack.c
@@ -106,7 +106,12 @@ retry:
                 was_locked = 1;
         } else {
                 local_irq_restore(flags);
-                cpu_relax();
+                /*
+                 * Wait for the lock to release before jumping to
+                 * atomic_cmpxchg() in order to mitigate the thundering herd
+                 * problem.
+                 */
+                do { cpu_relax(); } while (atomic_read(&dump_lock) != -1);
                 goto retry;
         }
 
diff --git a/mm/khugepaged.c b/mm/khugepaged.c
index 0a1b4b484ac5..f05d27b7183d 100644
--- a/mm/khugepaged.c
+++ b/mm/khugepaged.c
@@ -1028,12 +1028,13 @@ static void collapse_huge_page(struct mm_struct *mm,
 
         anon_vma_lock_write(vma->anon_vma);
 
-        pte = pte_offset_map(pmd, address);
-        pte_ptl = pte_lockptr(mm, pmd);
-
         mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, NULL, mm,
                                 address, address + HPAGE_PMD_SIZE);
         mmu_notifier_invalidate_range_start(&range);
+
+        pte = pte_offset_map(pmd, address);
+        pte_ptl = pte_lockptr(mm, pmd);
+
         pmd_ptl = pmd_lock(mm, pmd); /* probably unnecessary */
         /*
          * After this gup_fast can't run anymore. This also removes
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 363106578876..37592dd7ae32 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -484,7 +484,7 @@ ino_t page_cgroup_ino(struct page *page)
         unsigned long ino = 0;
 
         rcu_read_lock();
-        if (PageHead(page) && PageSlab(page))
+        if (PageSlab(page) && !PageTail(page))
                 memcg = memcg_from_slab_page(page);
         else
                 memcg = READ_ONCE(page->mem_cgroup);
@@ -2535,6 +2535,15 @@ retry:
         }
 
         /*
+         * Memcg doesn't have a dedicated reserve for atomic
+         * allocations. But like the global atomic pool, we need to
+         * put the burden of reclaim on regular allocation requests
+         * and let these go through as privileged allocations.
+         */
+        if (gfp_mask & __GFP_ATOMIC)
+                goto force;
+
+        /*
          * Unlike in global OOM situations, memcg is not in a physical
          * memory shortage.  Allow dying and OOM-killed tasks to
          * bypass the last charges so that they can exit quickly and
@@ -5014,12 +5023,6 @@ static void __mem_cgroup_free(struct mem_cgroup *memcg)
 {
         int node;
 
-        /*
-         * Flush percpu vmstats and vmevents to guarantee the value correctness
-         * on parent's and all ancestor levels.
-         */
-        memcg_flush_percpu_vmstats(memcg, false);
-        memcg_flush_percpu_vmevents(memcg);
         for_each_node(node)
                 free_mem_cgroup_per_node_info(memcg, node);
         free_percpu(memcg->vmstats_percpu);
@@ -5030,6 +5033,12 @@ static void __mem_cgroup_free(struct mem_cgroup *memcg)
 static void mem_cgroup_free(struct mem_cgroup *memcg)
 {
         memcg_wb_domain_exit(memcg);
+        /*
+         * Flush percpu vmstats and vmevents to guarantee the value correctness
+         * on parent's and all ancestor levels.
+         */
+        memcg_flush_percpu_vmstats(memcg, false);
+        memcg_flush_percpu_vmevents(memcg);
         __mem_cgroup_free(memcg);
 }
 
diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index df570e5c71cc..07e5c67f48a8 100644
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -447,6 +447,14 @@ static void update_pgdat_span(struct pglist_data *pgdat)
                                              zone->spanned_pages;
 
                 /* No need to lock the zones, they can't change. */
+                if (!zone->spanned_pages)
+                        continue;
+                if (!node_end_pfn) {
+                        node_start_pfn = zone->zone_start_pfn;
+                        node_end_pfn = zone_end_pfn;
+                        continue;
+                }
+
                 if (zone_end_pfn > node_end_pfn)
                         node_end_pfn = zone_end_pfn;
                 if (zone->zone_start_pfn < node_start_pfn)
diff --git a/mm/mmu_notifier.c b/mm/mmu_notifier.c
index 7fde88695f35..9a889e456168 100644
--- a/mm/mmu_notifier.c
+++ b/mm/mmu_notifier.c
@@ -180,7 +180,7 @@ int __mmu_notifier_invalidate_range_start(struct mmu_notifier_range *range)
                                         mn->ops->invalidate_range_start, _ret,
                                         !mmu_notifier_range_blockable(range) ? "non-" : "");
                                 WARN_ON(mmu_notifier_range_blockable(range) ||
-                                        ret != -EAGAIN);
+                                        _ret != -EAGAIN);
                                 ret = _ret;
                         }
                 }
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index ecc3dbad606b..f391c0c4ed1d 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1948,6 +1948,14 @@ void __init page_alloc_init_late(void)
         wait_for_completion(&pgdat_init_all_done_comp);
 
         /*
+         * The number of managed pages has changed due to the initialisation
+         * so the pcpu batch and high limits needs to be updated or the limits
+         * will be artificially small.
+         */
+        for_each_populated_zone(zone)
+                zone_pcp_update(zone);
+
+        /*
          * We initialized the rest of the deferred pages.  Permanently disable
          * on-demand struct page initialization.
          */
@@ -3720,10 +3728,6 @@ try_this_zone:
 static void warn_alloc_show_mem(gfp_t gfp_mask, nodemask_t *nodemask)
 {
         unsigned int filter = SHOW_MEM_FILTER_NODES;
-        static DEFINE_RATELIMIT_STATE(show_mem_rs, HZ, 1);
-
-        if (!__ratelimit(&show_mem_rs))
-                return;
 
         /*
          * This documents exceptions given to allocations in certain
@@ -3744,8 +3748,7 @@ void warn_alloc(gfp_t gfp_mask, nodemask_t *nodemask, const char *fmt, ...)
 {
         struct va_format vaf;
         va_list args;
-        static DEFINE_RATELIMIT_STATE(nopage_rs, DEFAULT_RATELIMIT_INTERVAL,
-                                      DEFAULT_RATELIMIT_BURST);
+        static DEFINE_RATELIMIT_STATE(nopage_rs, 10*HZ, 1);
 
         if ((gfp_mask & __GFP_NOWARN) || !__ratelimit(&nopage_rs))
                 return;
@@ -8514,7 +8517,6 @@ void free_contig_range(unsigned long pfn, unsigned int nr_pages)
         WARN(count != 0, "%d pages are still in use!\n", count);
 }
 
-#ifdef CONFIG_MEMORY_HOTPLUG
 /*
  * The zone indicated has a new number of managed_pages; batch sizes and percpu
  * page high values need to be recalulated.
@@ -8528,7 +8530,6 @@ void __meminit zone_pcp_update(struct zone *zone)
                                 per_cpu_ptr(zone->pageset, cpu));
         mutex_unlock(&pcp_batch_high_lock);
 }
-#endif
 
 void zone_pcp_reset(struct zone *zone)
 {
diff --git a/mm/slab.h b/mm/slab.h
index 68e455f2b698..b2b01694dc43 100644
--- a/mm/slab.h
+++ b/mm/slab.h
@@ -323,8 +323,8 @@ static inline struct kmem_cache *memcg_root_cache(struct kmem_cache *s)
  * Expects a pointer to a slab page. Please note, that PageSlab() check
  * isn't sufficient, as it returns true also for tail compound slab pages,
  * which do not have slab_cache pointer set.
- * So this function assumes that the page can pass PageHead() and PageSlab()
- * checks.
+ * So this function assumes that the page can pass PageSlab() && !PageTail()
+ * check.
  *
  * The kmem_cache can be reparented asynchronously. The caller must ensure
  * the memcg lifetime, e.g. by taking rcu_read_lock() or cgroup_mutex.
diff --git a/mm/vmstat.c b/mm/vmstat.c
index 6afc892a148a..a8222041bd44 100644
--- a/mm/vmstat.c
+++ b/mm/vmstat.c
@@ -1383,12 +1383,29 @@ static void pagetypeinfo_showfree_print(struct seq_file *m,
                         unsigned long freecount = 0;
                         struct free_area *area;
                         struct list_head *curr;
+                        bool overflow = false;
 
                         area = &(zone->free_area[order]);
 
-                        list_for_each(curr, &area->free_list[mtype])
-                                freecount++;
-                        seq_printf(m, "%6lu ", freecount);
+                        list_for_each(curr, &area->free_list[mtype]) {
+                                /*
+                                 * Cap the free_list iteration because it might
+                                 * be really large and we are under a spinlock
+                                 * so a long time spent here could trigger a
+                                 * hard lockup detector. Anyway this is a
+                                 * debugging tool so knowing there is a handful
+                                 * of pages of this order should be more than
+                                 * sufficient.
+                                 */
+                                if (++freecount >= 100000) {
+                                        overflow = true;
+                                        break;
+                                }
+                        }
+                        seq_printf(m, "%s%6lu ", overflow ? ">" : "", freecount);
+                        spin_unlock_irq(&zone->lock);
+                        cond_resched();
+                        spin_lock_irq(&zone->lock);
                 }
                 seq_putc(m, '\n');
         }
@@ -1972,7 +1989,7 @@ void __init init_mm_internals(void)
 #endif
 #ifdef CONFIG_PROC_FS
         proc_create_seq("buddyinfo", 0444, NULL, &fragmentation_op);
-        proc_create_seq("pagetypeinfo", 0444, NULL, &pagetypeinfo_op);
+        proc_create_seq("pagetypeinfo", 0400, NULL, &pagetypeinfo_op);
         proc_create_seq("vmstat", 0444, NULL, &vmstat_op);
         proc_create_seq("zoneinfo", 0444, NULL, &zoneinfo_op);
 #endif
diff --git a/scripts/gdb/linux/symbols.py b/scripts/gdb/linux/symbols.py
index 7b7c2fafbc68..be984aa29b75 100644
--- a/scripts/gdb/linux/symbols.py
+++ b/scripts/gdb/linux/symbols.py
@@ -99,7 +99,8 @@ lx-symbols command."""
             attrs[n]['name'].string(): attrs[n]['address']
             for n in range(int(sect_attrs['nsections']))}
         args = []
-        for section_name in [".data", ".data..read_mostly", ".rodata", ".bss"]:
+        for section_name in [".data", ".data..read_mostly", ".rodata", ".bss",
+                             ".text", ".text.hot", ".text.unlikely"]:
             address = section_name_to_address.get(section_name)
             if address:
                 args.append(" -s {name} {addr}".format(
diff --git a/tools/testing/selftests/vm/gup_benchmark.c b/tools/testing/selftests/vm/gup_benchmark.c
index cb3fc09645c4..485cf06ef013 100644
--- a/tools/testing/selftests/vm/gup_benchmark.c
+++ b/tools/testing/selftests/vm/gup_benchmark.c
@@ -71,7 +71,7 @@ int main(int argc, char **argv)
                         flags |= MAP_SHARED;
                         break;
                 case 'H':
-                        flags |= MAP_HUGETLB;
+                        flags |= (MAP_HUGETLB | MAP_ANONYMOUS);
                         break;
                 default:
                         return -1;