Merge branch 'akpm' (patches from Andrew)

Merge misc updates from Andrew Morton:

 - large KASAN update to use arm's "software tag-based mode"

 - a few misc things

 - sh updates

 - ocfs2 updates

 - just about all of MM

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (167 commits)
  kernel/fork.c: mark 'stack_vm_area' with __maybe_unused
  memcg, oom: notify on oom killer invocation from the charge path
  mm, swap: fix swapoff with KSM pages
  include/linux/gfp.h: fix typo
  mm/hmm: fix memremap.h, move dev_page_fault_t callback to hmm
  hugetlbfs: Use i_mmap_rwsem to fix page fault/truncate race
  hugetlbfs: use i_mmap_rwsem for more pmd sharing synchronization
  memory_hotplug: add missing newlines to debugging output
  mm: remove __hugepage_set_anon_rmap()
  include/linux/vmstat.h: remove unused page state adjustment macro
  mm/page_alloc.c: allow error injection
  mm: migrate: drop unused argument of migrate_page_move_mapping()
  blkdev: avoid migration stalls for blkdev pages
  mm: migrate: provide buffer_migrate_page_norefs()
  mm: migrate: move migrate_page_lock_buffers()
  mm: migrate: lock buffers before migrate_page_move_mapping()
  mm: migration: factor out code to compute expected number of page references
  mm, page_alloc: enable pcpu_drain with zone capability
  kmemleak: add config to select auto scan
  mm/page_alloc.c: don't call kasan_free_pages() at deferred mem init
  ...

31 files changed, 478 insertions, 301 deletions

diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index 0e5985682642..fb75a6fd4bd9 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -207,15 +207,15 @@ static bool pages_correctly_probed(unsigned long start_pfn)
                         return false;
 
                 if (!present_section_nr(section_nr)) {
-                        pr_warn("section %ld pfn[%lx, %lx) not present",
+                        pr_warn("section %ld pfn[%lx, %lx) not present\n",
                                 section_nr, pfn, pfn + PAGES_PER_SECTION);
                         return false;
                 } else if (!valid_section_nr(section_nr)) {
-                        pr_warn("section %ld pfn[%lx, %lx) no valid memmap",
+                        pr_warn("section %ld pfn[%lx, %lx) no valid memmap\n",
                                 section_nr, pfn, pfn + PAGES_PER_SECTION);
                         return false;
                 } else if (online_section_nr(section_nr)) {
-                        pr_warn("section %ld pfn[%lx, %lx) is already online",
+                        pr_warn("section %ld pfn[%lx, %lx) is already online\n",
                                 section_nr, pfn, pfn + PAGES_PER_SECTION);
                         return false;
                 }
@@ -688,7 +688,7 @@ static int add_memory_block(int base_section_nr)
         int i, ret, section_count = 0, section_nr;
 
         for (i = base_section_nr;
-             (i < base_section_nr + sections_per_block) && i < NR_MEM_SECTIONS;
+             i < base_section_nr + sections_per_block;
              i++) {
                 if (!present_section_nr(i))
                         continue;
diff --git a/drivers/block/zram/Kconfig b/drivers/block/zram/Kconfig
index fcd055457364..1ffc64770643 100644
--- a/drivers/block/zram/Kconfig
+++ b/drivers/block/zram/Kconfig
@@ -15,7 +15,7 @@ config ZRAM
           See Documentation/blockdev/zram.txt for more information.
 
 config ZRAM_WRITEBACK
-       bool "Write back incompressible page to backing device"
+       bool "Write back incompressible or idle page to backing device"
        depends on ZRAM
        help
          With incompressible page, there is no memory saving to keep it
@@ -23,6 +23,9 @@ config ZRAM_WRITEBACK
          For this feature, admin should set up backing device via
          /sys/block/zramX/backing_dev.
 
+         With /sys/block/zramX/{idle,writeback}, application could ask
+         idle page's writeback to the backing device to save in memory.
+
          See Documentation/blockdev/zram.txt for more information.
 
 config ZRAM_MEMORY_TRACKING
diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c
index 4879595200e1..33c5cc879f24 100644
--- a/drivers/block/zram/zram_drv.c
+++ b/drivers/block/zram/zram_drv.c
@@ -52,15 +52,23 @@ static unsigned int num_devices = 1;
 static size_t huge_class_size;
 
 static void zram_free_page(struct zram *zram, size_t index);
+static int zram_bvec_read(struct zram *zram, struct bio_vec *bvec,
+                                u32 index, int offset, struct bio *bio);
+
+
+static int zram_slot_trylock(struct zram *zram, u32 index)
+{
+        return bit_spin_trylock(ZRAM_LOCK, &zram->table[index].flags);
+}
 
 static void zram_slot_lock(struct zram *zram, u32 index)
 {
-        bit_spin_lock(ZRAM_LOCK, &zram->table[index].value);
+        bit_spin_lock(ZRAM_LOCK, &zram->table[index].flags);
 }
 
 static void zram_slot_unlock(struct zram *zram, u32 index)
 {
-        bit_spin_unlock(ZRAM_LOCK, &zram->table[index].value);
+        bit_spin_unlock(ZRAM_LOCK, &zram->table[index].flags);
 }
 
 static inline bool init_done(struct zram *zram)
@@ -68,13 +76,6 @@ static inline bool init_done(struct zram *zram)
         return zram->disksize;
 }
 
-static inline bool zram_allocated(struct zram *zram, u32 index)
-{
-
-        return (zram->table[index].value >> (ZRAM_FLAG_SHIFT + 1)) ||
-                                        zram->table[index].handle;
-}
-
 static inline struct zram *dev_to_zram(struct device *dev)
 {
         return (struct zram *)dev_to_disk(dev)->private_data;
@@ -94,19 +95,19 @@ static void zram_set_handle(struct zram *zram, u32 index, unsigned long handle)
 static bool zram_test_flag(struct zram *zram, u32 index,
                         enum zram_pageflags flag)
 {
-        return zram->table[index].value & BIT(flag);
+        return zram->table[index].flags & BIT(flag);
 }
 
 static void zram_set_flag(struct zram *zram, u32 index,
                         enum zram_pageflags flag)
 {
-        zram->table[index].value |= BIT(flag);
+        zram->table[index].flags |= BIT(flag);
 }
 
 static void zram_clear_flag(struct zram *zram, u32 index,
                         enum zram_pageflags flag)
 {
-        zram->table[index].value &= ~BIT(flag);
+        zram->table[index].flags &= ~BIT(flag);
 }
 
 static inline void zram_set_element(struct zram *zram, u32 index,
@@ -122,15 +123,22 @@ static unsigned long zram_get_element(struct zram *zram, u32 index)
 
 static size_t zram_get_obj_size(struct zram *zram, u32 index)
 {
-        return zram->table[index].value & (BIT(ZRAM_FLAG_SHIFT) - 1);
+        return zram->table[index].flags & (BIT(ZRAM_FLAG_SHIFT) - 1);
 }
 
 static void zram_set_obj_size(struct zram *zram,
                                         u32 index, size_t size)
 {
-        unsigned long flags = zram->table[index].value >> ZRAM_FLAG_SHIFT;
+        unsigned long flags = zram->table[index].flags >> ZRAM_FLAG_SHIFT;
 
-        zram->table[index].value = (flags << ZRAM_FLAG_SHIFT) | size;
+        zram->table[index].flags = (flags << ZRAM_FLAG_SHIFT) | size;
+}
+
+static inline bool zram_allocated(struct zram *zram, u32 index)
+{
+        return zram_get_obj_size(zram, index) ||
+                        zram_test_flag(zram, index, ZRAM_SAME) ||
+                        zram_test_flag(zram, index, ZRAM_WB);
 }
 
 #if PAGE_SIZE != 4096
@@ -276,17 +284,90 @@ static ssize_t mem_used_max_store(struct device *dev,
         return len;
 }
 
+static ssize_t idle_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t len)
+{
+        struct zram *zram = dev_to_zram(dev);
+        unsigned long nr_pages = zram->disksize >> PAGE_SHIFT;
+        int index;
+        char mode_buf[8];
+        ssize_t sz;
+
+        sz = strscpy(mode_buf, buf, sizeof(mode_buf));
+        if (sz <= 0)
+                return -EINVAL;
+
+        /* ignore trailing new line */
+        if (mode_buf[sz - 1] == '\n')
+                mode_buf[sz - 1] = 0x00;
+
+        if (strcmp(mode_buf, "all"))
+                return -EINVAL;
+
+        down_read(&zram->init_lock);
+        if (!init_done(zram)) {
+                up_read(&zram->init_lock);
+                return -EINVAL;
+        }
+
+        for (index = 0; index < nr_pages; index++) {
+                /*
+                 * Do not mark ZRAM_UNDER_WB slot as ZRAM_IDLE to close race.
+                 * See the comment in writeback_store.
+                 */
+                zram_slot_lock(zram, index);
+                if (!zram_allocated(zram, index) ||
+                                zram_test_flag(zram, index, ZRAM_UNDER_WB))
+                        goto next;
+                zram_set_flag(zram, index, ZRAM_IDLE);
+next:
+                zram_slot_unlock(zram, index);
+        }
+
+        up_read(&zram->init_lock);
+
+        return len;
+}
+
 #ifdef CONFIG_ZRAM_WRITEBACK
-static bool zram_wb_enabled(struct zram *zram)
+static ssize_t writeback_limit_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t len)
+{
+        struct zram *zram = dev_to_zram(dev);
+        u64 val;
+        ssize_t ret = -EINVAL;
+
+        if (kstrtoull(buf, 10, &val))
+                return ret;
+
+        down_read(&zram->init_lock);
+        atomic64_set(&zram->stats.bd_wb_limit, val);
+        if (val == 0)
+                zram->stop_writeback = false;
+        up_read(&zram->init_lock);
+        ret = len;
+
+        return ret;
+}
+
+static ssize_t writeback_limit_show(struct device *dev,
+                struct device_attribute *attr, char *buf)
 {
-        return zram->backing_dev;
+        u64 val;
+        struct zram *zram = dev_to_zram(dev);
+
+        down_read(&zram->init_lock);
+        val = atomic64_read(&zram->stats.bd_wb_limit);
+        up_read(&zram->init_lock);
+
+        return scnprintf(buf, PAGE_SIZE, "%llu\n", val);
 }
 
 static void reset_bdev(struct zram *zram)
 {
         struct block_device *bdev;
 
-        if (!zram_wb_enabled(zram))
+        if (!zram->backing_dev)
                 return;
 
         bdev = zram->bdev;
@@ -313,7 +394,7 @@ static ssize_t backing_dev_show(struct device *dev,
         ssize_t ret;
 
         down_read(&zram->init_lock);
-        if (!zram_wb_enabled(zram)) {
+        if (!zram->backing_dev) {
                 memcpy(buf, "none\n", 5);
                 up_read(&zram->init_lock);
                 return 5;
@@ -382,8 +463,10 @@ static ssize_t backing_dev_store(struct device *dev,
 
         bdev = bdgrab(I_BDEV(inode));
         err = blkdev_get(bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL, zram);
-        if (err < 0)
+        if (err < 0) {
+                bdev = NULL;
                 goto out;
+        }
 
         nr_pages = i_size_read(inode) >> PAGE_SHIFT;
         bitmap_sz = BITS_TO_LONGS(nr_pages) * sizeof(long);
@@ -399,7 +482,6 @@ static ssize_t backing_dev_store(struct device *dev,
                 goto out;
 
         reset_bdev(zram);
-        spin_lock_init(&zram->bitmap_lock);
 
         zram->old_block_size = old_block_size;
         zram->bdev = bdev;
@@ -441,32 +523,29 @@ out:
         return err;
 }
 
-static unsigned long get_entry_bdev(struct zram *zram)
+static unsigned long alloc_block_bdev(struct zram *zram)
 {
-        unsigned long entry;
-
-        spin_lock(&zram->bitmap_lock);
+        unsigned long blk_idx = 1;
+retry:
         /* skip 0 bit to confuse zram.handle = 0 */
-        entry = find_next_zero_bit(zram->bitmap, zram->nr_pages, 1);
-        if (entry == zram->nr_pages) {
-                spin_unlock(&zram->bitmap_lock);
+        blk_idx = find_next_zero_bit(zram->bitmap, zram->nr_pages, blk_idx);
+        if (blk_idx == zram->nr_pages)
                 return 0;
-        }
 
-        set_bit(entry, zram->bitmap);
-        spin_unlock(&zram->bitmap_lock);
+        if (test_and_set_bit(blk_idx, zram->bitmap))
+                goto retry;
 
-        return entry;
+        atomic64_inc(&zram->stats.bd_count);
+        return blk_idx;
 }
 
-static void put_entry_bdev(struct zram *zram, unsigned long entry)
+static void free_block_bdev(struct zram *zram, unsigned long blk_idx)
 {
         int was_set;
 
-        spin_lock(&zram->bitmap_lock);
-        was_set = test_and_clear_bit(entry, zram->bitmap);
-        spin_unlock(&zram->bitmap_lock);
+        was_set = test_and_clear_bit(blk_idx, zram->bitmap);
         WARN_ON_ONCE(!was_set);
+        atomic64_dec(&zram->stats.bd_count);
 }
 
 static void zram_page_end_io(struct bio *bio)
@@ -509,6 +588,169 @@ static int read_from_bdev_async(struct zram *zram, struct bio_vec *bvec,
         return 1;
 }
 
+#define HUGE_WRITEBACK 0x1
+#define IDLE_WRITEBACK 0x2
+
+static ssize_t writeback_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t len)
+{
+        struct zram *zram = dev_to_zram(dev);
+        unsigned long nr_pages = zram->disksize >> PAGE_SHIFT;
+        unsigned long index;
+        struct bio bio;
+        struct bio_vec bio_vec;
+        struct page *page;
+        ssize_t ret, sz;
+        char mode_buf[8];
+        unsigned long mode = -1UL;
+        unsigned long blk_idx = 0;
+
+        sz = strscpy(mode_buf, buf, sizeof(mode_buf));
+        if (sz <= 0)
+                return -EINVAL;
+
+        /* ignore trailing newline */
+        if (mode_buf[sz - 1] == '\n')
+                mode_buf[sz - 1] = 0x00;
+
+        if (!strcmp(mode_buf, "idle"))
+                mode = IDLE_WRITEBACK;
+        else if (!strcmp(mode_buf, "huge"))
+                mode = HUGE_WRITEBACK;
+
+        if (mode == -1UL)
+                return -EINVAL;
+
+        down_read(&zram->init_lock);
+        if (!init_done(zram)) {
+                ret = -EINVAL;
+                goto release_init_lock;
+        }
+
+        if (!zram->backing_dev) {
+                ret = -ENODEV;
+                goto release_init_lock;
+        }
+
+        page = alloc_page(GFP_KERNEL);
+        if (!page) {
+                ret = -ENOMEM;
+                goto release_init_lock;
+        }
+
+        for (index = 0; index < nr_pages; index++) {
+                struct bio_vec bvec;
+
+                bvec.bv_page = page;
+                bvec.bv_len = PAGE_SIZE;
+                bvec.bv_offset = 0;
+
+                if (zram->stop_writeback) {
+                        ret = -EIO;
+                        break;
+                }
+
+                if (!blk_idx) {
+                        blk_idx = alloc_block_bdev(zram);
+                        if (!blk_idx) {
+                                ret = -ENOSPC;
+                                break;
+                        }
+                }
+
+                zram_slot_lock(zram, index);
+                if (!zram_allocated(zram, index))
+                        goto next;
+
+                if (zram_test_flag(zram, index, ZRAM_WB) ||
+                                zram_test_flag(zram, index, ZRAM_SAME) ||
+                                zram_test_flag(zram, index, ZRAM_UNDER_WB))
+                        goto next;
+
+                if ((mode & IDLE_WRITEBACK &&
+                          !zram_test_flag(zram, index, ZRAM_IDLE)) &&
+                    (mode & HUGE_WRITEBACK &&
+                          !zram_test_flag(zram, index, ZRAM_HUGE)))
+                        goto next;
+                /*
+                 * Clearing ZRAM_UNDER_WB is duty of caller.
+                 * IOW, zram_free_page never clear it.
+                 */
+                zram_set_flag(zram, index, ZRAM_UNDER_WB);
+                /* Need for hugepage writeback racing */
+                zram_set_flag(zram, index, ZRAM_IDLE);
+                zram_slot_unlock(zram, index);
+                if (zram_bvec_read(zram, &bvec, index, 0, NULL)) {
+                        zram_slot_lock(zram, index);
+                        zram_clear_flag(zram, index, ZRAM_UNDER_WB);
+                        zram_clear_flag(zram, index, ZRAM_IDLE);
+                        zram_slot_unlock(zram, index);
+                        continue;
+                }
+
+                bio_init(&bio, &bio_vec, 1);
+                bio_set_dev(&bio, zram->bdev);
+                bio.bi_iter.bi_sector = blk_idx * (PAGE_SIZE >> 9);
+                bio.bi_opf = REQ_OP_WRITE | REQ_SYNC;
+
+                bio_add_page(&bio, bvec.bv_page, bvec.bv_len,
+                                bvec.bv_offset);
+                /*
+                 * XXX: A single page IO would be inefficient for write
+                 * but it would be not bad as starter.
+                 */
+                ret = submit_bio_wait(&bio);
+                if (ret) {
+                        zram_slot_lock(zram, index);
+                        zram_clear_flag(zram, index, ZRAM_UNDER_WB);
+                        zram_clear_flag(zram, index, ZRAM_IDLE);
+                        zram_slot_unlock(zram, index);
+                        continue;
+                }
+
+                atomic64_inc(&zram->stats.bd_writes);
+                /*
+                 * We released zram_slot_lock so need to check if the slot was
+                 * changed. If there is freeing for the slot, we can catch it
+                 * easily by zram_allocated.
+                 * A subtle case is the slot is freed/reallocated/marked as
+                 * ZRAM_IDLE again. To close the race, idle_store doesn't
+                 * mark ZRAM_IDLE once it found the slot was ZRAM_UNDER_WB.
+                 * Thus, we could close the race by checking ZRAM_IDLE bit.
+                 */
+                zram_slot_lock(zram, index);
+                if (!zram_allocated(zram, index) ||
+                          !zram_test_flag(zram, index, ZRAM_IDLE)) {
+                        zram_clear_flag(zram, index, ZRAM_UNDER_WB);
+                        zram_clear_flag(zram, index, ZRAM_IDLE);
+                        goto next;
+                }
+
+                zram_free_page(zram, index);
+                zram_clear_flag(zram, index, ZRAM_UNDER_WB);
+                zram_set_flag(zram, index, ZRAM_WB);
+                zram_set_element(zram, index, blk_idx);
+                blk_idx = 0;
+                atomic64_inc(&zram->stats.pages_stored);
+                if (atomic64_add_unless(&zram->stats.bd_wb_limit,
+                                        -1 << (PAGE_SHIFT - 12), 0)) {
+                        if (atomic64_read(&zram->stats.bd_wb_limit) == 0)
+                                zram->stop_writeback = true;
+                }
+next:
+                zram_slot_unlock(zram, index);
+        }
+
+        if (blk_idx)
+                free_block_bdev(zram, blk_idx);
+        ret = len;
+        __free_page(page);
+release_init_lock:
+        up_read(&zram->init_lock);
+
+        return ret;
+}
+
 struct zram_work {
         struct work_struct work;
         struct zram *zram;
@@ -561,79 +803,21 @@ static int read_from_bdev_sync(struct zram *zram, struct bio_vec *bvec,
 static int read_from_bdev(struct zram *zram, struct bio_vec *bvec,
                         unsigned long entry, struct bio *parent, bool sync)
 {
+        atomic64_inc(&zram->stats.bd_reads);
         if (sync)
                 return read_from_bdev_sync(zram, bvec, entry, parent);
         else
                 return read_from_bdev_async(zram, bvec, entry, parent);
 }
-
-static int write_to_bdev(struct zram *zram, struct bio_vec *bvec,
-                                        u32 index, struct bio *parent,
-                                        unsigned long *pentry)
-{
-        struct bio *bio;
-        unsigned long entry;
-
-        bio = bio_alloc(GFP_ATOMIC, 1);
-        if (!bio)
-                return -ENOMEM;
-
-        entry = get_entry_bdev(zram);
-        if (!entry) {
-                bio_put(bio);
-                return -ENOSPC;
-        }
-
-        bio->bi_iter.bi_sector = entry * (PAGE_SIZE >> 9);
-        bio_set_dev(bio, zram->bdev);
-        if (!bio_add_page(bio, bvec->bv_page, bvec->bv_len,
-                                        bvec->bv_offset)) {
-                bio_put(bio);
-                put_entry_bdev(zram, entry);
-                return -EIO;
-        }
-
-        if (!parent) {
-                bio->bi_opf = REQ_OP_WRITE | REQ_SYNC;
-                bio->bi_end_io = zram_page_end_io;
-        } else {
-                bio->bi_opf = parent->bi_opf;
-                bio_chain(bio, parent);
-        }
-
-        submit_bio(bio);
-        *pentry = entry;
-
-        return 0;
-}
-
-static void zram_wb_clear(struct zram *zram, u32 index)
-{
-        unsigned long entry;
-
-        zram_clear_flag(zram, index, ZRAM_WB);
-        entry = zram_get_element(zram, index);
-        zram_set_element(zram, index, 0);
-        put_entry_bdev(zram, entry);
-}
-
 #else
-static bool zram_wb_enabled(struct zram *zram) { return false; }
 static inline void reset_bdev(struct zram *zram) {};
-static int write_to_bdev(struct zram *zram, struct bio_vec *bvec,
-                                        u32 index, struct bio *parent,
-                                        unsigned long *pentry)
-
-{
-        return -EIO;
-}
-
 static int read_from_bdev(struct zram *zram, struct bio_vec *bvec,
                         unsigned long entry, struct bio *parent, bool sync)
 {
         return -EIO;
 }
-static void zram_wb_clear(struct zram *zram, u32 index) {}
+
+static void free_block_bdev(struct zram *zram, unsigned long blk_idx) {};
 #endif
 
 #ifdef CONFIG_ZRAM_MEMORY_TRACKING
@@ -652,14 +836,10 @@ static void zram_debugfs_destroy(void)
 
 static void zram_accessed(struct zram *zram, u32 index)
 {
+        zram_clear_flag(zram, index, ZRAM_IDLE);
         zram->table[index].ac_time = ktime_get_boottime();
 }
 
-static void zram_reset_access(struct zram *zram, u32 index)
-{
-        zram->table[index].ac_time = 0;
-}
-
 static ssize_t read_block_state(struct file *file, char __user *buf,
                                 size_t count, loff_t *ppos)
 {
@@ -689,12 +869,13 @@ static ssize_t read_block_state(struct file *file, char __user *buf,
 
                 ts = ktime_to_timespec64(zram->table[index].ac_time);
                 copied = snprintf(kbuf + written, count,
-                        "%12zd %12lld.%06lu %c%c%c\n",
+                        "%12zd %12lld.%06lu %c%c%c%c\n",
                         index, (s64)ts.tv_sec,
                         ts.tv_nsec / NSEC_PER_USEC,
                         zram_test_flag(zram, index, ZRAM_SAME) ? 's' : '.',
                         zram_test_flag(zram, index, ZRAM_WB) ? 'w' : '.',
-                        zram_test_flag(zram, index, ZRAM_HUGE) ? 'h' : '.');
+                        zram_test_flag(zram, index, ZRAM_HUGE) ? 'h' : '.',
+                        zram_test_flag(zram, index, ZRAM_IDLE) ? 'i' : '.');
 
                 if (count < copied) {
                         zram_slot_unlock(zram, index);
@@ -739,8 +920,10 @@ static void zram_debugfs_unregister(struct zram *zram)
 #else
 static void zram_debugfs_create(void) {};
 static void zram_debugfs_destroy(void) {};
-static void zram_accessed(struct zram *zram, u32 index) {};
-static void zram_reset_access(struct zram *zram, u32 index) {};
+static void zram_accessed(struct zram *zram, u32 index)
+{
+        zram_clear_flag(zram, index, ZRAM_IDLE);
+};
 static void zram_debugfs_register(struct zram *zram) {};
 static void zram_debugfs_unregister(struct zram *zram) {};
 #endif
@@ -877,6 +1060,26 @@ static ssize_t mm_stat_show(struct device *dev,
         return ret;
 }
 
+#ifdef CONFIG_ZRAM_WRITEBACK
+#define FOUR_K(x) ((x) * (1 << (PAGE_SHIFT - 12)))
+static ssize_t bd_stat_show(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct zram *zram = dev_to_zram(dev);
+        ssize_t ret;
+
+        down_read(&zram->init_lock);
+        ret = scnprintf(buf, PAGE_SIZE,
+                "%8llu %8llu %8llu\n",
+                        FOUR_K((u64)atomic64_read(&zram->stats.bd_count)),
+                        FOUR_K((u64)atomic64_read(&zram->stats.bd_reads)),
+                        FOUR_K((u64)atomic64_read(&zram->stats.bd_writes)));
+        up_read(&zram->init_lock);
+
+        return ret;
+}
+#endif
+
 static ssize_t debug_stat_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
@@ -886,9 +1089,10 @@ static ssize_t debug_stat_show(struct device *dev,
 
         down_read(&zram->init_lock);
         ret = scnprintf(buf, PAGE_SIZE,
-                        "version: %d\n%8llu\n",
+                        "version: %d\n%8llu %8llu\n",
                         version,
-                        (u64)atomic64_read(&zram->stats.writestall));
+                        (u64)atomic64_read(&zram->stats.writestall),
+                        (u64)atomic64_read(&zram->stats.miss_free));
         up_read(&zram->init_lock);
 
         return ret;
@@ -896,6 +1100,9 @@ static ssize_t debug_stat_show(struct device *dev,
 
 static DEVICE_ATTR_RO(io_stat);
 static DEVICE_ATTR_RO(mm_stat);
+#ifdef CONFIG_ZRAM_WRITEBACK
+static DEVICE_ATTR_RO(bd_stat);
+#endif
 static DEVICE_ATTR_RO(debug_stat);
 
 static void zram_meta_free(struct zram *zram, u64 disksize)
@@ -940,17 +1147,21 @@ static void zram_free_page(struct zram *zram, size_t index)
 {
         unsigned long handle;
 
-        zram_reset_access(zram, index);
+#ifdef CONFIG_ZRAM_MEMORY_TRACKING
+        zram->table[index].ac_time = 0;
+#endif
+        if (zram_test_flag(zram, index, ZRAM_IDLE))
+                zram_clear_flag(zram, index, ZRAM_IDLE);
 
         if (zram_test_flag(zram, index, ZRAM_HUGE)) {
                 zram_clear_flag(zram, index, ZRAM_HUGE);
                 atomic64_dec(&zram->stats.huge_pages);
         }
 
-        if (zram_wb_enabled(zram) && zram_test_flag(zram, index, ZRAM_WB)) {
-                zram_wb_clear(zram, index);
-                atomic64_dec(&zram->stats.pages_stored);
-                return;
+        if (zram_test_flag(zram, index, ZRAM_WB)) {
+                zram_clear_flag(zram, index, ZRAM_WB);
+                free_block_bdev(zram, zram_get_element(zram, index));
+                goto out;
         }
 
         /*
@@ -959,10 +1170,8 @@ static void zram_free_page(struct zram *zram, size_t index)
          */
         if (zram_test_flag(zram, index, ZRAM_SAME)) {
                 zram_clear_flag(zram, index, ZRAM_SAME);
-                zram_set_element(zram, index, 0);
                 atomic64_dec(&zram->stats.same_pages);
-                atomic64_dec(&zram->stats.pages_stored);
-                return;
+                goto out;
         }
 
         handle = zram_get_handle(zram, index);
@@ -973,10 +1182,12 @@ static void zram_free_page(struct zram *zram, size_t index)
 
         atomic64_sub(zram_get_obj_size(zram, index),
                         &zram->stats.compr_data_size);
+out:
         atomic64_dec(&zram->stats.pages_stored);
-
         zram_set_handle(zram, index, 0);
         zram_set_obj_size(zram, index, 0);
+        WARN_ON_ONCE(zram->table[index].flags &
+                ~(1UL << ZRAM_LOCK | 1UL << ZRAM_UNDER_WB));
 }
 
 static int __zram_bvec_read(struct zram *zram, struct page *page, u32 index,
@@ -987,24 +1198,20 @@ static int __zram_bvec_read(struct zram *zram, struct page *page, u32 index,
         unsigned int size;
         void *src, *dst;
 
-        if (zram_wb_enabled(zram)) {
-                zram_slot_lock(zram, index);
-                if (zram_test_flag(zram, index, ZRAM_WB)) {
-                        struct bio_vec bvec;
-
-                        zram_slot_unlock(zram, index);
+        zram_slot_lock(zram, index);
+        if (zram_test_flag(zram, index, ZRAM_WB)) {
+                struct bio_vec bvec;
 
-                        bvec.bv_page = page;
-                        bvec.bv_len = PAGE_SIZE;
-                        bvec.bv_offset = 0;
-                        return read_from_bdev(zram, &bvec,
-                                        zram_get_element(zram, index),
-                                        bio, partial_io);
-                }
                 zram_slot_unlock(zram, index);
+
+                bvec.bv_page = page;
+                bvec.bv_len = PAGE_SIZE;
+                bvec.bv_offset = 0;
+                return read_from_bdev(zram, &bvec,
+                                zram_get_element(zram, index),
+                                bio, partial_io);
         }
 
-        zram_slot_lock(zram, index);
         handle = zram_get_handle(zram, index);
         if (!handle || zram_test_flag(zram, index, ZRAM_SAME)) {
                 unsigned long value;
@@ -1089,7 +1296,6 @@ static int __zram_bvec_write(struct zram *zram, struct bio_vec *bvec,
         struct page *page = bvec->bv_page;
         unsigned long element = 0;
         enum zram_pageflags flags = 0;
-        bool allow_wb = true;
 
         mem = kmap_atomic(page);
         if (page_same_filled(mem, &element)) {
@@ -1114,21 +1320,8 @@ compress_again:
                 return ret;
         }
 
-        if (unlikely(comp_len >= huge_class_size)) {
+        if (comp_len >= huge_class_size)
                 comp_len = PAGE_SIZE;
-                if (zram_wb_enabled(zram) && allow_wb) {
-                        zcomp_stream_put(zram->comp);
-                        ret = write_to_bdev(zram, bvec, index, bio, &element);
-                        if (!ret) {
-                                flags = ZRAM_WB;
-                                ret = 1;
-                                goto out;
-                        }
-                        allow_wb = false;
-                        goto compress_again;
-                }
-        }
-
         /*
          * handle allocation has 2 paths:
          * a) fast path is executed with preemption disabled (for
@@ -1400,10 +1593,14 @@ static void zram_slot_free_notify(struct block_device *bdev,
 
         zram = bdev->bd_disk->private_data;
 
-        zram_slot_lock(zram, index);
+        atomic64_inc(&zram->stats.notify_free);
+        if (!zram_slot_trylock(zram, index)) {
+                atomic64_inc(&zram->stats.miss_free);
+                return;
+        }
+
         zram_free_page(zram, index);
         zram_slot_unlock(zram, index);
-        atomic64_inc(&zram->stats.notify_free);
 }
 
 static int zram_rw_page(struct block_device *bdev, sector_t sector,
@@ -1608,10 +1805,13 @@ static DEVICE_ATTR_RO(initstate);
 static DEVICE_ATTR_WO(reset);
 static DEVICE_ATTR_WO(mem_limit);
 static DEVICE_ATTR_WO(mem_used_max);
+static DEVICE_ATTR_WO(idle);
 static DEVICE_ATTR_RW(max_comp_streams);
 static DEVICE_ATTR_RW(comp_algorithm);
 #ifdef CONFIG_ZRAM_WRITEBACK
 static DEVICE_ATTR_RW(backing_dev);
+static DEVICE_ATTR_WO(writeback);
+static DEVICE_ATTR_RW(writeback_limit);
 #endif
 
 static struct attribute *zram_disk_attrs[] = {
@@ -1621,13 +1821,19 @@ static struct attribute *zram_disk_attrs[] = {
         &dev_attr_compact.attr,
         &dev_attr_mem_limit.attr,
         &dev_attr_mem_used_max.attr,
+        &dev_attr_idle.attr,
         &dev_attr_max_comp_streams.attr,
         &dev_attr_comp_algorithm.attr,
 #ifdef CONFIG_ZRAM_WRITEBACK
         &dev_attr_backing_dev.attr,
+        &dev_attr_writeback.attr,
+        &dev_attr_writeback_limit.attr,
 #endif
         &dev_attr_io_stat.attr,
         &dev_attr_mm_stat.attr,
+#ifdef CONFIG_ZRAM_WRITEBACK
+        &dev_attr_bd_stat.attr,
+#endif
         &dev_attr_debug_stat.attr,
         NULL,
 };
diff --git a/drivers/block/zram/zram_drv.h b/drivers/block/zram/zram_drv.h
index 72c8584b6dff..4bd3afd15e83 100644
--- a/drivers/block/zram/zram_drv.h
+++ b/drivers/block/zram/zram_drv.h
@@ -30,7 +30,7 @@
 
 
 /*
- * The lower ZRAM_FLAG_SHIFT bits of table.value is for
+ * The lower ZRAM_FLAG_SHIFT bits of table.flags is for
  * object size (excluding header), the higher bits is for
  * zram_pageflags.
  *
@@ -41,13 +41,15 @@
  */
 #define ZRAM_FLAG_SHIFT 24
 
-/* Flags for zram pages (table[page_no].value) */
+/* Flags for zram pages (table[page_no].flags) */
 enum zram_pageflags {
         /* zram slot is locked */
         ZRAM_LOCK = ZRAM_FLAG_SHIFT,
         ZRAM_SAME,      /* Page consists the same element */
         ZRAM_WB,        /* page is stored on backing_device */
+        ZRAM_UNDER_WB,  /* page is under writeback */
         ZRAM_HUGE,      /* Incompressible page */
+        ZRAM_IDLE,      /* not accessed page since last idle marking */
 
         __NR_ZRAM_PAGEFLAGS,
 };
@@ -60,7 +62,7 @@ struct zram_table_entry {
                 unsigned long handle;
                 unsigned long element;
         };
-        unsigned long value;
+        unsigned long flags;
 #ifdef CONFIG_ZRAM_MEMORY_TRACKING
         ktime_t ac_time;
 #endif
@@ -79,6 +81,13 @@ struct zram_stats {
         atomic64_t pages_stored;        /* no. of pages currently stored */
         atomic_long_t max_used_pages;   /* no. of maximum pages stored */
         atomic64_t writestall;          /* no. of write slow paths */
+        atomic64_t miss_free;           /* no. of missed free */
+#ifdef  CONFIG_ZRAM_WRITEBACK
+        atomic64_t bd_count;            /* no. of pages in backing device */
+        atomic64_t bd_reads;            /* no. of reads from backing device */
+        atomic64_t bd_writes;           /* no. of writes from backing device */
+        atomic64_t bd_wb_limit;         /* writeback limit of backing device */
+#endif
 };
 
 struct zram {
@@ -104,13 +113,13 @@ struct zram {
          * zram is claimed so open request will be failed
          */
         bool claim; /* Protected by bdev->bd_mutex */
-#ifdef CONFIG_ZRAM_WRITEBACK
         struct file *backing_dev;
+        bool stop_writeback;
+#ifdef CONFIG_ZRAM_WRITEBACK
         struct block_device *bdev;
         unsigned int old_block_size;
         unsigned long *bitmap;
         unsigned long nr_pages;
-        spinlock_t bitmap_lock;
 #endif
 #ifdef CONFIG_ZRAM_MEMORY_TRACKING
         struct dentry *debugfs_dir;
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/dax/pmem.c b/drivers/dax/pmem.c
index 99e2aace8078..2c1f459c0c63 100644
--- a/drivers/dax/pmem.c
+++ b/drivers/dax/pmem.c
@@ -48,9 +48,8 @@ static void dax_pmem_percpu_exit(void *data)
         percpu_ref_exit(ref);
 }
 
-static void dax_pmem_percpu_kill(void *data)
+static void dax_pmem_percpu_kill(struct percpu_ref *ref)
 {
-        struct percpu_ref *ref = data;
         struct dax_pmem *dax_pmem = to_dax_pmem(ref);
 
         dev_dbg(dax_pmem->dev, "trace\n");
@@ -112,17 +111,10 @@ static int dax_pmem_probe(struct device *dev)
         }
 
         dax_pmem->pgmap.ref = &dax_pmem->ref;
+        dax_pmem->pgmap.kill = dax_pmem_percpu_kill;
         addr = devm_memremap_pages(dev, &dax_pmem->pgmap);
-        if (IS_ERR(addr)) {
-                devm_remove_action(dev, dax_pmem_percpu_exit, &dax_pmem->ref);
-                percpu_ref_exit(&dax_pmem->ref);
+        if (IS_ERR(addr))
                 return PTR_ERR(addr);
-        }
-
-        rc = devm_add_action_or_reset(dev, dax_pmem_percpu_kill,
-                                                        &dax_pmem->ref);
-        if (rc)
-                return rc;
 
         /* adjust the dax_region resource to the start of data */
         memcpy(&res, &dax_pmem->pgmap.res, sizeof(res));
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c
index e55508b39496..3e6823fdd939 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c
@@ -238,44 +238,40 @@ static void amdgpu_mn_invalidate_node(struct amdgpu_mn_node *node,
  * amdgpu_mn_invalidate_range_start_gfx - callback to notify about mm change
  *
  * @mn: our notifier
- * @mm: the mm this callback is about
- * @start: start of updated range
- * @end: end of updated range
+ * @range: mmu notifier context
  *
  * Block for operations on BOs to finish and mark pages as accessed and
  * potentially dirty.
  */
 static int amdgpu_mn_invalidate_range_start_gfx(struct mmu_notifier *mn,
-                                                 struct mm_struct *mm,
-                                                 unsigned long start,
-                                                 unsigned long end,
-                                                 bool blockable)
+                        const struct mmu_notifier_range *range)
 {
         struct amdgpu_mn *amn = container_of(mn, struct amdgpu_mn, mn);
         struct interval_tree_node *it;
+        unsigned long end;
 
         /* notification is exclusive, but interval is inclusive */
-        end -= 1;
+        end = range->end - 1;
 
         /* TODO we should be able to split locking for interval tree and
          * amdgpu_mn_invalidate_node
          */
-        if (amdgpu_mn_read_lock(amn, blockable))
+        if (amdgpu_mn_read_lock(amn, range->blockable))
                 return -EAGAIN;
 
-        it = interval_tree_iter_first(&amn->objects, start, end);
+        it = interval_tree_iter_first(&amn->objects, range->start, end);
         while (it) {
                 struct amdgpu_mn_node *node;
 
-                if (!blockable) {
+                if (!range->blockable) {
                         amdgpu_mn_read_unlock(amn);
                         return -EAGAIN;
                 }
 
                 node = container_of(it, struct amdgpu_mn_node, it);
-                it = interval_tree_iter_next(it, start, end);
+                it = interval_tree_iter_next(it, range->start, end);
 
-                amdgpu_mn_invalidate_node(node, start, end);
+                amdgpu_mn_invalidate_node(node, range->start, end);
         }
 
         return 0;
@@ -294,39 +290,38 @@ static int amdgpu_mn_invalidate_range_start_gfx(struct mmu_notifier *mn,
  * are restorted in amdgpu_mn_invalidate_range_end_hsa.
  */
 static int amdgpu_mn_invalidate_range_start_hsa(struct mmu_notifier *mn,
-                                                 struct mm_struct *mm,
-                                                 unsigned long start,
-                                                 unsigned long end,
-                                                 bool blockable)
+                        const struct mmu_notifier_range *range)
 {
         struct amdgpu_mn *amn = container_of(mn, struct amdgpu_mn, mn);
         struct interval_tree_node *it;
+        unsigned long end;
 
         /* notification is exclusive, but interval is inclusive */
-        end -= 1;
+        end = range->end - 1;
 
-        if (amdgpu_mn_read_lock(amn, blockable))
+        if (amdgpu_mn_read_lock(amn, range->blockable))
                 return -EAGAIN;
 
-        it = interval_tree_iter_first(&amn->objects, start, end);
+        it = interval_tree_iter_first(&amn->objects, range->start, end);
         while (it) {
                 struct amdgpu_mn_node *node;
                 struct amdgpu_bo *bo;
 
-                if (!blockable) {
+                if (!range->blockable) {
                         amdgpu_mn_read_unlock(amn);
                         return -EAGAIN;
                 }
 
                 node = container_of(it, struct amdgpu_mn_node, it);
-                it = interval_tree_iter_next(it, start, end);
+                it = interval_tree_iter_next(it, range->start, end);
 
                 list_for_each_entry(bo, &node->bos, mn_list) {
                         struct kgd_mem *mem = bo->kfd_bo;
 
                         if (amdgpu_ttm_tt_affect_userptr(bo->tbo.ttm,
-                                                         start, end))
-                                amdgpu_amdkfd_evict_userptr(mem, mm);
+                                                         range->start,
+                                                         end))
+                                amdgpu_amdkfd_evict_userptr(mem, range->mm);
                 }
         }
 
@@ -344,9 +339,7 @@ static int amdgpu_mn_invalidate_range_start_hsa(struct mmu_notifier *mn,
  * Release the lock again to allow new command submissions.
  */
 static void amdgpu_mn_invalidate_range_end(struct mmu_notifier *mn,
-                                           struct mm_struct *mm,
-                                           unsigned long start,
-                                           unsigned long end)
+                        const struct mmu_notifier_range *range)
 {
         struct amdgpu_mn *amn = container_of(mn, struct amdgpu_mn, mn);
 
diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_crat.c b/drivers/gpu/drm/amd/amdkfd/kfd_crat.c
index c02adbbeef2a..b7bc7d7d048f 100644
--- a/drivers/gpu/drm/amd/amdkfd/kfd_crat.c
+++ b/drivers/gpu/drm/amd/amdkfd/kfd_crat.c
@@ -853,7 +853,7 @@ static int kfd_fill_mem_info_for_cpu(int numa_node_id, int *avail_size,
          */
         pgdat = NODE_DATA(numa_node_id);
         for (zone_type = 0; zone_type < MAX_NR_ZONES; zone_type++)
-                mem_in_bytes += pgdat->node_zones[zone_type].managed_pages;
+                mem_in_bytes += zone_managed_pages(&pgdat->node_zones[zone_type]);
         mem_in_bytes <<= PAGE_SHIFT;
 
         sub_type_hdr->length_low = lower_32_bits(mem_in_bytes);
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/i915_gem_userptr.c b/drivers/gpu/drm/i915/i915_gem_userptr.c
index 2c9b284036d1..3df77020aada 100644
--- a/drivers/gpu/drm/i915/i915_gem_userptr.c
+++ b/drivers/gpu/drm/i915/i915_gem_userptr.c
@@ -113,27 +113,25 @@ static void del_object(struct i915_mmu_object *mo)
 }
 
 static int i915_gem_userptr_mn_invalidate_range_start(struct mmu_notifier *_mn,
-                                                       struct mm_struct *mm,
-                                                       unsigned long start,
-                                                       unsigned long end,
-                                                       bool blockable)
+                        const struct mmu_notifier_range *range)
 {
         struct i915_mmu_notifier *mn =
                 container_of(_mn, struct i915_mmu_notifier, mn);
         struct i915_mmu_object *mo;
         struct interval_tree_node *it;
         LIST_HEAD(cancelled);
+        unsigned long end;
 
         if (RB_EMPTY_ROOT(&mn->objects.rb_root))
                 return 0;
 
         /* interval ranges are inclusive, but invalidate range is exclusive */
-        end--;
+        end = range->end - 1;
 
         spin_lock(&mn->lock);
-        it = interval_tree_iter_first(&mn->objects, start, end);
+        it = interval_tree_iter_first(&mn->objects, range->start, end);
         while (it) {
-                if (!blockable) {
+                if (!range->blockable) {
                         spin_unlock(&mn->lock);
                         return -EAGAIN;
                 }
@@ -151,7 +149,7 @@ static int i915_gem_userptr_mn_invalidate_range_start(struct mmu_notifier *_mn,
                         queue_work(mn->wq, &mo->work);
 
                 list_add(&mo->link, &cancelled);
-                it = interval_tree_iter_next(it, start, end);
+                it = interval_tree_iter_next(it, range->start, end);
         }
         list_for_each_entry(mo, &cancelled, link)
                 del_object(mo);
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/gpu/drm/radeon/radeon_mn.c b/drivers/gpu/drm/radeon/radeon_mn.c
index f8b35df44c60..b3019505065a 100644
--- a/drivers/gpu/drm/radeon/radeon_mn.c
+++ b/drivers/gpu/drm/radeon/radeon_mn.c
@@ -119,40 +119,38 @@ static void radeon_mn_release(struct mmu_notifier *mn,
  * unmap them by move them into system domain again.
  */
 static int radeon_mn_invalidate_range_start(struct mmu_notifier *mn,
-                                             struct mm_struct *mm,
-                                             unsigned long start,
-                                             unsigned long end,
-                                             bool blockable)
+                                const struct mmu_notifier_range *range)
 {
         struct radeon_mn *rmn = container_of(mn, struct radeon_mn, mn);
         struct ttm_operation_ctx ctx = { false, false };
         struct interval_tree_node *it;
+        unsigned long end;
         int ret = 0;
 
         /* notification is exclusive, but interval is inclusive */
-        end -= 1;
+        end = range->end - 1;
 
         /* TODO we should be able to split locking for interval tree and
          * the tear down.
          */
-        if (blockable)
+        if (range->blockable)
                 mutex_lock(&rmn->lock);
         else if (!mutex_trylock(&rmn->lock))
                 return -EAGAIN;
 
-        it = interval_tree_iter_first(&rmn->objects, start, end);
+        it = interval_tree_iter_first(&rmn->objects, range->start, end);
         while (it) {
                 struct radeon_mn_node *node;
                 struct radeon_bo *bo;
                 long r;
 
-                if (!blockable) {
+                if (!range->blockable) {
                         ret = -EAGAIN;
                         goto out_unlock;
                 }
 
                 node = container_of(it, struct radeon_mn_node, it);
-                it = interval_tree_iter_next(it, start, end);
+                it = interval_tree_iter_next(it, range->start, end);
 
                 list_for_each_entry(bo, &node->bos, mn_list) {
 
diff --git a/drivers/hv/hv_balloon.c b/drivers/hv/hv_balloon.c
index 41631512ae97..5301fef16c31 100644
--- a/drivers/hv/hv_balloon.c
+++ b/drivers/hv/hv_balloon.c
@@ -1090,6 +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();
 #define MB2PAGES(mb) ((mb) << (20 - PAGE_SHIFT))
         /* Simple continuous piecewiese linear function:
          *  max MiB -> min MiB  gradient
@@ -1102,16 +1103,16 @@ static unsigned long compute_balloon_floor(void)
          *    8192       744    (1/16)
          *   32768      1512    (1/32)
          */
-        if (totalram_pages < MB2PAGES(128))
-                min_pages = MB2PAGES(8) + (totalram_pages >> 1);
-        else if (totalram_pages < MB2PAGES(512))
-                min_pages = MB2PAGES(40) + (totalram_pages >> 2);
-        else if (totalram_pages < MB2PAGES(2048))
-                min_pages = MB2PAGES(104) + (totalram_pages >> 3);
-        else if (totalram_pages < MB2PAGES(8192))
-                min_pages = MB2PAGES(232) + (totalram_pages >> 4);
+        if (nr_pages < MB2PAGES(128))
+                min_pages = MB2PAGES(8) + (nr_pages >> 1);
+        else if (nr_pages < MB2PAGES(512))
+                min_pages = MB2PAGES(40) + (nr_pages >> 2);
+        else if (nr_pages < MB2PAGES(2048))
+                min_pages = MB2PAGES(104) + (nr_pages >> 3);
+        else if (nr_pages < MB2PAGES(8192))
+                min_pages = MB2PAGES(232) + (nr_pages >> 4);
         else
-                min_pages = MB2PAGES(488) + (totalram_pages >> 5);
+                min_pages = MB2PAGES(488) + (nr_pages >> 5);
 #undef MB2PAGES
         return min_pages;
 }
diff --git a/drivers/infiniband/core/umem_odp.c b/drivers/infiniband/core/umem_odp.c
index 9608681224e6..a4ec43093cb3 100644
--- a/drivers/infiniband/core/umem_odp.c
+++ b/drivers/infiniband/core/umem_odp.c
@@ -146,15 +146,12 @@ static int invalidate_range_start_trampoline(struct ib_umem_odp *item,
 }
 
 static int ib_umem_notifier_invalidate_range_start(struct mmu_notifier *mn,
-                                                    struct mm_struct *mm,
-                                                    unsigned long start,
-                                                    unsigned long end,
-                                                    bool blockable)
+                                const struct mmu_notifier_range *range)
 {
         struct ib_ucontext_per_mm *per_mm =
                 container_of(mn, struct ib_ucontext_per_mm, mn);
 
-        if (blockable)
+        if (range->blockable)
                 down_read(&per_mm->umem_rwsem);
         else if (!down_read_trylock(&per_mm->umem_rwsem))
                 return -EAGAIN;
@@ -169,9 +166,10 @@ static int ib_umem_notifier_invalidate_range_start(struct mmu_notifier *mn,
                 return 0;
         }
 
-        return rbt_ib_umem_for_each_in_range(&per_mm->umem_tree, start, end,
+        return rbt_ib_umem_for_each_in_range(&per_mm->umem_tree, range->start,
+                                             range->end,
                                              invalidate_range_start_trampoline,
-                                             blockable, NULL);
+                                             range->blockable, NULL);
 }
 
 static int invalidate_range_end_trampoline(struct ib_umem_odp *item, u64 start,
@@ -182,9 +180,7 @@ static int invalidate_range_end_trampoline(struct ib_umem_odp *item, u64 start,
 }
 
 static void ib_umem_notifier_invalidate_range_end(struct mmu_notifier *mn,
-                                                  struct mm_struct *mm,
-                                                  unsigned long start,
-                                                  unsigned long end)
+                                const struct mmu_notifier_range *range)
 {
         struct ib_ucontext_per_mm *per_mm =
                 container_of(mn, struct ib_ucontext_per_mm, mn);
@@ -192,8 +188,8 @@ static void ib_umem_notifier_invalidate_range_end(struct mmu_notifier *mn,
         if (unlikely(!per_mm->active))
                 return;
 
-        rbt_ib_umem_for_each_in_range(&per_mm->umem_tree, start,
-                                      end,
+        rbt_ib_umem_for_each_in_range(&per_mm->umem_tree, range->start,
+                                      range->end,
                                       invalidate_range_end_trampoline, true, NULL);
         up_read(&per_mm->umem_rwsem);
 }
diff --git a/drivers/infiniband/hw/hfi1/mmu_rb.c b/drivers/infiniband/hw/hfi1/mmu_rb.c
index 475b769e120c..14d2a90964c3 100644
--- a/drivers/infiniband/hw/hfi1/mmu_rb.c
+++ b/drivers/infiniband/hw/hfi1/mmu_rb.c
@@ -68,8 +68,7 @@ struct mmu_rb_handler {
 static unsigned long mmu_node_start(struct mmu_rb_node *);
 static unsigned long mmu_node_last(struct mmu_rb_node *);
 static int mmu_notifier_range_start(struct mmu_notifier *,
-                                     struct mm_struct *,
-                                     unsigned long, unsigned long, bool);
+                const struct mmu_notifier_range *);
 static struct mmu_rb_node *__mmu_rb_search(struct mmu_rb_handler *,
                                            unsigned long, unsigned long);
 static void do_remove(struct mmu_rb_handler *handler,
@@ -284,10 +283,7 @@ void hfi1_mmu_rb_remove(struct mmu_rb_handler *handler,
 }
 
 static int mmu_notifier_range_start(struct mmu_notifier *mn,
-                                     struct mm_struct *mm,
-                                     unsigned long start,
-                                     unsigned long end,
-                                     bool blockable)
+                const struct mmu_notifier_range *range)
 {
         struct mmu_rb_handler *handler =
                 container_of(mn, struct mmu_rb_handler, mn);
@@ -297,10 +293,11 @@ static int mmu_notifier_range_start(struct mmu_notifier *mn,
         bool added = false;
 
         spin_lock_irqsave(&handler->lock, flags);
-        for (node = __mmu_int_rb_iter_first(root, start, end - 1);
+        for (node = __mmu_int_rb_iter_first(root, range->start, range->end-1);
              node; node = ptr) {
                 /* Guard against node removal. */
-                ptr = __mmu_int_rb_iter_next(node, start, end - 1);
+                ptr = __mmu_int_rb_iter_next(node, range->start,
+                                             range->end - 1);
                 trace_hfi1_mmu_mem_invalidate(node->addr, node->len);
                 if (handler->ops->invalidate(handler->ops_arg, node)) {
                         __mmu_int_rb_remove(node, root);
diff --git a/drivers/md/dm-bufio.c b/drivers/md/dm-bufio.c
index 0e9fcceaefd2..1ecef76225a1 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 1ea73ace9b9e..0ff22159a0ca 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -2167,7 +2167,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 2b27abfa428d..457200ca6287 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/mic/scif/scif_dma.c b/drivers/misc/mic/scif/scif_dma.c
index 18b8ed57c4ac..e0d97044d0e9 100644
--- a/drivers/misc/mic/scif/scif_dma.c
+++ b/drivers/misc/mic/scif/scif_dma.c
@@ -201,23 +201,18 @@ static void scif_mmu_notifier_release(struct mmu_notifier *mn,
 }
 
 static int scif_mmu_notifier_invalidate_range_start(struct mmu_notifier *mn,
-                                                     struct mm_struct *mm,
-                                                     unsigned long start,
-                                                     unsigned long end,
-                                                     bool blockable)
+                                        const struct mmu_notifier_range *range)
 {
         struct scif_mmu_notif   *mmn;
 
         mmn = container_of(mn, struct scif_mmu_notif, ep_mmu_notifier);
-        scif_rma_destroy_tcw(mmn, start, end - start);
+        scif_rma_destroy_tcw(mmn, range->start, range->end - range->start);
 
         return 0;
 }
 
 static void scif_mmu_notifier_invalidate_range_end(struct mmu_notifier *mn,
-                                                   struct mm_struct *mm,
-                                                   unsigned long start,
-                                                   unsigned long end)
+                        const struct mmu_notifier_range *range)
 {
         /*
          * Nothing to do here, everything needed was done in
diff --git a/drivers/misc/sgi-gru/grutlbpurge.c b/drivers/misc/sgi-gru/grutlbpurge.c
index 03b49d52092e..ca2032afe035 100644
--- a/drivers/misc/sgi-gru/grutlbpurge.c
+++ b/drivers/misc/sgi-gru/grutlbpurge.c
@@ -220,9 +220,7 @@ void gru_flush_all_tlb(struct gru_state *gru)
  * MMUOPS notifier callout functions
  */
 static int gru_invalidate_range_start(struct mmu_notifier *mn,
-                                       struct mm_struct *mm,
-                                       unsigned long start, unsigned long end,
-                                       bool blockable)
+                        const struct mmu_notifier_range *range)
 {
         struct gru_mm_struct *gms = container_of(mn, struct gru_mm_struct,
                                                  ms_notifier);
@@ -230,15 +228,14 @@ static int gru_invalidate_range_start(struct mmu_notifier *mn,
         STAT(mmu_invalidate_range);
         atomic_inc(&gms->ms_range_active);
         gru_dbg(grudev, "gms %p, start 0x%lx, end 0x%lx, act %d\n", gms,
-                start, end, atomic_read(&gms->ms_range_active));
-        gru_flush_tlb_range(gms, start, end - start);
+                range->start, range->end, atomic_read(&gms->ms_range_active));
+        gru_flush_tlb_range(gms, range->start, range->end - range->start);
 
         return 0;
 }
 
 static void gru_invalidate_range_end(struct mmu_notifier *mn,
-                                     struct mm_struct *mm, unsigned long start,
-                                     unsigned long end)
+                        const struct mmu_notifier_range *range)
 {
         struct gru_mm_struct *gms = container_of(mn, struct gru_mm_struct,
                                                  ms_notifier);
@@ -247,7 +244,8 @@ static void gru_invalidate_range_end(struct mmu_notifier *mn,
         (void)atomic_dec_and_test(&gms->ms_range_active);
 
         wake_up_all(&gms->ms_wait_queue);
-        gru_dbg(grudev, "gms %p, start 0x%lx, end 0x%lx\n", gms, start, end);
+        gru_dbg(grudev, "gms %p, start 0x%lx, end 0x%lx\n",
+                gms, range->start, range->end);
 }
 
 static void gru_release(struct mmu_notifier *mn, struct mm_struct *mm)
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/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
index f7019294740c..bc2f700feef8 100644
--- a/drivers/nvdimm/pmem.c
+++ b/drivers/nvdimm/pmem.c
@@ -309,8 +309,11 @@ static void pmem_release_queue(void *q)
         blk_cleanup_queue(q);
 }
 
-static void pmem_freeze_queue(void *q)
+static void pmem_freeze_queue(struct percpu_ref *ref)
 {
+        struct request_queue *q;
+
+        q = container_of(ref, typeof(*q), q_usage_counter);
         blk_freeze_queue_start(q);
 }
 
@@ -402,6 +405,7 @@ static int pmem_attach_disk(struct device *dev,
 
         pmem->pfn_flags = PFN_DEV;
         pmem->pgmap.ref = &q->q_usage_counter;
+        pmem->pgmap.kill = pmem_freeze_queue;
         if (is_nd_pfn(dev)) {
                 if (setup_pagemap_fsdax(dev, &pmem->pgmap))
                         return -ENOMEM;
@@ -427,13 +431,6 @@ static int pmem_attach_disk(struct device *dev,
                 memcpy(&bb_res, &nsio->res, sizeof(bb_res));
         }
 
-        /*
-         * At release time the queue must be frozen before
-         * devm_memremap_pages is unwound
-         */
-        if (devm_add_action_or_reset(dev, pmem_freeze_queue, q))
-                return -ENOMEM;
-
         if (IS_ERR(addr))
                 return PTR_ERR(addr);
         pmem->virt_addr = addr;
diff --git a/drivers/parisc/ccio-dma.c b/drivers/parisc/ccio-dma.c
index 714aac72df0e..8d2fc84119c6 100644
--- a/drivers/parisc/ccio-dma.c
+++ b/drivers/parisc/ccio-dma.c
@@ -1243,7 +1243,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 */
 
@@ -1282,7 +1282,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 452d306ce5cb..42172eb32235 100644
--- a/drivers/parisc/sba_iommu.c
+++ b/drivers/parisc/sba_iommu.c
@@ -1406,7 +1406,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))) {
@@ -1431,7 +1431,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/pci/p2pdma.c b/drivers/pci/p2pdma.c
index ae3c5b25dcc7..a2eb25271c96 100644
--- a/drivers/pci/p2pdma.c
+++ b/drivers/pci/p2pdma.c
@@ -82,10 +82,8 @@ static void pci_p2pdma_percpu_release(struct percpu_ref *ref)
         complete_all(&p2p->devmap_ref_done);
 }
 
-static void pci_p2pdma_percpu_kill(void *data)
+static void pci_p2pdma_percpu_kill(struct percpu_ref *ref)
 {
-        struct percpu_ref *ref = data;
-
         /*
          * pci_p2pdma_add_resource() may be called multiple times
          * by a driver and may register the percpu_kill devm action multiple
@@ -198,6 +196,7 @@ int pci_p2pdma_add_resource(struct pci_dev *pdev, int bar, size_t size,
         pgmap->type = MEMORY_DEVICE_PCI_P2PDMA;
         pgmap->pci_p2pdma_bus_offset = pci_bus_address(pdev, bar) -
                 pci_resource_start(pdev, bar);
+        pgmap->kill = pci_p2pdma_percpu_kill;
 
         addr = devm_memremap_pages(&pdev->dev, pgmap);
         if (IS_ERR(addr)) {
@@ -211,11 +210,6 @@ int pci_p2pdma_add_resource(struct pci_dev *pdev, int bar, size_t size,
         if (error)
                 goto pgmap_free;
 
-        error = devm_add_action_or_reset(&pdev->dev, pci_p2pdma_percpu_kill,
-                                          &pdev->p2pdma->devmap_ref);
-        if (error)
-                goto pgmap_free;
-
         pci_info(pdev, "added peer-to-peer DMA memory %pR\n",
                  &pgmap->res);
 
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/balloon.c b/drivers/xen/balloon.c
index 221b7333d067..ceb5048de9a7 100644
--- a/drivers/xen/balloon.c
+++ b/drivers/xen/balloon.c
@@ -352,7 +352,7 @@ static enum bp_state reserve_additional_memory(void)
         mutex_unlock(&balloon_mutex);
         /* add_memory_resource() requires the device_hotplug lock */
         lock_device_hotplug();
-        rc = add_memory_resource(nid, resource, memhp_auto_online);
+        rc = add_memory_resource(nid, resource);
         unlock_device_hotplug();
         mutex_lock(&balloon_mutex);
 
diff --git a/drivers/xen/gntdev.c b/drivers/xen/gntdev.c
index b0b02a501167..5efc5eee9544 100644
--- a/drivers/xen/gntdev.c
+++ b/drivers/xen/gntdev.c
@@ -520,26 +520,26 @@ static int unmap_if_in_range(struct gntdev_grant_map *map,
 }
 
 static int mn_invl_range_start(struct mmu_notifier *mn,
-                                struct mm_struct *mm,
-                                unsigned long start, unsigned long end,
-                                bool blockable)
+                               const struct mmu_notifier_range *range)
 {
         struct gntdev_priv *priv = container_of(mn, struct gntdev_priv, mn);
         struct gntdev_grant_map *map;
         int ret = 0;
 
-        if (blockable)
+        if (range->blockable)
                 mutex_lock(&priv->lock);
         else if (!mutex_trylock(&priv->lock))
                 return -EAGAIN;
 
         list_for_each_entry(map, &priv->maps, next) {
-                ret = unmap_if_in_range(map, start, end, blockable);
+                ret = unmap_if_in_range(map, range->start, range->end,
+                                        range->blockable);
                 if (ret)
                         goto out_unlock;
         }
         list_for_each_entry(map, &priv->freeable_maps, next) {
-                ret = unmap_if_in_range(map, start, end, blockable);
+                ret = unmap_if_in_range(map, range->start, range->end,
+                                        range->blockable);
                 if (ret)
                         goto out_unlock;
         }
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);