mm: convert totalram_pages and totalhigh_pages variables to atomic

totalram_pages and totalhigh_pages are made static inline function.

Main motivation was that managed_page_count_lock handling was complicating
things.  It was discussed in length here,
https://lore.kernel.org/patchwork/patch/995739/#1181785 So it seemes
better to remove the lock and convert variables to atomic, with preventing
poteintial store-to-read tearing as a bonus.

[akpm@linux-foundation.org: coding style fixes]
Link: http://lkml.kernel.org/r/1542090790-21750-4-git-send-email-arunks@codeaurora.org
Signed-off-by: Arun KS <arunks@codeaurora.org>
Suggested-by: Michal Hocko <mhocko@suse.com>
Suggested-by: Vlastimil Babka <vbabka@suse.cz>
Reviewed-by: Konstantin Khlebnikov <khlebnikov@yandex-team.ru>
Reviewed-by: Pavel Tatashin <pasha.tatashin@soleen.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: David Hildenbrand <david@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

53 files changed, 131 insertions, 81 deletions

diff --git a/arch/csky/mm/init.c b/arch/csky/mm/init.c
index dc07c078f9b8..66e597053488 100644
--- a/arch/csky/mm/init.c
+++ b/arch/csky/mm/init.c
@@ -71,7 +71,7 @@ void free_initrd_mem(unsigned long start, unsigned long end)
                 ClearPageReserved(virt_to_page(start));
                 init_page_count(virt_to_page(start));
                 free_page(start);
-                totalram_pages++;
+                totalram_pages_inc();
         }
 }
 #endif
@@ -88,7 +88,7 @@ void free_initmem(void)
                 ClearPageReserved(virt_to_page(addr));
                 init_page_count(virt_to_page(addr));
                 free_page(addr);
-                totalram_pages++;
+                totalram_pages_inc();
                 addr += PAGE_SIZE;
         }
 
diff --git a/arch/powerpc/platforms/pseries/cmm.c b/arch/powerpc/platforms/pseries/cmm.c
index 25427a48feae..e8d63a6a9002 100644
--- a/arch/powerpc/platforms/pseries/cmm.c
+++ b/arch/powerpc/platforms/pseries/cmm.c
@@ -208,7 +208,7 @@ static long cmm_alloc_pages(long nr)
 
                 pa->page[pa->index++] = addr;
                 loaned_pages++;
-                totalram_pages--;
+                totalram_pages_dec();
                 spin_unlock(&cmm_lock);
                 nr--;
         }
@@ -247,7 +247,7 @@ static long cmm_free_pages(long nr)
                 free_page(addr);
                 loaned_pages--;
                 nr--;
-                totalram_pages++;
+                totalram_pages_inc();
         }
         spin_unlock(&cmm_lock);
         cmm_dbg("End request with %ld pages unfulfilled\n", nr);
@@ -291,7 +291,7 @@ static void cmm_get_mpp(void)
         int rc;
         struct hvcall_mpp_data mpp_data;
         signed long active_pages_target, page_loan_request, target;
-        signed long total_pages = totalram_pages + loaned_pages;
+        signed long total_pages = totalram_pages() + loaned_pages;
         signed long min_mem_pages = (min_mem_mb * 1024 * 1024) / PAGE_SIZE;
 
         rc = h_get_mpp(&mpp_data);
@@ -322,7 +322,7 @@ static void cmm_get_mpp(void)
 
         cmm_dbg("delta = %ld, loaned = %lu, target = %lu, oom = %lu, totalram = %lu\n",
                 page_loan_request, loaned_pages, loaned_pages_target,
-                oom_freed_pages, totalram_pages);
+                oom_freed_pages, totalram_pages());
 }
 
 static struct notifier_block cmm_oom_nb = {
@@ -581,7 +581,7 @@ static int cmm_mem_going_offline(void *arg)
                         free_page(pa_curr->page[idx]);
                         freed++;
                         loaned_pages--;
-                        totalram_pages++;
+                        totalram_pages_inc();
                         pa_curr->page[idx] = pa_last->page[--pa_last->index];
                         if (pa_last->index == 0) {
                                 if (pa_curr == pa_last)
diff --git a/arch/s390/mm/init.c b/arch/s390/mm/init.c
index 76d0708438e9..50388190b393 100644
--- a/arch/s390/mm/init.c
+++ b/arch/s390/mm/init.c
@@ -59,7 +59,7 @@ static void __init setup_zero_pages(void)
         order = 7;
 
         /* Limit number of empty zero pages for small memory sizes */
-        while (order > 2 && (totalram_pages >> 10) < (1UL << order))
+        while (order > 2 && (totalram_pages() >> 10) < (1UL << order))
                 order--;
 
         empty_zero_page = __get_free_pages(GFP_KERNEL | __GFP_ZERO, order);
diff --git a/arch/um/kernel/mem.c b/arch/um/kernel/mem.c
index 2da209687a22..8d21a83dd289 100644
--- a/arch/um/kernel/mem.c
+++ b/arch/um/kernel/mem.c
@@ -51,7 +51,7 @@ void __init mem_init(void)
 
         /* this will put all low memory onto the freelists */
         memblock_free_all();
-        max_low_pfn = totalram_pages;
+        max_low_pfn = totalram_pages();
         max_pfn = max_low_pfn;
         mem_init_print_info(NULL);
         kmalloc_ok = 1;
diff --git a/arch/x86/kernel/cpu/microcode/core.c b/arch/x86/kernel/cpu/microcode/core.c
index 168fa272cc3e..97f9ada9ceda 100644
--- a/arch/x86/kernel/cpu/microcode/core.c
+++ b/arch/x86/kernel/cpu/microcode/core.c
@@ -434,7 +434,7 @@ static ssize_t microcode_write(struct file *file, const char __user *buf,
                                size_t len, loff_t *ppos)
 {
         ssize_t ret = -EINVAL;
-        unsigned long nr_pages = totalram_pages;
+        unsigned long nr_pages = totalram_pages();
 
         if ((len >> PAGE_SHIFT) > nr_pages) {
                 pr_err("too much data (max %ld pages)\n", nr_pages);
diff --git a/drivers/char/agp/backend.c b/drivers/char/agp/backend.c
index 38ffb281df97..004a3ce8ba72 100644
--- a/drivers/char/agp/backend.c
+++ b/drivers/char/agp/backend.c
@@ -115,9 +115,9 @@ static int agp_find_max(void)
         long memory, index, result;
 
 #if PAGE_SHIFT < 20
-        memory = totalram_pages >> (20 - PAGE_SHIFT);
+        memory = totalram_pages() >> (20 - PAGE_SHIFT);
 #else
-        memory = totalram_pages << (PAGE_SHIFT - 20);
+        memory = totalram_pages() << (PAGE_SHIFT - 20);
 #endif
         index = 1;
 
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index d36a9755ad91..a9de07bb72c8 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -2559,7 +2559,7 @@ static int i915_gem_object_get_pages_gtt(struct drm_i915_gem_object *obj)
          * If there's no chance of allocating enough pages for the whole
          * object, bail early.
          */
-        if (page_count > totalram_pages)
+        if (page_count > totalram_pages())
                 return -ENOMEM;
 
         st = kmalloc(sizeof(*st), GFP_KERNEL);
diff --git a/drivers/gpu/drm/i915/selftests/i915_gem_gtt.c b/drivers/gpu/drm/i915/selftests/i915_gem_gtt.c
index 69fe86b30fbb..a9ed0ecc94e2 100644
--- a/drivers/gpu/drm/i915/selftests/i915_gem_gtt.c
+++ b/drivers/gpu/drm/i915/selftests/i915_gem_gtt.c
@@ -170,7 +170,7 @@ static int igt_ppgtt_alloc(void *arg)
          * This should ensure that we do not run into the oomkiller during
          * the test and take down the machine wilfully.
          */
-        limit = totalram_pages << PAGE_SHIFT;
+        limit = totalram_pages() << PAGE_SHIFT;
         limit = min(ppgtt->vm.total, limit);
 
         /* Check we can allocate the entire range */
@@ -1244,7 +1244,7 @@ static int exercise_mock(struct drm_i915_private *i915,
                                      u64 hole_start, u64 hole_end,
                                      unsigned long end_time))
 {
-        const u64 limit = totalram_pages << PAGE_SHIFT;
+        const u64 limit = totalram_pages() << PAGE_SHIFT;
         struct i915_gem_context *ctx;
         struct i915_hw_ppgtt *ppgtt;
         IGT_TIMEOUT(end_time);
diff --git a/drivers/hv/hv_balloon.c b/drivers/hv/hv_balloon.c
index f3e7da981610..5301fef16c31 100644
--- a/drivers/hv/hv_balloon.c
+++ b/drivers/hv/hv_balloon.c
@@ -1090,7 +1090,7 @@ static void process_info(struct hv_dynmem_device *dm, struct dm_info_msg *msg)
 static unsigned long compute_balloon_floor(void)
 {
         unsigned long min_pages;
-        unsigned long nr_pages = totalram_pages;
+        unsigned long nr_pages = totalram_pages();
 #define MB2PAGES(mb) ((mb) << (20 - PAGE_SHIFT))
         /* Simple continuous piecewiese linear function:
          *  max MiB -> min MiB  gradient
diff --git a/drivers/md/dm-bufio.c b/drivers/md/dm-bufio.c
index dc385b70e4c3..8b0b628e5d1c 100644
--- a/drivers/md/dm-bufio.c
+++ b/drivers/md/dm-bufio.c
@@ -1887,7 +1887,7 @@ static int __init dm_bufio_init(void)
         dm_bufio_allocated_vmalloc = 0;
         dm_bufio_current_allocated = 0;
 
-        mem = (__u64)mult_frac(totalram_pages - totalhigh_pages,
+        mem = (__u64)mult_frac(totalram_pages() - totalhigh_pages(),
                                DM_BUFIO_MEMORY_PERCENT, 100) << PAGE_SHIFT;
 
         if (mem > ULONG_MAX)
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index a7195eb5b8d8..a8c32de29e3f 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -2158,7 +2158,7 @@ static int crypt_wipe_key(struct crypt_config *cc)
 
 static void crypt_calculate_pages_per_client(void)
 {
-        unsigned long pages = (totalram_pages - totalhigh_pages) * DM_CRYPT_MEMORY_PERCENT / 100;
+        unsigned long pages = (totalram_pages() - totalhigh_pages()) * DM_CRYPT_MEMORY_PERCENT / 100;
 
         if (!dm_crypt_clients_n)
                 return;
diff --git a/drivers/md/dm-integrity.c b/drivers/md/dm-integrity.c
index d4ad0bfee251..62baa3214cc7 100644
--- a/drivers/md/dm-integrity.c
+++ b/drivers/md/dm-integrity.c
@@ -2843,7 +2843,7 @@ static int create_journal(struct dm_integrity_c *ic, char **error)
         journal_pages = roundup((__u64)ic->journal_sections * ic->journal_section_sectors,
                                 PAGE_SIZE >> SECTOR_SHIFT) >> (PAGE_SHIFT - SECTOR_SHIFT);
         journal_desc_size = journal_pages * sizeof(struct page_list);
-        if (journal_pages >= totalram_pages - totalhigh_pages || journal_desc_size > ULONG_MAX) {
+        if (journal_pages >= totalram_pages() - totalhigh_pages() || journal_desc_size > ULONG_MAX) {
                 *error = "Journal doesn't fit into memory";
                 r = -ENOMEM;
                 goto bad;
diff --git a/drivers/md/dm-stats.c b/drivers/md/dm-stats.c
index 21de30b4e2a1..45b92a3d9d8e 100644
--- a/drivers/md/dm-stats.c
+++ b/drivers/md/dm-stats.c
@@ -85,7 +85,7 @@ static bool __check_shared_memory(size_t alloc_size)
         a = shared_memory_amount + alloc_size;
         if (a < shared_memory_amount)
                 return false;
-        if (a >> PAGE_SHIFT > totalram_pages / DM_STATS_MEMORY_FACTOR)
+        if (a >> PAGE_SHIFT > totalram_pages() / DM_STATS_MEMORY_FACTOR)
                 return false;
 #ifdef CONFIG_MMU
         if (a > (VMALLOC_END - VMALLOC_START) / DM_STATS_VMALLOC_FACTOR)
diff --git a/drivers/media/platform/mtk-vpu/mtk_vpu.c b/drivers/media/platform/mtk-vpu/mtk_vpu.c
index 616f78b24a79..b6602490a247 100644
--- a/drivers/media/platform/mtk-vpu/mtk_vpu.c
+++ b/drivers/media/platform/mtk-vpu/mtk_vpu.c
@@ -855,7 +855,7 @@ static int mtk_vpu_probe(struct platform_device *pdev)
         /* Set PTCM to 96K and DTCM to 32K */
         vpu_cfg_writel(vpu, 0x2, VPU_TCM_CFG);
 
-        vpu->enable_4GB = !!(totalram_pages > (SZ_2G >> PAGE_SHIFT));
+        vpu->enable_4GB = !!(totalram_pages() > (SZ_2G >> PAGE_SHIFT));
         dev_info(dev, "4GB mode %u\n", vpu->enable_4GB);
 
         if (vpu->enable_4GB) {
diff --git a/drivers/misc/vmw_balloon.c b/drivers/misc/vmw_balloon.c
index 9b0b3fa4f836..e6126a4b95d3 100644
--- a/drivers/misc/vmw_balloon.c
+++ b/drivers/misc/vmw_balloon.c
@@ -570,7 +570,7 @@ static int vmballoon_send_get_target(struct vmballoon *b)
         unsigned long status;
         unsigned long limit;
 
-        limit = totalram_pages;
+        limit = totalram_pages();
 
         /* Ensure limit fits in 32-bits */
         if (limit != (u32)limit)
diff --git a/drivers/parisc/ccio-dma.c b/drivers/parisc/ccio-dma.c
index 701a7d6a74d5..358e380eb7fa 100644
--- a/drivers/parisc/ccio-dma.c
+++ b/drivers/parisc/ccio-dma.c
@@ -1251,7 +1251,7 @@ ccio_ioc_init(struct ioc *ioc)
         ** Hot-Plug/Removal of PCI cards. (aka PCI OLARD).
         */
 
-        iova_space_size = (u32) (totalram_pages / count_parisc_driver(&ccio_driver));
+        iova_space_size = (u32) (totalram_pages() / count_parisc_driver(&ccio_driver));
 
         /* limit IOVA space size to 1MB-1GB */
 
@@ -1290,7 +1290,7 @@ ccio_ioc_init(struct ioc *ioc)
 
         DBG_INIT("%s() hpa 0x%p mem %luMB IOV %dMB (%d bits)\n",
                         __func__, ioc->ioc_regs,
-                        (unsigned long) totalram_pages >> (20 - PAGE_SHIFT),
+                        (unsigned long) totalram_pages() >> (20 - PAGE_SHIFT),
                         iova_space_size>>20,
                         iov_order + PAGE_SHIFT);
 
diff --git a/drivers/parisc/sba_iommu.c b/drivers/parisc/sba_iommu.c
index c1e599a429af..e0655949480a 100644
--- a/drivers/parisc/sba_iommu.c
+++ b/drivers/parisc/sba_iommu.c
@@ -1414,7 +1414,7 @@ sba_ioc_init(struct parisc_device *sba, struct ioc *ioc, int ioc_num)
         ** for DMA hints - ergo only 30 bits max.
         */
 
-        iova_space_size = (u32) (totalram_pages/global_ioc_cnt);
+        iova_space_size = (u32) (totalram_pages()/global_ioc_cnt);
 
         /* limit IOVA space size to 1MB-1GB */
         if (iova_space_size < (1 << (20 - PAGE_SHIFT))) {
@@ -1439,7 +1439,7 @@ sba_ioc_init(struct parisc_device *sba, struct ioc *ioc, int ioc_num)
         DBG_INIT("%s() hpa 0x%lx mem %ldMB IOV %dMB (%d bits)\n",
                         __func__,
                         ioc->ioc_hpa,
-                        (unsigned long) totalram_pages >> (20 - PAGE_SHIFT),
+                        (unsigned long) totalram_pages() >> (20 - PAGE_SHIFT),
                         iova_space_size>>20,
                         iov_order + PAGE_SHIFT);
 
diff --git a/drivers/staging/android/ion/ion_system_heap.c b/drivers/staging/android/ion/ion_system_heap.c
index 548bb02c0ca6..6cb0eebdff89 100644
--- a/drivers/staging/android/ion/ion_system_heap.c
+++ b/drivers/staging/android/ion/ion_system_heap.c
@@ -110,7 +110,7 @@ static int ion_system_heap_allocate(struct ion_heap *heap,
         unsigned long size_remaining = PAGE_ALIGN(size);
         unsigned int max_order = orders[0];
 
-        if (size / PAGE_SIZE > totalram_pages / 2)
+        if (size / PAGE_SIZE > totalram_pages() / 2)
                 return -ENOMEM;
 
         INIT_LIST_HEAD(&pages);
diff --git a/drivers/xen/xen-selfballoon.c b/drivers/xen/xen-selfballoon.c
index 5165aa82bf7d..246f6122c9ee 100644
--- a/drivers/xen/xen-selfballoon.c
+++ b/drivers/xen/xen-selfballoon.c
@@ -189,7 +189,7 @@ static void selfballoon_process(struct work_struct *work)
         bool reset_timer = false;
 
         if (xen_selfballooning_enabled) {
-                cur_pages = totalram_pages;
+                cur_pages = totalram_pages();
                 tgt_pages = cur_pages; /* default is no change */
                 goal_pages = vm_memory_committed() +
                                 totalreserve_pages +
@@ -227,7 +227,7 @@ static void selfballoon_process(struct work_struct *work)
                 if (tgt_pages < floor_pages)
                         tgt_pages = floor_pages;
                 balloon_set_new_target(tgt_pages +
-                        balloon_stats.current_pages - totalram_pages);
+                        balloon_stats.current_pages - totalram_pages());
                 reset_timer = true;
         }
 #ifdef CONFIG_FRONTSWAP
@@ -569,7 +569,7 @@ int xen_selfballoon_init(bool use_selfballooning, bool use_frontswap_selfshrink)
          * much more reliably and response faster in some cases.
          */
         if (!selfballoon_reserved_mb) {
-                reserve_pages = totalram_pages / 10;
+                reserve_pages = totalram_pages() / 10;
                 selfballoon_reserved_mb = PAGES2MB(reserve_pages);
         }
         schedule_delayed_work(&selfballoon_worker, selfballoon_interval * HZ);
diff --git a/fs/ceph/super.h b/fs/ceph/super.h
index 79a265ba9200..dfb64a5211b6 100644
--- a/fs/ceph/super.h
+++ b/fs/ceph/super.h
@@ -810,7 +810,7 @@ static inline int default_congestion_kb(void)
          * This allows larger machines to have larger/more transfers.
          * Limit the default to 256M
          */
-        congestion_kb = (16*int_sqrt(totalram_pages)) << (PAGE_SHIFT-10);
+        congestion_kb = (16*int_sqrt(totalram_pages())) << (PAGE_SHIFT-10);
         if (congestion_kb > 256*1024)
                 congestion_kb = 256*1024;
 
diff --git a/fs/file_table.c b/fs/file_table.c
index b6e9587f05c7..5679e7fcb6b0 100644
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -380,7 +380,7 @@ void __init files_init(void)
 void __init files_maxfiles_init(void)
 {
         unsigned long n;
-        unsigned long nr_pages = totalram_pages;
+        unsigned long nr_pages = totalram_pages();
         unsigned long memreserve = (nr_pages - nr_free_pages()) * 3/2;
 
         memreserve = min(memreserve, nr_pages - 1);
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 568abed20eb2..76baaa6be393 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -824,7 +824,7 @@ static const struct super_operations fuse_super_operations = {
 static void sanitize_global_limit(unsigned *limit)
 {
         if (*limit == 0)
-                *limit = ((totalram_pages << PAGE_SHIFT) >> 13) /
+                *limit = ((totalram_pages() << PAGE_SHIFT) >> 13) /
                          sizeof(struct fuse_req);
 
         if (*limit >= 1 << 16)
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 586726a590d8..4f15665f0ad1 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -2121,7 +2121,7 @@ int __init nfs_init_writepagecache(void)
          * This allows larger machines to have larger/more transfers.
          * Limit the default to 256M
          */
-        nfs_congestion_kb = (16*int_sqrt(totalram_pages)) << (PAGE_SHIFT-10);
+        nfs_congestion_kb = (16*int_sqrt(totalram_pages())) << (PAGE_SHIFT-10);
         if (nfs_congestion_kb > 256*1024)
                 nfs_congestion_kb = 256*1024;
 
diff --git a/fs/nfsd/nfscache.c b/fs/nfsd/nfscache.c
index e2fe0e9ce0df..da52b594362a 100644
--- a/fs/nfsd/nfscache.c
+++ b/fs/nfsd/nfscache.c
@@ -99,7 +99,7 @@ static unsigned int
 nfsd_cache_size_limit(void)
 {
         unsigned int limit;
-        unsigned long low_pages = totalram_pages - totalhigh_pages;
+        unsigned long low_pages = totalram_pages() - totalhigh_pages();
 
         limit = (16 * int_sqrt(low_pages)) << (PAGE_SHIFT-10);
         return min_t(unsigned int, limit, 256*1024);
diff --git a/fs/ntfs/malloc.h b/fs/ntfs/malloc.h
index ab172e5f51d9..5becc8acc8f4 100644
--- a/fs/ntfs/malloc.h
+++ b/fs/ntfs/malloc.h
@@ -47,7 +47,7 @@ static inline void *__ntfs_malloc(unsigned long size, gfp_t gfp_mask)
                 return kmalloc(PAGE_SIZE, gfp_mask & ~__GFP_HIGHMEM);
                 /* return (void *)__get_free_page(gfp_mask); */
         }
-        if (likely((size >> PAGE_SHIFT) < totalram_pages))
+        if (likely((size >> PAGE_SHIFT) < totalram_pages()))
                 return __vmalloc(size, gfp_mask, PAGE_KERNEL);
         return NULL;
 }
diff --git a/fs/proc/base.c b/fs/proc/base.c
index ce3465479447..d7fd1ca807d2 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -530,7 +530,7 @@ static const struct file_operations proc_lstats_operations = {
 static int proc_oom_score(struct seq_file *m, struct pid_namespace *ns,
                           struct pid *pid, struct task_struct *task)
 {
-        unsigned long totalpages = totalram_pages + total_swap_pages;
+        unsigned long totalpages = totalram_pages() + total_swap_pages;
         unsigned long points = 0;
 
         points = oom_badness(task, NULL, NULL, totalpages) *
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index 0690679832d4..ea5cdbd8c2c3 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -36,7 +36,31 @@ static inline void invalidate_kernel_vmap_range(void *vaddr, int size)
 
 /* declarations for linux/mm/highmem.c */
 unsigned int nr_free_highpages(void);
-extern unsigned long totalhigh_pages;
+extern atomic_long_t _totalhigh_pages;
+static inline unsigned long totalhigh_pages(void)
+{
+        return (unsigned long)atomic_long_read(&_totalhigh_pages);
+}
+
+static inline void totalhigh_pages_inc(void)
+{
+        atomic_long_inc(&_totalhigh_pages);
+}
+
+static inline void totalhigh_pages_dec(void)
+{
+        atomic_long_dec(&_totalhigh_pages);
+}
+
+static inline void totalhigh_pages_add(long count)
+{
+        atomic_long_add(count, &_totalhigh_pages);
+}
+
+static inline void totalhigh_pages_set(long val)
+{
+        atomic_long_set(&_totalhigh_pages, val);
+}
 
 void kmap_flush_unused(void);
 
@@ -51,7 +75,7 @@ static inline struct page *kmap_to_page(void *addr)
         return virt_to_page(addr);
 }
 
-#define totalhigh_pages 0UL
+static inline unsigned long totalhigh_pages(void) { return 0UL; }
 
 #ifndef ARCH_HAS_KMAP
 static inline void *kmap(struct page *page)
diff --git a/include/linux/mm.h b/include/linux/mm.h
index b4d01969e700..1d2be4c2d34a 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -48,7 +48,32 @@ static inline void set_max_mapnr(unsigned long limit)
 static inline void set_max_mapnr(unsigned long limit) { }
 #endif
 
-extern unsigned long totalram_pages;
+extern atomic_long_t _totalram_pages;
+static inline unsigned long totalram_pages(void)
+{
+        return (unsigned long)atomic_long_read(&_totalram_pages);
+}
+
+static inline void totalram_pages_inc(void)
+{
+        atomic_long_inc(&_totalram_pages);
+}
+
+static inline void totalram_pages_dec(void)
+{
+        atomic_long_dec(&_totalram_pages);
+}
+
+static inline void totalram_pages_add(long count)
+{
+        atomic_long_add(count, &_totalram_pages);
+}
+
+static inline void totalram_pages_set(long val)
+{
+        atomic_long_set(&_totalram_pages, val);
+}
+
 extern void * high_memory;
 extern int page_cluster;
 
diff --git a/include/linux/swap.h b/include/linux/swap.h
index a8f6d5d89524..77459d695010 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -310,7 +310,6 @@ void workingset_update_node(struct xa_node *node);
 } while (0)
 
 /* linux/mm/page_alloc.c */
-extern unsigned long totalram_pages;
 extern unsigned long totalreserve_pages;
 extern unsigned long nr_free_buffer_pages(void);
 extern unsigned long nr_free_pagecache_pages(void);
diff --git a/kernel/fork.c b/kernel/fork.c
index 8617a326e9f5..c979605fe806 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -744,7 +744,7 @@ void __init __weak arch_task_cache_init(void) { }
 static void set_max_threads(unsigned int max_threads_suggested)
 {
         u64 threads;
-        unsigned long nr_pages = totalram_pages;
+        unsigned long nr_pages = totalram_pages();
 
         /*
          * The number of threads shall be limited such that the thread
diff --git a/kernel/kexec_core.c b/kernel/kexec_core.c
index 7e967ca98d92..d7140447be75 100644
--- a/kernel/kexec_core.c
+++ b/kernel/kexec_core.c
@@ -152,7 +152,7 @@ int sanity_check_segment_list(struct kimage *image)
         int i;
         unsigned long nr_segments = image->nr_segments;
         unsigned long total_pages = 0;
-        unsigned long nr_pages = totalram_pages;
+        unsigned long nr_pages = totalram_pages();
 
         /*
          * Verify we have good destination addresses.  The caller is
diff --git a/kernel/power/snapshot.c b/kernel/power/snapshot.c
index b0308a2c6000..640b2034edd6 100644
--- a/kernel/power/snapshot.c
+++ b/kernel/power/snapshot.c
@@ -105,7 +105,7 @@ unsigned long image_size;
 
 void __init hibernate_image_size_init(void)
 {
-        image_size = ((totalram_pages * 2) / 5) * PAGE_SIZE;
+        image_size = ((totalram_pages() * 2) / 5) * PAGE_SIZE;
 }
 
 /*
diff --git a/mm/highmem.c b/mm/highmem.c
index 59db3223a5d6..107b10f9878e 100644
--- a/mm/highmem.c
+++ b/mm/highmem.c
@@ -105,9 +105,8 @@ static inline wait_queue_head_t *get_pkmap_wait_queue_head(unsigned int color)
 }
 #endif
 
-unsigned long totalhigh_pages __read_mostly;
-EXPORT_SYMBOL(totalhigh_pages);
-
+atomic_long_t _totalhigh_pages __read_mostly;
+EXPORT_SYMBOL(_totalhigh_pages);
 
 EXPORT_PER_CPU_SYMBOL(__kmap_atomic_idx);
 
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index e84a10b0d310..da6682bb69aa 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -420,7 +420,7 @@ static int __init hugepage_init(void)
          * where the extra memory used could hurt more than TLB overhead
          * is likely to save.  The admin can still enable it through /sys.
          */
-        if (totalram_pages < (512 << (20 - PAGE_SHIFT))) {
+        if (totalram_pages() < (512 << (20 - PAGE_SHIFT))) {
                 transparent_hugepage_flags = 0;
                 return 0;
         }
diff --git a/mm/kasan/quarantine.c b/mm/kasan/quarantine.c
index 57334ef2d7ef..978bc4a3eb51 100644
--- a/mm/kasan/quarantine.c
+++ b/mm/kasan/quarantine.c
@@ -237,7 +237,7 @@ void quarantine_reduce(void)
          * Update quarantine size in case of hotplug. Allocate a fraction of
          * the installed memory to quarantine minus per-cpu queue limits.
          */
-        total_size = (READ_ONCE(totalram_pages) << PAGE_SHIFT) /
+        total_size = (totalram_pages() << PAGE_SHIFT) /
                 QUARANTINE_FRACTION;
         percpu_quarantines = QUARANTINE_PERCPU_SIZE * num_online_cpus();
         new_quarantine_size = (total_size < percpu_quarantines) ?
diff --git a/mm/memblock.c b/mm/memblock.c
index 0068f87af1e8..a53d8697612c 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1576,7 +1576,7 @@ void __init __memblock_free_late(phys_addr_t base, phys_addr_t size)
 
         for (; cursor < end; cursor++) {
                 memblock_free_pages(pfn_to_page(cursor), cursor, 0);
-                totalram_pages++;
+                totalram_pages_inc();
         }
 }
 
@@ -1978,7 +1978,7 @@ unsigned long __init memblock_free_all(void)
         reset_all_zones_managed_pages();
 
         pages = free_low_memory_core_early();
-        totalram_pages += pages;
+        totalram_pages_add(pages);
 
         return pages;
 }
diff --git a/mm/mm_init.c b/mm/mm_init.c
index 6838a530789b..33917105a3a2 100644
--- a/mm/mm_init.c
+++ b/mm/mm_init.c
@@ -146,7 +146,7 @@ static void __meminit mm_compute_batch(void)
         s32 batch = max_t(s32, nr*2, 32);
 
         /* batch size set to 0.4% of (total memory/#cpus), or max int32 */
-        memsized_batch = min_t(u64, (totalram_pages/nr)/256, 0x7fffffff);
+        memsized_batch = min_t(u64, (totalram_pages()/nr)/256, 0x7fffffff);
 
         vm_committed_as_batch = max_t(s32, memsized_batch, batch);
 }
diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index 6589f60d5018..21d487749e1d 100644
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -269,7 +269,7 @@ static enum oom_constraint constrained_alloc(struct oom_control *oc)
         }
 
         /* Default to all available memory */
-        oc->totalpages = totalram_pages + total_swap_pages;
+        oc->totalpages = totalram_pages() + total_swap_pages;
 
         if (!IS_ENABLED(CONFIG_NUMA))
                 return CONSTRAINT_NONE;
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 4b5c4ff68f18..eb2027892ef9 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -16,6 +16,7 @@
 
 #include <linux/stddef.h>
 #include <linux/mm.h>
+#include <linux/highmem.h>
 #include <linux/swap.h>
 #include <linux/interrupt.h>
 #include <linux/pagemap.h>
@@ -124,7 +125,8 @@ EXPORT_SYMBOL(node_states);
 /* Protect totalram_pages and zone->managed_pages */
 static DEFINE_SPINLOCK(managed_page_count_lock);
 
-unsigned long totalram_pages __read_mostly;
+atomic_long_t _totalram_pages __read_mostly;
+EXPORT_SYMBOL(_totalram_pages);
 unsigned long totalreserve_pages __read_mostly;
 unsigned long totalcma_pages __read_mostly;
 
@@ -4747,11 +4749,11 @@ EXPORT_SYMBOL_GPL(si_mem_available);
 
 void si_meminfo(struct sysinfo *val)
 {
-        val->totalram = totalram_pages;
+        val->totalram = totalram_pages();
         val->sharedram = global_node_page_state(NR_SHMEM);
         val->freeram = global_zone_page_state(NR_FREE_PAGES);
         val->bufferram = nr_blockdev_pages();
-        val->totalhigh = totalhigh_pages;
+        val->totalhigh = totalhigh_pages();
         val->freehigh = nr_free_highpages();
         val->mem_unit = PAGE_SIZE;
 }
@@ -7077,10 +7079,10 @@ void adjust_managed_page_count(struct page *page, long count)
 {
         spin_lock(&managed_page_count_lock);
         atomic_long_add(count, &page_zone(page)->managed_pages);
-        totalram_pages += count;
+        totalram_pages_add(count);
 #ifdef CONFIG_HIGHMEM
         if (PageHighMem(page))
-                totalhigh_pages += count;
+                totalhigh_pages_add(count);
 #endif
         spin_unlock(&managed_page_count_lock);
 }
@@ -7123,9 +7125,9 @@ EXPORT_SYMBOL(free_reserved_area);
 void free_highmem_page(struct page *page)
 {
         __free_reserved_page(page);
-        totalram_pages++;
+        totalram_pages_inc();
         atomic_long_inc(&page_zone(page)->managed_pages);
-        totalhigh_pages++;
+        totalhigh_pages_inc();
 }
 #endif
 
@@ -7174,10 +7176,10 @@ void __init mem_init_print_info(const char *str)
                 physpages << (PAGE_SHIFT - 10),
                 codesize >> 10, datasize >> 10, rosize >> 10,
                 (init_data_size + init_code_size) >> 10, bss_size >> 10,
-                (physpages - totalram_pages - totalcma_pages) << (PAGE_SHIFT - 10),
+                (physpages - totalram_pages() - totalcma_pages) << (PAGE_SHIFT - 10),
                 totalcma_pages << (PAGE_SHIFT - 10),
 #ifdef  CONFIG_HIGHMEM
-                totalhigh_pages << (PAGE_SHIFT - 10),
+                totalhigh_pages() << (PAGE_SHIFT - 10),
 #endif
                 str ? ", " : "", str ? str : "");
 }
diff --git a/mm/shmem.c b/mm/shmem.c
index b1f0f54470fb..6ece1e2fe76e 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -109,13 +109,14 @@ struct shmem_falloc {
 #ifdef CONFIG_TMPFS
 static unsigned long shmem_default_max_blocks(void)
 {
-        return totalram_pages / 2;
+        return totalram_pages() / 2;
 }
 
 static unsigned long shmem_default_max_inodes(void)
 {
-        unsigned long nr_pages = totalram_pages;
-        return min(nr_pages - totalhigh_pages, nr_pages / 2);
+        unsigned long nr_pages = totalram_pages();
+
+        return min(nr_pages - totalhigh_pages(), nr_pages / 2);
 }
 #endif
 
@@ -3302,7 +3303,7 @@ static int shmem_parse_options(char *options, struct shmem_sb_info *sbinfo,
                         size = memparse(value,&rest);
                         if (*rest == '%') {
                                 size <<= PAGE_SHIFT;
-                                size *= totalram_pages;
+                                size *= totalram_pages();
                                 do_div(size, 100);
                                 rest++;
                         }
diff --git a/mm/slab.c b/mm/slab.c
index 01991060714c..73fe23e649c9 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -1235,7 +1235,7 @@ void __init kmem_cache_init(void)
          * page orders on machines with more than 32MB of memory if
          * not overridden on the command line.
          */
-        if (!slab_max_order_set && totalram_pages > (32 << 20) >> PAGE_SHIFT)
+        if (!slab_max_order_set && totalram_pages() > (32 << 20) >> PAGE_SHIFT)
                 slab_max_order = SLAB_MAX_ORDER_HI;
 
         /* Bootstrap is tricky, because several objects are allocated
diff --git a/mm/swap.c b/mm/swap.c
index 5d786019eab9..4d8a1f1afaab 100644
--- a/mm/swap.c
+++ b/mm/swap.c
@@ -1022,7 +1022,7 @@ EXPORT_SYMBOL(pagevec_lookup_range_nr_tag);
  */
 void __init swap_setup(void)
 {
-        unsigned long megs = totalram_pages >> (20 - PAGE_SHIFT);
+        unsigned long megs = totalram_pages() >> (20 - PAGE_SHIFT);
 
         /* Use a smaller cluster for small-memory machines */
         if (megs < 16)
diff --git a/mm/util.c b/mm/util.c
index 8bf08b5b5760..4df23d64aac7 100644
--- a/mm/util.c
+++ b/mm/util.c
@@ -593,7 +593,7 @@ unsigned long vm_commit_limit(void)
         if (sysctl_overcommit_kbytes)
                 allowed = sysctl_overcommit_kbytes >> (PAGE_SHIFT - 10);
         else
-                allowed = ((totalram_pages - hugetlb_total_pages())
+                allowed = ((totalram_pages() - hugetlb_total_pages())
                            * sysctl_overcommit_ratio / 100);
         allowed += total_swap_pages;
 
diff --git a/mm/vmalloc.c b/mm/vmalloc.c
index 97d4b25d0373..871e41c55e23 100644
--- a/mm/vmalloc.c
+++ b/mm/vmalloc.c
@@ -1634,7 +1634,7 @@ void *vmap(struct page **pages, unsigned int count,
 
         might_sleep();
 
-        if (count > totalram_pages)
+        if (count > totalram_pages())
                 return NULL;
 
         size = (unsigned long)count << PAGE_SHIFT;
@@ -1739,7 +1739,7 @@ void *__vmalloc_node_range(unsigned long size, unsigned long align,
         unsigned long real_size = size;
 
         size = PAGE_ALIGN(size);
-        if (!size || (size >> PAGE_SHIFT) > totalram_pages)
+        if (!size || (size >> PAGE_SHIFT) > totalram_pages())
                 goto fail;
 
         area = __get_vm_area_node(size, align, VM_ALLOC | VM_UNINITIALIZED |
diff --git a/mm/workingset.c b/mm/workingset.c
index d46f8c92aa2f..dcb994f2acc2 100644
--- a/mm/workingset.c
+++ b/mm/workingset.c
@@ -549,7 +549,7 @@ static int __init workingset_init(void)
          * double the initial memory by using totalram_pages as-is.
          */
         timestamp_bits = BITS_PER_LONG - EVICTION_SHIFT;
-        max_order = fls_long(totalram_pages - 1);
+        max_order = fls_long(totalram_pages() - 1);
         if (max_order > timestamp_bits)
                 bucket_order = max_order - timestamp_bits;
         pr_info("workingset: timestamp_bits=%d max_order=%d bucket_order=%u\n",
diff --git a/mm/zswap.c b/mm/zswap.c
index cd91fd9d96b8..a4e4d36ec085 100644
--- a/mm/zswap.c
+++ b/mm/zswap.c
@@ -219,8 +219,8 @@ static const struct zpool_ops zswap_zpool_ops = {
 
 static bool zswap_is_full(void)
 {
-        return totalram_pages * zswap_max_pool_percent / 100 <
-                DIV_ROUND_UP(zswap_pool_total_size, PAGE_SIZE);
+        return totalram_pages() * zswap_max_pool_percent / 100 <
+                        DIV_ROUND_UP(zswap_pool_total_size, PAGE_SIZE);
 }
 
 static void zswap_update_total_size(void)
diff --git a/net/dccp/proto.c b/net/dccp/proto.c
index ff727ff61b5b..0e2f71ab8367 100644
--- a/net/dccp/proto.c
+++ b/net/dccp/proto.c
@@ -1131,7 +1131,7 @@ EXPORT_SYMBOL_GPL(dccp_debug);
 static int __init dccp_init(void)
 {
         unsigned long goal;
-        unsigned long nr_pages = totalram_pages;
+        unsigned long nr_pages = totalram_pages();
         int ehash_order, bhash_order, i;
         int rc;
 
diff --git a/net/decnet/dn_route.c b/net/decnet/dn_route.c
index 1c002c0fb712..950613ee7881 100644
--- a/net/decnet/dn_route.c
+++ b/net/decnet/dn_route.c
@@ -1866,7 +1866,7 @@ void __init dn_route_init(void)
         dn_route_timer.expires = jiffies + decnet_dst_gc_interval * HZ;
         add_timer(&dn_route_timer);
 
-        goal = totalram_pages >> (26 - PAGE_SHIFT);
+        goal = totalram_pages() >> (26 - PAGE_SHIFT);
 
         for(order = 0; (1UL << order) < goal; order++)
                 /* NOTHING */;
diff --git a/net/ipv4/tcp_metrics.c b/net/ipv4/tcp_metrics.c
index 03b51cdcc731..b467a7cabf40 100644
--- a/net/ipv4/tcp_metrics.c
+++ b/net/ipv4/tcp_metrics.c
@@ -1000,7 +1000,7 @@ static int __net_init tcp_net_metrics_init(struct net *net)
 
         slots = tcpmhash_entries;
         if (!slots) {
-                if (totalram_pages >= 128 * 1024)
+                if (totalram_pages() >= 128 * 1024)
                         slots = 16 * 1024;
                 else
                         slots = 8 * 1024;
diff --git a/net/netfilter/nf_conntrack_core.c b/net/netfilter/nf_conntrack_core.c
index 5eb990830348..741b533148ba 100644
--- a/net/netfilter/nf_conntrack_core.c
+++ b/net/netfilter/nf_conntrack_core.c
@@ -2248,7 +2248,7 @@ static __always_inline unsigned int total_extension_size(void)
 
 int nf_conntrack_init_start(void)
 {
-        unsigned long nr_pages = totalram_pages;
+        unsigned long nr_pages = totalram_pages();
         int max_factor = 8;
         int ret = -ENOMEM;
         int i;
diff --git a/net/netfilter/xt_hashlimit.c b/net/netfilter/xt_hashlimit.c
index 88b520ba2abc..8d86e39d6280 100644
--- a/net/netfilter/xt_hashlimit.c
+++ b/net/netfilter/xt_hashlimit.c
@@ -274,7 +274,7 @@ static int htable_create(struct net *net, struct hashlimit_cfg3 *cfg,
         struct xt_hashlimit_htable *hinfo;
         const struct seq_operations *ops;
         unsigned int size, i;
-        unsigned long nr_pages = totalram_pages;
+        unsigned long nr_pages = totalram_pages();
         int ret;
 
         if (cfg->size) {
diff --git a/net/sctp/protocol.c b/net/sctp/protocol.c
index a5b24182b3cc..d5878ae55840 100644
--- a/net/sctp/protocol.c
+++ b/net/sctp/protocol.c
@@ -1368,7 +1368,7 @@ static __init int sctp_init(void)
         int status = -EINVAL;
         unsigned long goal;
         unsigned long limit;
-        unsigned long nr_pages = totalram_pages;
+        unsigned long nr_pages = totalram_pages();
         int max_share;
         int order;
         int num_entries;
diff --git a/security/integrity/ima/ima_kexec.c b/security/integrity/ima/ima_kexec.c
index 16bd18747cfa..d6f32807b347 100644
--- a/security/integrity/ima/ima_kexec.c
+++ b/security/integrity/ima/ima_kexec.c
@@ -106,7 +106,7 @@ void ima_add_kexec_buffer(struct kimage *image)
                 kexec_segment_size = ALIGN(ima_get_binary_runtime_size() +
                                            PAGE_SIZE / 2, PAGE_SIZE);
         if ((kexec_segment_size == ULONG_MAX) ||
-            ((kexec_segment_size >> PAGE_SHIFT) > totalram_pages / 2)) {
+            ((kexec_segment_size >> PAGE_SHIFT) > totalram_pages() / 2)) {
                 pr_err("Binary measurement list too large.\n");
                 return;
         }