mm: meminit: make __early_pfn_to_nid SMP-safe and introduce meminit_pfn_in_nid

__early_pfn_to_nid() use static variables to cache recent lookups as
memblock lookups are very expensive but it assumes that memory
initialisation is single-threaded.  Parallel initialisation of struct
pages will break that assumption so this patch makes __early_pfn_to_nid()
SMP-safe by requiring the caller to cache recent search information.
early_pfn_to_nid() keeps the same interface but is only safe to use early
in boot due to the use of a global static variable.  meminit_pfn_in_nid()
is an SMP-safe version that callers must maintain their own state for.

Signed-off-by: Mel Gorman <mgorman@suse.de>
Tested-by: Nate Zimmer <nzimmer@sgi.com>
Tested-by: Waiman Long <waiman.long@hp.com>
Tested-by: Daniel J Blueman <daniel@numascale.com>
Acked-by: Pekka Enberg <penberg@kernel.org>
Cc: Robin Holt <robinmholt@gmail.com>
Cc: Nate Zimmer <nzimmer@sgi.com>
Cc: Dave Hansen <dave.hansen@intel.com>
Cc: Waiman Long <waiman.long@hp.com>
Cc: Scott Norton <scott.norton@hp.com>
Cc: "Luck, Tony" <tony.luck@intel.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 7 insertions, 12 deletions

diff --git a/arch/ia64/mm/numa.c b/arch/ia64/mm/numa.c
index ea21d4cad540..aa19b7ac8222 100644
--- a/arch/ia64/mm/numa.c
+++ b/arch/ia64/mm/numa.c
@@ -58,27 +58,22 @@ paddr_to_nid(unsigned long paddr)
  * SPARSEMEM to allocate the SPARSEMEM sectionmap on the NUMA node where
  * the section resides.
  */
-int __meminit __early_pfn_to_nid(unsigned long pfn)
+int __meminit __early_pfn_to_nid(unsigned long pfn,
+                                        struct mminit_pfnnid_cache *state)
 {
         int i, section = pfn >> PFN_SECTION_SHIFT, ssec, esec;
-        /*
-         * NOTE: The following SMP-unsafe globals are only used early in boot
-         * when the kernel is running single-threaded.
-         */
-        static int __meminitdata last_ssec, last_esec;
-        static int __meminitdata last_nid;
 
-        if (section >= last_ssec && section < last_esec)
-                return last_nid;
+        if (section >= state->last_start && section < state->last_end)
+                return state->last_nid;
 
         for (i = 0; i < num_node_memblks; i++) {
                 ssec = node_memblk[i].start_paddr >> PA_SECTION_SHIFT;
                 esec = (node_memblk[i].start_paddr + node_memblk[i].size +
                         ((1L << PA_SECTION_SHIFT) - 1)) >> PA_SECTION_SHIFT;
                 if (section >= ssec && section < esec) {
-                        last_ssec = ssec;
-                        last_esec = esec;
-                        last_nid = node_memblk[i].nid;
+                        state->last_start = ssec;
+                        state->last_end = esec;
+                        state->last_nid = node_memblk[i].nid;
                         return node_memblk[i].nid;
                 }
         }