3 files changed, 25 insertions, 25 deletions

diff --git a/mm/memblock.c b/mm/memblock.c
index 81ae63ca78d0..0068f87af1e8 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1950,7 +1950,7 @@ void reset_node_managed_pages(pg_data_t *pgdat)
         struct zone *z;
 
         for (z = pgdat->node_zones; z < pgdat->node_zones + MAX_NR_ZONES; z++)
-                z->managed_pages = 0;
+                atomic_long_set(&z->managed_pages, 0);
 }
 
 void __init reset_all_zones_managed_pages(void)
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index b79e79caea99..4b5c4ff68f18 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1280,7 +1280,7 @@ static void __init __free_pages_boot_core(struct page *page, unsigned int order)
         __ClearPageReserved(p);
         set_page_count(p, 0);
 
-        page_zone(page)->managed_pages += nr_pages;
+        atomic_long_add(nr_pages, &page_zone(page)->managed_pages);
         set_page_refcounted(page);
         __free_pages(page, order);
 }
@@ -2259,7 +2259,7 @@ static void reserve_highatomic_pageblock(struct page *page, struct zone *zone,
          * Limit the number reserved to 1 pageblock or roughly 1% of a zone.
          * Check is race-prone but harmless.
          */
-        max_managed = (zone->managed_pages / 100) + pageblock_nr_pages;
+        max_managed = (zone_managed_pages(zone) / 100) + pageblock_nr_pages;
         if (zone->nr_reserved_highatomic >= max_managed)
                 return;
 
@@ -4661,7 +4661,7 @@ static unsigned long nr_free_zone_pages(int offset)
         struct zonelist *zonelist = node_zonelist(numa_node_id(), GFP_KERNEL);
 
         for_each_zone_zonelist(zone, z, zonelist, offset) {
-                unsigned long size = zone->managed_pages;
+                unsigned long size = zone_managed_pages(zone);
                 unsigned long high = high_wmark_pages(zone);
                 if (size > high)
                         sum += size - high;
@@ -4768,7 +4768,7 @@ void si_meminfo_node(struct sysinfo *val, int nid)
         pg_data_t *pgdat = NODE_DATA(nid);
 
         for (zone_type = 0; zone_type < MAX_NR_ZONES; zone_type++)
-                managed_pages += pgdat->node_zones[zone_type].managed_pages;
+                managed_pages += zone_managed_pages(&pgdat->node_zones[zone_type]);
         val->totalram = managed_pages;
         val->sharedram = node_page_state(pgdat, NR_SHMEM);
         val->freeram = sum_zone_node_page_state(nid, NR_FREE_PAGES);
@@ -4777,7 +4777,7 @@ void si_meminfo_node(struct sysinfo *val, int nid)
                 struct zone *zone = &pgdat->node_zones[zone_type];
 
                 if (is_highmem(zone)) {
-                        managed_highpages += zone->managed_pages;
+                        managed_highpages += zone_managed_pages(zone);
                         free_highpages += zone_page_state(zone, NR_FREE_PAGES);
                 }
         }
@@ -4984,7 +4984,7 @@ void show_free_areas(unsigned int filter, nodemask_t *nodemask)
                         K(zone_page_state(zone, NR_ZONE_UNEVICTABLE)),
                         K(zone_page_state(zone, NR_ZONE_WRITE_PENDING)),
                         K(zone->present_pages),
-                        K(zone->managed_pages),
+                        K(zone_managed_pages(zone)),
                         K(zone_page_state(zone, NR_MLOCK)),
                         zone_page_state(zone, NR_KERNEL_STACK_KB),
                         K(zone_page_state(zone, NR_PAGETABLE)),
@@ -5656,7 +5656,7 @@ static int zone_batchsize(struct zone *zone)
          * The per-cpu-pages pools are set to around 1000th of the
          * size of the zone.
          */
-        batch = zone->managed_pages / 1024;
+        batch = zone_managed_pages(zone) / 1024;
         /* But no more than a meg. */
         if (batch * PAGE_SIZE > 1024 * 1024)
                 batch = (1024 * 1024) / PAGE_SIZE;
@@ -5766,7 +5766,7 @@ static void pageset_set_high_and_batch(struct zone *zone,
 {
         if (percpu_pagelist_fraction)
                 pageset_set_high(pcp,
-                        (zone->managed_pages /
+                        (zone_managed_pages(zone) /
                                 percpu_pagelist_fraction));
         else
                 pageset_set_batch(pcp, zone_batchsize(zone));
@@ -6323,7 +6323,7 @@ static void __meminit pgdat_init_internals(struct pglist_data *pgdat)
 static void __meminit zone_init_internals(struct zone *zone, enum zone_type idx, int nid,
                                                         unsigned long remaining_pages)
 {
-        zone->managed_pages = remaining_pages;
+        atomic_long_set(&zone->managed_pages, remaining_pages);
         zone_set_nid(zone, nid);
         zone->name = zone_names[idx];
         zone->zone_pgdat = NODE_DATA(nid);
@@ -7076,7 +7076,7 @@ early_param("movablecore", cmdline_parse_movablecore);
 void adjust_managed_page_count(struct page *page, long count)
 {
         spin_lock(&managed_page_count_lock);
-        page_zone(page)->managed_pages += count;
+        atomic_long_add(count, &page_zone(page)->managed_pages);
         totalram_pages += count;
 #ifdef CONFIG_HIGHMEM
         if (PageHighMem(page))
@@ -7124,7 +7124,7 @@ void free_highmem_page(struct page *page)
 {
         __free_reserved_page(page);
         totalram_pages++;
-        page_zone(page)->managed_pages++;
+        atomic_long_inc(&page_zone(page)->managed_pages);
         totalhigh_pages++;
 }
 #endif
@@ -7257,7 +7257,7 @@ static void calculate_totalreserve_pages(void)
                 for (i = 0; i < MAX_NR_ZONES; i++) {
                         struct zone *zone = pgdat->node_zones + i;
                         long max = 0;
-                        unsigned long managed_pages = zone->managed_pages;
+                        unsigned long managed_pages = zone_managed_pages(zone);
 
                         /* Find valid and maximum lowmem_reserve in the zone */
                         for (j = i; j < MAX_NR_ZONES; j++) {
@@ -7293,7 +7293,7 @@ static void setup_per_zone_lowmem_reserve(void)
         for_each_online_pgdat(pgdat) {
                 for (j = 0; j < MAX_NR_ZONES; j++) {
                         struct zone *zone = pgdat->node_zones + j;
-                        unsigned long managed_pages = zone->managed_pages;
+                        unsigned long managed_pages = zone_managed_pages(zone);
 
                         zone->lowmem_reserve[j] = 0;
 
@@ -7311,7 +7311,7 @@ static void setup_per_zone_lowmem_reserve(void)
                                         lower_zone->lowmem_reserve[j] =
                                                 managed_pages / sysctl_lowmem_reserve_ratio[idx];
                                 }
-                                managed_pages += lower_zone->managed_pages;
+                                managed_pages += zone_managed_pages(lower_zone);
                         }
                 }
         }
@@ -7330,14 +7330,14 @@ static void __setup_per_zone_wmarks(void)
         /* Calculate total number of !ZONE_HIGHMEM pages */
         for_each_zone(zone) {
                 if (!is_highmem(zone))
-                        lowmem_pages += zone->managed_pages;
+                        lowmem_pages += zone_managed_pages(zone);
         }
 
         for_each_zone(zone) {
                 u64 tmp;
 
                 spin_lock_irqsave(&zone->lock, flags);
-                tmp = (u64)pages_min * zone->managed_pages;
+                tmp = (u64)pages_min * zone_managed_pages(zone);
                 do_div(tmp, lowmem_pages);
                 if (is_highmem(zone)) {
                         /*
@@ -7351,7 +7351,7 @@ static void __setup_per_zone_wmarks(void)
                          */
                         unsigned long min_pages;
 
-                        min_pages = zone->managed_pages / 1024;
+                        min_pages = zone_managed_pages(zone) / 1024;
                         min_pages = clamp(min_pages, SWAP_CLUSTER_MAX, 128UL);
                         zone->watermark[WMARK_MIN] = min_pages;
                 } else {
@@ -7368,7 +7368,7 @@ static void __setup_per_zone_wmarks(void)
                  * ensure a minimum size on small systems.
                  */
                 tmp = max_t(u64, tmp >> 2,
-                            mult_frac(zone->managed_pages,
+                            mult_frac(zone_managed_pages(zone),
                                       watermark_scale_factor, 10000));
 
                 zone->watermark[WMARK_LOW]  = min_wmark_pages(zone) + tmp;
@@ -7498,8 +7498,8 @@ static void setup_min_unmapped_ratio(void)
                 pgdat->min_unmapped_pages = 0;
 
         for_each_zone(zone)
-                zone->zone_pgdat->min_unmapped_pages += (zone->managed_pages *
-                                sysctl_min_unmapped_ratio) / 100;
+                zone->zone_pgdat->min_unmapped_pages += (zone_managed_pages(zone) *
+                                                         sysctl_min_unmapped_ratio) / 100;
 }
 
 
@@ -7526,8 +7526,8 @@ static void setup_min_slab_ratio(void)
                 pgdat->min_slab_pages = 0;
 
         for_each_zone(zone)
-                zone->zone_pgdat->min_slab_pages += (zone->managed_pages *
-                                sysctl_min_slab_ratio) / 100;
+                zone->zone_pgdat->min_slab_pages += (zone_managed_pages(zone) *
+                                                     sysctl_min_slab_ratio) / 100;
 }
 
 int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *table, int write,
diff --git a/mm/vmstat.c b/mm/vmstat.c
index 9c624595e904..83b30edc2f7f 100644
--- a/mm/vmstat.c
+++ b/mm/vmstat.c
@@ -227,7 +227,7 @@ int calculate_normal_threshold(struct zone *zone)
          * 125          1024            10      16-32 GB        9
          */
 
-        mem = zone->managed_pages >> (27 - PAGE_SHIFT);
+        mem = zone_managed_pages(zone) >> (27 - PAGE_SHIFT);
 
         threshold = 2 * fls(num_online_cpus()) * (1 + fls(mem));
 
@@ -1569,7 +1569,7 @@ static void zoneinfo_show_print(struct seq_file *m, pg_data_t *pgdat,
                    high_wmark_pages(zone),
                    zone->spanned_pages,
                    zone->present_pages,
-                   zone->managed_pages);
+                   zone_managed_pages(zone));
 
         seq_printf(m,
                    "\n        protection: (%ld",