Merge branch 'core/speculation' of git://git.kernel.org/pub/scm/linux/kernel/git...
[sfrench/cifs-2.6.git] / arch / powerpc / kernel / setup_64.c
index c7ec27ba8926a8b1a974e3c8cc56855467d35b70..4f49e1a3594c2d3423ae232152cda2b53e730483 100644 (file)
@@ -634,19 +634,17 @@ __init u64 ppc64_bolted_size(void)
 
 static void *__init alloc_stack(unsigned long limit, int cpu)
 {
-       unsigned long pa;
+       void *ptr;
 
        BUILD_BUG_ON(STACK_INT_FRAME_SIZE % 16);
 
-       pa = memblock_alloc_base_nid(THREAD_SIZE, THREAD_SIZE, limit,
-                                       early_cpu_to_node(cpu), MEMBLOCK_NONE);
-       if (!pa) {
-               pa = memblock_alloc_base(THREAD_SIZE, THREAD_SIZE, limit);
-               if (!pa)
-                       panic("cannot allocate stacks");
-       }
+       ptr = memblock_alloc_try_nid(THREAD_SIZE, THREAD_SIZE,
+                                    MEMBLOCK_LOW_LIMIT, limit,
+                                    early_cpu_to_node(cpu));
+       if (!ptr)
+               panic("cannot allocate stacks");
 
-       return __va(pa);
+       return ptr;
 }
 
 void __init irqstack_early_init(void)
@@ -691,24 +689,6 @@ void __init exc_lvl_early_init(void)
 }
 #endif
 
-/*
- * Emergency stacks are used for a range of things, from asynchronous
- * NMIs (system reset, machine check) to synchronous, process context.
- * We set preempt_count to zero, even though that isn't necessarily correct. To
- * get the right value we'd need to copy it from the previous thread_info, but
- * doing that might fault causing more problems.
- * TODO: what to do with accounting?
- */
-static void emerg_stack_init_thread_info(struct thread_info *ti, int cpu)
-{
-       ti->task = NULL;
-       ti->cpu = cpu;
-       ti->preempt_count = 0;
-       ti->local_flags = 0;
-       ti->flags = 0;
-       klp_init_thread_info(ti);
-}
-
 /*
  * Stack space used when we detect a bad kernel stack pointer, and
  * early in SMP boots before relocation is enabled. Exclusive emergency
@@ -736,25 +716,14 @@ void __init emergency_stack_init(void)
        limit = min(ppc64_bolted_size(), ppc64_rma_size);
 
        for_each_possible_cpu(i) {
-               struct thread_info *ti;
-
-               ti = alloc_stack(limit, i);
-               memset(ti, 0, THREAD_SIZE);
-               emerg_stack_init_thread_info(ti, i);
-               paca_ptrs[i]->emergency_sp = (void *)ti + THREAD_SIZE;
+               paca_ptrs[i]->emergency_sp = alloc_stack(limit, i) + THREAD_SIZE;
 
 #ifdef CONFIG_PPC_BOOK3S_64
                /* emergency stack for NMI exception handling. */
-               ti = alloc_stack(limit, i);
-               memset(ti, 0, THREAD_SIZE);
-               emerg_stack_init_thread_info(ti, i);
-               paca_ptrs[i]->nmi_emergency_sp = (void *)ti + THREAD_SIZE;
+               paca_ptrs[i]->nmi_emergency_sp = alloc_stack(limit, i) + THREAD_SIZE;
 
                /* emergency stack for machine check exception handling. */
-               ti = alloc_stack(limit, i);
-               memset(ti, 0, THREAD_SIZE);
-               emerg_stack_init_thread_info(ti, i);
-               paca_ptrs[i]->mc_emergency_sp = (void *)ti + THREAD_SIZE;
+               paca_ptrs[i]->mc_emergency_sp = alloc_stack(limit, i) + THREAD_SIZE;
 #endif
        }
 }
@@ -933,8 +902,13 @@ static void __ref init_fallback_flush(void)
         * hardware prefetch runoff. We don't have a recipe for load patterns to
         * reliably avoid the prefetcher.
         */
-       l1d_flush_fallback_area = __va(memblock_alloc_base(l1d_size * 2, l1d_size, limit));
-       memset(l1d_flush_fallback_area, 0, l1d_size * 2);
+       l1d_flush_fallback_area = memblock_alloc_try_nid(l1d_size * 2,
+                                               l1d_size, MEMBLOCK_LOW_LIMIT,
+                                               limit, NUMA_NO_NODE);
+       if (!l1d_flush_fallback_area)
+               panic("%s: Failed to allocate %llu bytes align=0x%llx max_addr=%pa\n",
+                     __func__, l1d_size * 2, l1d_size, &limit);
+
 
        for_each_possible_cpu(cpu) {
                struct paca_struct *paca = paca_ptrs[cpu];