5 files changed, 103 insertions, 8 deletions

diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h
index 3c8cf86201c3..a61aede1b391 100644
--- a/include/linux/memory_hotplug.h
+++ b/include/linux/memory_hotplug.h
@@ -14,6 +14,20 @@ struct memory_block;
 struct resource;
 
 #ifdef CONFIG_MEMORY_HOTPLUG
+/*
+ * Return page for the valid pfn only if the page is online. All pfn
+ * walkers which rely on the fully initialized page->flags and others
+ * should use this rather than pfn_valid && pfn_to_page
+ */
+#define pfn_to_online_page(pfn)                         \
+({                                                      \
+        struct page *___page = NULL;                    \
+        unsigned long ___nr = pfn_to_section_nr(pfn);   \
+                                                        \
+        if (___nr < NR_MEM_SECTIONS && online_section_nr(___nr))\
+                ___page = pfn_to_page(pfn);             \
+        ___page;                                        \
+})
 
 /*
  * Types for free bootmem stored in page->lru.next. These have to be in
@@ -203,6 +217,14 @@ extern void set_zone_contiguous(struct zone *zone);
 extern void clear_zone_contiguous(struct zone *zone);
 
 #else /* ! CONFIG_MEMORY_HOTPLUG */
+#define pfn_to_online_page(pfn)                 \
+({                                              \
+        struct page *___page = NULL;            \
+        if (pfn_valid(pfn))                     \
+                ___page = pfn_to_page(pfn);     \
+        ___page;                                \
+ })
+
 /*
  * Stub functions for when hotplug is off
  */
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 976a1202bec1..2aaf7e08c5a8 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -1144,9 +1144,10 @@ extern unsigned long usemap_size(void);
  */
 #define SECTION_MARKED_PRESENT  (1UL<<0)
 #define SECTION_HAS_MEM_MAP     (1UL<<1)
-#define SECTION_MAP_LAST_BIT    (1UL<<2)
+#define SECTION_IS_ONLINE       (1UL<<2)
+#define SECTION_MAP_LAST_BIT    (1UL<<3)
 #define SECTION_MAP_MASK        (~(SECTION_MAP_LAST_BIT-1))
-#define SECTION_NID_SHIFT       2
+#define SECTION_NID_SHIFT       3
 
 static inline struct page *__section_mem_map_addr(struct mem_section *section)
 {
@@ -1175,6 +1176,23 @@ static inline int valid_section_nr(unsigned long nr)
         return valid_section(__nr_to_section(nr));
 }
 
+static inline int online_section(struct mem_section *section)
+{
+        return (section && (section->section_mem_map & SECTION_IS_ONLINE));
+}
+
+static inline int online_section_nr(unsigned long nr)
+{
+        return online_section(__nr_to_section(nr));
+}
+
+#ifdef CONFIG_MEMORY_HOTPLUG
+void online_mem_sections(unsigned long start_pfn, unsigned long end_pfn);
+#ifdef CONFIG_MEMORY_HOTREMOVE
+void offline_mem_sections(unsigned long start_pfn, unsigned long end_pfn);
+#endif
+#endif
+
 static inline struct mem_section *__pfn_to_section(unsigned long pfn)
 {
         return __nr_to_section(pfn_to_section_nr(pfn));
@@ -1253,10 +1271,15 @@ unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);
 #ifdef CONFIG_ARCH_HAS_HOLES_MEMORYMODEL
 /*
  * pfn_valid() is meant to be able to tell if a given PFN has valid memmap
- * associated with it or not. In FLATMEM, it is expected that holes always
- * have valid memmap as long as there is valid PFNs either side of the hole.
- * In SPARSEMEM, it is assumed that a valid section has a memmap for the
- * entire section.
+ * associated with it or not. This means that a struct page exists for this
+ * pfn. The caller cannot assume the page is fully initialized in general.
+ * Hotplugable pages might not have been onlined yet. pfn_to_online_page()
+ * will ensure the struct page is fully online and initialized. Special pages
+ * (e.g. ZONE_DEVICE) are never onlined and should be treated accordingly.
+ *
+ * In FLATMEM, it is expected that holes always have valid memmap as long as
+ * there is valid PFNs either side of the hole. In SPARSEMEM, it is assumed
+ * that a valid section has a memmap for the entire section.
  *
  * However, an ARM, and maybe other embedded architectures in the future
  * free memmap backing holes to save memory on the assumption the memmap is
diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index caa58338d121..b2ebe9ad7f6c 100644
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -929,12 +929,16 @@ static int online_pages_range(unsigned long start_pfn, unsigned long nr_pages,
         unsigned long i;
         unsigned long onlined_pages = *(unsigned long *)arg;
         struct page *page;
+
         if (PageReserved(pfn_to_page(start_pfn)))
                 for (i = 0; i < nr_pages; i++) {
                         page = pfn_to_page(start_pfn + i);
                         (*online_page_callback)(page);
                         onlined_pages++;
                 }
+
+        online_mem_sections(start_pfn, start_pfn + nr_pages);
+
         *(unsigned long *)arg = onlined_pages;
         return 0;
 }
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 73f854344735..387f20db217c 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1365,7 +1365,9 @@ struct page *__pageblock_pfn_to_page(unsigned long start_pfn,
         if (!pfn_valid(start_pfn) || !pfn_valid(end_pfn))
                 return NULL;
 
-        start_page = pfn_to_page(start_pfn);
+        start_page = pfn_to_online_page(start_pfn);
+        if (!start_page)
+                return NULL;
 
         if (page_zone(start_page) != zone)
                 return NULL;
@@ -7656,6 +7658,7 @@ __offline_isolated_pages(unsigned long start_pfn, unsigned long end_pfn)
                         break;
         if (pfn == end_pfn)
                 return;
+        offline_mem_sections(pfn, end_pfn);
         zone = page_zone(pfn_to_page(pfn));
         spin_lock_irqsave(&zone->lock, flags);
         pfn = start_pfn;
diff --git a/mm/sparse.c b/mm/sparse.c
index 5032c9a619de..9d7fd666015e 100644
--- a/mm/sparse.c
+++ b/mm/sparse.c
@@ -222,7 +222,8 @@ void __init memory_present(int nid, unsigned long start, unsigned long end)
 
                 ms = __nr_to_section(section);
                 if (!ms->section_mem_map) {
-                        ms->section_mem_map = sparse_encode_early_nid(nid);
+                        ms->section_mem_map = sparse_encode_early_nid(nid) |
+                                                        SECTION_IS_ONLINE;
                         section_mark_present(ms);
                 }
         }
@@ -622,6 +623,48 @@ void __init sparse_init(void)
 }
 
 #ifdef CONFIG_MEMORY_HOTPLUG
+
+/* Mark all memory sections within the pfn range as online */
+void online_mem_sections(unsigned long start_pfn, unsigned long end_pfn)
+{
+        unsigned long pfn;
+
+        for (pfn = start_pfn; pfn < end_pfn; pfn += PAGES_PER_SECTION) {
+                unsigned long section_nr = pfn_to_section_nr(start_pfn);
+                struct mem_section *ms;
+
+                /* onlining code should never touch invalid ranges */
+                if (WARN_ON(!valid_section_nr(section_nr)))
+                        continue;
+
+                ms = __nr_to_section(section_nr);
+                ms->section_mem_map |= SECTION_IS_ONLINE;
+        }
+}
+
+#ifdef CONFIG_MEMORY_HOTREMOVE
+/* Mark all memory sections within the pfn range as online */
+void offline_mem_sections(unsigned long start_pfn, unsigned long end_pfn)
+{
+        unsigned long pfn;
+
+        for (pfn = start_pfn; pfn < end_pfn; pfn += PAGES_PER_SECTION) {
+                unsigned long section_nr = pfn_to_section_nr(start_pfn);
+                struct mem_section *ms;
+
+                /*
+                 * TODO this needs some double checking. Offlining code makes
+                 * sure to check pfn_valid but those checks might be just bogus
+                 */
+                if (WARN_ON(!valid_section_nr(section_nr)))
+                        continue;
+
+                ms = __nr_to_section(section_nr);
+                ms->section_mem_map &= ~SECTION_IS_ONLINE;
+        }
+}
+#endif
+
 #ifdef CONFIG_SPARSEMEM_VMEMMAP
 static inline struct page *kmalloc_section_memmap(unsigned long pnum, int nid)
 {