s390/mm: Convert bootmem to memblock
authorPhilipp Hachtmann <phacht@linux.vnet.ibm.com>
Wed, 29 Jan 2014 17:16:01 +0000 (18:16 +0100)
committerMartin Schwidefsky <schwidefsky@de.ibm.com>
Tue, 20 May 2014 06:58:40 +0000 (08:58 +0200)
The original bootmem allocator is getting replaced by memblock. To
cover the needs of the s390 kdump implementation the physical memory
list is used.
With this patch the bootmem allocator and its bitmaps are completely
removed from s390.

Signed-off-by: Philipp Hachtmann <phacht@linux.vnet.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
arch/s390/Kconfig
arch/s390/include/asm/setup.h
arch/s390/kernel/crash_dump.c
arch/s390/kernel/early.c
arch/s390/kernel/head31.S
arch/s390/kernel/setup.c
arch/s390/kernel/topology.c
arch/s390/mm/mem_detect.c
arch/s390/mm/vmem.c
drivers/s390/char/zcore.c

index d68fe34799b0fc8f988b81bbeaf3a14d40afc8e3..d239e6afb9238ea6f073ec1cfd330ea6af2a3fe4 100644 (file)
@@ -60,7 +60,6 @@ config PCI_QUIRKS
 
 config S390
        def_bool y
-       select ARCH_DISCARD_MEMBLOCK
        select ARCH_HAS_ATOMIC64_DEC_IF_POSITIVE
        select ARCH_HAS_DEBUG_STRICT_USER_COPY_CHECKS
        select ARCH_HAVE_NMI_SAFE_CMPXCHG
@@ -130,6 +129,7 @@ config S390
        select HAVE_KVM if 64BIT
        select HAVE_MEMBLOCK
        select HAVE_MEMBLOCK_NODE_MAP
+       select HAVE_MEMBLOCK_PHYS_MAP
        select HAVE_MOD_ARCH_SPECIFIC
        select HAVE_OPROFILE
        select HAVE_PERF_EVENTS
@@ -139,6 +139,7 @@ config S390
        select HAVE_VIRT_CPU_ACCOUNTING
        select KTIME_SCALAR if 32BIT
        select MODULES_USE_ELF_RELA
+       select NO_BOOTMEM
        select OLD_SIGACTION
        select OLD_SIGSUSPEND3
        select SYSCTL_EXCEPTION_TRACE
index b31b22dba94859087a019975ace0f505d69fdf5e..089a49814c505b506ed1689230a470ebfc575d03 100644 (file)
@@ -9,7 +9,6 @@
 
 
 #define PARMAREA               0x10400
-#define MEMORY_CHUNKS          256
 
 #ifndef __ASSEMBLY__
 
 #endif /* CONFIG_64BIT */
 #define COMMAND_LINE      ((char *)            (0x10480))
 
-#define CHUNK_READ_WRITE 0
-#define CHUNK_READ_ONLY  1
-
-struct mem_chunk {
-       unsigned long addr;
-       unsigned long size;
-       int type;
-};
-
-extern struct mem_chunk memory_chunk[];
 extern int memory_end_set;
 extern unsigned long memory_end;
+extern unsigned long max_physmem_end;
 
-void detect_memory_layout(struct mem_chunk chunk[], unsigned long maxsize);
-void create_mem_hole(struct mem_chunk mem_chunk[], unsigned long addr,
-                    unsigned long size);
+extern void detect_memory_memblock(void);
 
 /*
  * Machine features detected in head.S
index d7658c4b2ed5817c75cd6a90c91b3a1b93738809..a3b9150e6802973b3b82a6db379c7959dfb48e9d 100644 (file)
@@ -13,6 +13,7 @@
 #include <linux/slab.h>
 #include <linux/bootmem.h>
 #include <linux/elf.h>
+#include <linux/memblock.h>
 #include <asm/os_info.h>
 #include <asm/elf.h>
 #include <asm/ipl.h>
 #define PTR_SUB(x, y) (((char *) (x)) - ((unsigned long) (y)))
 #define PTR_DIFF(x, y) ((unsigned long)(((char *) (x)) - ((unsigned long) (y))))
 
+static struct memblock_region oldmem_region;
+
+static struct memblock_type oldmem_type = {
+       .cnt = 1,
+       .max = 1,
+       .total_size = 0,
+       .regions = &oldmem_region,
+};
+
+#define for_each_dump_mem_range(i, nid, p_start, p_end, p_nid)         \
+       for (i = 0, __next_mem_range(&i, nid, &memblock.physmem,        \
+                                    &oldmem_type, p_start,             \
+                                    p_end, p_nid);                     \
+            i != (u64)ULLONG_MAX;                                      \
+            __next_mem_range(&i, nid, &memblock.physmem,               \
+                             &oldmem_type,                             \
+                             p_start, p_end, p_nid))
+
 struct dump_save_areas dump_save_areas;
 
 /*
@@ -263,19 +282,6 @@ static void *kzalloc_panic(int len)
        return rc;
 }
 
-/*
- * Get memory layout and create hole for oldmem
- */
-static struct mem_chunk *get_memory_layout(void)
-{
-       struct mem_chunk *chunk_array;
-
-       chunk_array = kzalloc_panic(MEMORY_CHUNKS * sizeof(struct mem_chunk));
-       detect_memory_layout(chunk_array, 0);
-       create_mem_hole(chunk_array, OLDMEM_BASE, OLDMEM_SIZE);
-       return chunk_array;
-}
-
 /*
  * Initialize ELF note
  */
@@ -490,52 +496,33 @@ static int get_cpu_cnt(void)
  */
 static int get_mem_chunk_cnt(void)
 {
-       struct mem_chunk *chunk_array, *mem_chunk;
-       int i, cnt = 0;
+       int cnt = 0;
+       u64 idx;
 
-       chunk_array = get_memory_layout();
-       for (i = 0; i < MEMORY_CHUNKS; i++) {
-               mem_chunk = &chunk_array[i];
-               if (chunk_array[i].type != CHUNK_READ_WRITE &&
-                   chunk_array[i].type != CHUNK_READ_ONLY)
-                       continue;
-               if (mem_chunk->size == 0)
-                       continue;
+       for_each_dump_mem_range(idx, NUMA_NO_NODE, NULL, NULL, NULL)
                cnt++;
-       }
-       kfree(chunk_array);
        return cnt;
 }
 
 /*
  * Initialize ELF loads (new kernel)
  */
-static int loads_init(Elf64_Phdr *phdr, u64 loads_offset)
+static void loads_init(Elf64_Phdr *phdr, u64 loads_offset)
 {
-       struct mem_chunk *chunk_array, *mem_chunk;
-       int i;
+       phys_addr_t start, end;
+       u64 idx;
 
-       chunk_array = get_memory_layout();
-       for (i = 0; i < MEMORY_CHUNKS; i++) {
-               mem_chunk = &chunk_array[i];
-               if (mem_chunk->size == 0)
-                       continue;
-               if (chunk_array[i].type != CHUNK_READ_WRITE &&
-                   chunk_array[i].type != CHUNK_READ_ONLY)
-                       continue;
-               else
-                       phdr->p_filesz = mem_chunk->size;
+       for_each_dump_mem_range(idx, NUMA_NO_NODE, &start, &end, NULL) {
+               phdr->p_filesz = end - start;
                phdr->p_type = PT_LOAD;
-               phdr->p_offset = mem_chunk->addr;
-               phdr->p_vaddr = mem_chunk->addr;
-               phdr->p_paddr = mem_chunk->addr;
-               phdr->p_memsz = mem_chunk->size;
+               phdr->p_offset = start;
+               phdr->p_vaddr = start;
+               phdr->p_paddr = start;
+               phdr->p_memsz = end - start;
                phdr->p_flags = PF_R | PF_W | PF_X;
                phdr->p_align = PAGE_SIZE;
                phdr++;
        }
-       kfree(chunk_array);
-       return i;
 }
 
 /*
@@ -584,6 +571,14 @@ int elfcorehdr_alloc(unsigned long long *addr, unsigned long long *size)
        /* If we cannot get HSA size for zfcpdump return error */
        if (ipl_info.type == IPL_TYPE_FCP_DUMP && !sclp_get_hsa_size())
                return -ENODEV;
+
+       /* For kdump, exclude previous crashkernel memory */
+       if (OLDMEM_BASE) {
+               oldmem_region.base = OLDMEM_BASE;
+               oldmem_region.size = OLDMEM_SIZE;
+               oldmem_type.total_size = OLDMEM_SIZE;
+       }
+
        mem_chunk_cnt = get_mem_chunk_cnt();
 
        alloc_size = 0x1000 + get_cpu_cnt() * 0x300 +
index a734f3585cebdd8eda8db980fb0343bae16a1b1b..0dff972a169c16dd533c8256de9771e96f459e01 100644 (file)
@@ -258,13 +258,19 @@ static __init void setup_topology(void)
 static void early_pgm_check_handler(void)
 {
        const struct exception_table_entry *fixup;
+       unsigned long cr0, cr0_new;
        unsigned long addr;
 
        addr = S390_lowcore.program_old_psw.addr;
        fixup = search_exception_tables(addr & PSW_ADDR_INSN);
        if (!fixup)
                disabled_wait(0);
+       /* Disable low address protection before storing into lowcore. */
+       __ctl_store(cr0, 0, 0);
+       cr0_new = cr0 & ~(1UL << 28);
+       __ctl_load(cr0_new, 0, 0);
        S390_lowcore.program_old_psw.addr = extable_fixup(fixup)|PSW_ADDR_AMODE;
+       __ctl_load(cr0, 0, 0);
 }
 
 static noinline __init void setup_lowcore_early(void)
index 9a99856df1c93ea4d23612d7e2c4670cd82a1a81..6dbe80983a24fcd9ea04339d90fb2c993e7546f5 100644 (file)
@@ -59,7 +59,6 @@ ENTRY(startup_continue)
        .long   0                       # cr13: home space segment table
        .long   0xc0000000              # cr14: machine check handling off
        .long   0                       # cr15: linkage stack operations
-.Lmchunk:.long memory_chunk
 .Lbss_bgn:  .long __bss_start
 .Lbss_end:  .long _end
 .Lparmaddr: .long PARMAREA
index 88d1ca81e2dd7fc5ac74fc31c4b0eca47aec754f..1f5536c2fd02b5f48eb65c0ac1d358cd7b8ffde6 100644 (file)
@@ -78,10 +78,9 @@ EXPORT_SYMBOL(console_irq);
 unsigned long elf_hwcap = 0;
 char elf_platform[ELF_PLATFORM_SIZE];
 
-struct mem_chunk __initdata memory_chunk[MEMORY_CHUNKS];
-
 int __initdata memory_end_set;
 unsigned long __initdata memory_end;
+unsigned long __initdata max_physmem_end;
 
 unsigned long VMALLOC_START;
 EXPORT_SYMBOL(VMALLOC_START);
@@ -273,6 +272,7 @@ EXPORT_SYMBOL_GPL(pm_power_off);
 static int __init early_parse_mem(char *p)
 {
        memory_end = memparse(p, &p);
+       memory_end &= PAGE_MASK;
        memory_end_set = 1;
        return 0;
 }
@@ -401,7 +401,8 @@ static struct resource __initdata *standard_resources[] = {
 static void __init setup_resources(void)
 {
        struct resource *res, *std_res, *sub_res;
-       int i, j;
+       struct memblock_region *reg;
+       int j;
 
        code_resource.start = (unsigned long) &_text;
        code_resource.end = (unsigned long) &_etext - 1;
@@ -410,24 +411,13 @@ static void __init setup_resources(void)
        bss_resource.start = (unsigned long) &__bss_start;
        bss_resource.end = (unsigned long) &__bss_stop - 1;
 
-       for (i = 0; i < MEMORY_CHUNKS; i++) {
-               if (!memory_chunk[i].size)
-                       continue;
+       for_each_memblock(memory, reg) {
                res = alloc_bootmem_low(sizeof(*res));
                res->flags = IORESOURCE_BUSY | IORESOURCE_MEM;
-               switch (memory_chunk[i].type) {
-               case CHUNK_READ_WRITE:
-                       res->name = "System RAM";
-                       break;
-               case CHUNK_READ_ONLY:
-                       res->name = "System ROM";
-                       res->flags |= IORESOURCE_READONLY;
-                       break;
-               default:
-                       res->name = "reserved";
-               }
-               res->start = memory_chunk[i].addr;
-               res->end = res->start + memory_chunk[i].size - 1;
+
+               res->name = "System RAM";
+               res->start = reg->base;
+               res->end = reg->base + reg->size - 1;
                request_resource(&iomem_resource, res);
 
                for (j = 0; j < ARRAY_SIZE(standard_resources); j++) {
@@ -451,48 +441,11 @@ static void __init setup_resources(void)
 static void __init setup_memory_end(void)
 {
        unsigned long vmax, vmalloc_size, tmp;
-       unsigned long real_memory_size = 0;
-       int i;
-
-
-#ifdef CONFIG_ZFCPDUMP
-       if (ipl_info.type == IPL_TYPE_FCP_DUMP &&
-           !OLDMEM_BASE && sclp_get_hsa_size()) {
-               memory_end = sclp_get_hsa_size();
-               memory_end_set = 1;
-       }
-#endif
-       memory_end &= PAGE_MASK;
-
-       /*
-        * Make sure all chunks are MAX_ORDER aligned so we don't need the
-        * extra checks that HOLES_IN_ZONE would require.
-        */
-       for (i = 0; i < MEMORY_CHUNKS; i++) {
-               unsigned long start, end;
-               struct mem_chunk *chunk;
-               unsigned long align;
-
-               chunk = &memory_chunk[i];
-               if (!chunk->size)
-                       continue;
-               align = 1UL << (MAX_ORDER + PAGE_SHIFT - 1);
-               start = (chunk->addr + align - 1) & ~(align - 1);
-               end = (chunk->addr + chunk->size) & ~(align - 1);
-               if (start >= end)
-                       memset(chunk, 0, sizeof(*chunk));
-               else {
-                       chunk->addr = start;
-                       chunk->size = end - start;
-               }
-               real_memory_size = max(real_memory_size,
-                                      chunk->addr + chunk->size);
-       }
 
        /* Choose kernel address space layout: 2, 3, or 4 levels. */
 #ifdef CONFIG_64BIT
        vmalloc_size = VMALLOC_END ?: (128UL << 30) - MODULES_LEN;
-       tmp = (memory_end ?: real_memory_size) / PAGE_SIZE;
+       tmp = (memory_end ?: max_physmem_end) / PAGE_SIZE;
        tmp = tmp * (sizeof(struct page) + PAGE_SIZE) + vmalloc_size;
        if (tmp <= (1UL << 42))
                vmax = 1UL << 42;       /* 3-level kernel page table */
@@ -520,21 +473,11 @@ static void __init setup_memory_end(void)
        vmemmap = (struct page *) tmp;
 
        /* Take care that memory_end is set and <= vmemmap */
-       memory_end = min(memory_end ?: real_memory_size, tmp);
-
-       /* Fixup memory chunk array to fit into 0..memory_end */
-       for (i = 0; i < MEMORY_CHUNKS; i++) {
-               struct mem_chunk *chunk = &memory_chunk[i];
+       memory_end = min(memory_end ?: max_physmem_end, tmp);
+       max_pfn = max_low_pfn = PFN_DOWN(memory_end);
+       memblock_remove(memory_end, ULONG_MAX);
 
-               if (!chunk->size)
-                       continue;
-               if (chunk->addr >= memory_end) {
-                       memset(chunk, 0, sizeof(*chunk));
-                       continue;
-               }
-               if (chunk->addr + chunk->size > memory_end)
-                       chunk->size = memory_end - chunk->addr;
-       }
+       pr_notice("Max memory size: %luMB\n", memory_end >> 20);
 }
 
 static void __init setup_vmcoreinfo(void)
@@ -544,89 +487,6 @@ static void __init setup_vmcoreinfo(void)
 
 #ifdef CONFIG_CRASH_DUMP
 
-/*
- * Find suitable location for crashkernel memory
- */
-static unsigned long __init find_crash_base(unsigned long crash_size,
-                                           char **msg)
-{
-       unsigned long crash_base;
-       struct mem_chunk *chunk;
-       int i;
-
-       if (memory_chunk[0].size < crash_size) {
-               *msg = "first memory chunk must be at least crashkernel size";
-               return 0;
-       }
-       if (OLDMEM_BASE && crash_size == OLDMEM_SIZE)
-               return OLDMEM_BASE;
-
-       for (i = MEMORY_CHUNKS - 1; i >= 0; i--) {
-               chunk = &memory_chunk[i];
-               if (chunk->size == 0)
-                       continue;
-               if (chunk->type != CHUNK_READ_WRITE)
-                       continue;
-               if (chunk->size < crash_size)
-                       continue;
-               crash_base = (chunk->addr + chunk->size) - crash_size;
-               if (crash_base < crash_size)
-                       continue;
-               if (crash_base < sclp_get_hsa_size())
-                       continue;
-               if (crash_base < (unsigned long) INITRD_START + INITRD_SIZE)
-                       continue;
-               return crash_base;
-       }
-       *msg = "no suitable area found";
-       return 0;
-}
-
-/*
- * Check if crash_base and crash_size is valid
- */
-static int __init verify_crash_base(unsigned long crash_base,
-                                   unsigned long crash_size,
-                                   char **msg)
-{
-       struct mem_chunk *chunk;
-       int i;
-
-       /*
-        * Because we do the swap to zero, we must have at least 'crash_size'
-        * bytes free space before crash_base
-        */
-       if (crash_size > crash_base) {
-               *msg = "crashkernel offset must be greater than size";
-               return -EINVAL;
-       }
-
-       /* First memory chunk must be at least crash_size */
-       if (memory_chunk[0].size < crash_size) {
-               *msg = "first memory chunk must be at least crashkernel size";
-               return -EINVAL;
-       }
-       /* Check if we fit into the respective memory chunk */
-       for (i = 0; i < MEMORY_CHUNKS; i++) {
-               chunk = &memory_chunk[i];
-               if (chunk->size == 0)
-                       continue;
-               if (crash_base < chunk->addr)
-                       continue;
-               if (crash_base >= chunk->addr + chunk->size)
-                       continue;
-               /* we have found the memory chunk */
-               if (crash_base + crash_size > chunk->addr + chunk->size) {
-                       *msg = "selected memory chunk is too small for "
-                               "crashkernel memory";
-                       return -EINVAL;
-               }
-               return 0;
-       }
-       *msg = "invalid memory range specified";
-       return -EINVAL;
-}
-
 /*
  * When kdump is enabled, we have to ensure that no memory from
  * the area [0 - crashkernel memory size] and
@@ -652,24 +512,45 @@ static struct notifier_block kdump_mem_nb = {
 
 #endif
 
+/*
+ * Make sure that the area behind memory_end is protected
+ */
+static void reserve_memory_end(void)
+{
+#ifdef CONFIG_ZFCPDUMP
+       if (ipl_info.type == IPL_TYPE_FCP_DUMP &&
+           !OLDMEM_BASE && sclp_get_hsa_size()) {
+               memory_end = sclp_get_hsa_size();
+               memory_end &= PAGE_MASK;
+               memory_end_set = 1;
+       }
+#endif
+       if (!memory_end_set)
+               return;
+       memblock_reserve(memory_end, ULONG_MAX);
+}
+
 /*
  * Make sure that oldmem, where the dump is stored, is protected
  */
 static void reserve_oldmem(void)
 {
 #ifdef CONFIG_CRASH_DUMP
-       unsigned long real_size = 0;
-       int i;
-
-       if (!OLDMEM_BASE)
-               return;
-       for (i = 0; i < MEMORY_CHUNKS; i++) {
-               struct mem_chunk *chunk = &memory_chunk[i];
+       if (OLDMEM_BASE)
+               /* Forget all memory above the running kdump system */
+               memblock_reserve(OLDMEM_SIZE, (phys_addr_t)ULONG_MAX);
+#endif
+}
 
-               real_size = max(real_size, chunk->addr + chunk->size);
-       }
-       create_mem_hole(memory_chunk, OLDMEM_BASE, OLDMEM_SIZE);
-       create_mem_hole(memory_chunk, OLDMEM_SIZE, real_size - OLDMEM_SIZE);
+/*
+ * Make sure that oldmem, where the dump is stored, is protected
+ */
+static void remove_oldmem(void)
+{
+#ifdef CONFIG_CRASH_DUMP
+       if (OLDMEM_BASE)
+               /* Forget all memory above the running kdump system */
+               memblock_remove(OLDMEM_SIZE, (phys_addr_t)ULONG_MAX);
 #endif
 }
 
@@ -680,167 +561,132 @@ static void __init reserve_crashkernel(void)
 {
 #ifdef CONFIG_CRASH_DUMP
        unsigned long long crash_base, crash_size;
-       char *msg = NULL;
+       phys_addr_t low, high;
        int rc;
 
        rc = parse_crashkernel(boot_command_line, memory_end, &crash_size,
                               &crash_base);
-       if (rc || crash_size == 0)
-               return;
+
        crash_base = ALIGN(crash_base, KEXEC_CRASH_MEM_ALIGN);
        crash_size = ALIGN(crash_size, KEXEC_CRASH_MEM_ALIGN);
-       if (register_memory_notifier(&kdump_mem_nb))
+       if (rc || crash_size == 0)
                return;
-       if (!crash_base)
-               crash_base = find_crash_base(crash_size, &msg);
-       if (!crash_base) {
-               pr_info("crashkernel reservation failed: %s\n", msg);
-               unregister_memory_notifier(&kdump_mem_nb);
+
+       if (memblock.memory.regions[0].size < crash_size) {
+               pr_info("crashkernel reservation failed: %s\n",
+                       "first memory chunk must be at least crashkernel size");
                return;
        }
-       if (verify_crash_base(crash_base, crash_size, &msg)) {
-               pr_info("crashkernel reservation failed: %s\n", msg);
-               unregister_memory_notifier(&kdump_mem_nb);
+
+       low = crash_base ?: OLDMEM_BASE;
+       high = low + crash_size;
+       if (low >= OLDMEM_BASE && high <= OLDMEM_BASE + OLDMEM_SIZE) {
+               /* The crashkernel fits into OLDMEM, reuse OLDMEM */
+               crash_base = low;
+       } else {
+               /* Find suitable area in free memory */
+               low = max_t(unsigned long, crash_size, sclp_get_hsa_size());
+               high = crash_base ? crash_base + crash_size : ULONG_MAX;
+
+               if (crash_base && crash_base < low) {
+                       pr_info("crashkernel reservation failed: %s\n",
+                               "crash_base too low");
+                       return;
+               }
+               low = crash_base ?: low;
+               crash_base = memblock_find_in_range(low, high, crash_size,
+                                                   KEXEC_CRASH_MEM_ALIGN);
+       }
+
+       if (!crash_base) {
+               pr_info("crashkernel reservation failed: %s\n",
+                       "no suitable area found");
                return;
        }
+
+       if (register_memory_notifier(&kdump_mem_nb))
+               return;
+
        if (!OLDMEM_BASE && MACHINE_IS_VM)
                diag10_range(PFN_DOWN(crash_base), PFN_DOWN(crash_size));
        crashk_res.start = crash_base;
        crashk_res.end = crash_base + crash_size - 1;
        insert_resource(&iomem_resource, &crashk_res);
-       create_mem_hole(memory_chunk, crash_base, crash_size);
+       memblock_remove(crash_base, crash_size);
        pr_info("Reserving %lluMB of memory at %lluMB "
                "for crashkernel (System RAM: %luMB)\n",
-               crash_size >> 20, crash_base >> 20, memory_end >> 20);
+               crash_size >> 20, crash_base >> 20,
+               (unsigned long)memblock.memory.total_size >> 20);
        os_info_crashkernel_add(crash_base, crash_size);
 #endif
 }
 
-static void __init setup_memory(void)
+/*
+ * Reserve the initrd from being used by memblock
+ */
+static void __init reserve_initrd(void)
 {
-        unsigned long bootmap_size;
-       unsigned long start_pfn, end_pfn;
-       int i;
+#ifdef CONFIG_BLK_DEV_INITRD
+       initrd_start = INITRD_START;
+       initrd_end = initrd_start + INITRD_SIZE;
+       memblock_reserve(INITRD_START, INITRD_SIZE);
+#endif
+}
 
-       /*
-        * partially used pages are not usable - thus
-        * we are rounding upwards:
-        */
+/*
+ * Check for initrd being in usable memory
+ */
+static void __init check_initrd(void)
+{
+#ifdef CONFIG_BLK_DEV_INITRD
+       if (INITRD_START && INITRD_SIZE &&
+           !memblock_is_region_memory(INITRD_START, INITRD_SIZE)) {
+               pr_err("initrd does not fit memory.\n");
+               memblock_free(INITRD_START, INITRD_SIZE);
+               initrd_start = initrd_end = 0;
+       }
+#endif
+}
+
+/*
+ * Reserve all kernel text
+ */
+static void __init reserve_kernel(void)
+{
+       unsigned long start_pfn;
        start_pfn = PFN_UP(__pa(&_end));
-       end_pfn = max_pfn = PFN_DOWN(memory_end);
 
-#ifdef CONFIG_BLK_DEV_INITRD
        /*
-        * Move the initrd in case the bitmap of the bootmem allocater
-        * would overwrite it.
+        * Reserve memory used for lowcore/command line/kernel image.
         */
+       memblock_reserve(0, (unsigned long)_ehead);
+       memblock_reserve((unsigned long)_stext, PFN_PHYS(start_pfn)
+                        - (unsigned long)_stext);
+}
 
-       if (INITRD_START && INITRD_SIZE) {
-               unsigned long bmap_size;
-               unsigned long start;
-
-               bmap_size = bootmem_bootmap_pages(end_pfn - start_pfn + 1);
-               bmap_size = PFN_PHYS(bmap_size);
-
-               if (PFN_PHYS(start_pfn) + bmap_size > INITRD_START) {
-                       start = PFN_PHYS(start_pfn) + bmap_size + PAGE_SIZE;
-
+static void __init reserve_elfcorehdr(void)
+{
 #ifdef CONFIG_CRASH_DUMP
-                       if (OLDMEM_BASE) {
-                               /* Move initrd behind kdump oldmem */
-                               if (start + INITRD_SIZE > OLDMEM_BASE &&
-                                   start < OLDMEM_BASE + OLDMEM_SIZE)
-                                       start = OLDMEM_BASE + OLDMEM_SIZE;
-                       }
-#endif
-                       if (start + INITRD_SIZE > memory_end) {
-                               pr_err("initrd extends beyond end of "
-                                      "memory (0x%08lx > 0x%08lx) "
-                                      "disabling initrd\n",
-                                      start + INITRD_SIZE, memory_end);
-                               INITRD_START = INITRD_SIZE = 0;
-                       } else {
-                               pr_info("Moving initrd (0x%08lx -> "
-                                       "0x%08lx, size: %ld)\n",
-                                       INITRD_START, start, INITRD_SIZE);
-                               memmove((void *) start, (void *) INITRD_START,
-                                       INITRD_SIZE);
-                               INITRD_START = start;
-                       }
-               }
-       }
+       if (is_kdump_kernel())
+               memblock_reserve(elfcorehdr_addr - OLDMEM_BASE,
+                                PAGE_ALIGN(elfcorehdr_size));
 #endif
+}
 
-       /*
-        * Initialize the boot-time allocator
-        */
-       bootmap_size = init_bootmem(start_pfn, end_pfn);
+static void __init setup_memory(void)
+{
+       struct memblock_region *reg;
 
        /*
-        * Register RAM areas with the bootmem allocator.
+        * Init storage key for present memory
         */
-
-       for (i = 0; i < MEMORY_CHUNKS; i++) {
-               unsigned long start_chunk, end_chunk, pfn;
-
-               if (!memory_chunk[i].size)
-                       continue;
-               start_chunk = PFN_DOWN(memory_chunk[i].addr);
-               end_chunk = start_chunk + PFN_DOWN(memory_chunk[i].size);
-               end_chunk = min(end_chunk, end_pfn);
-               if (start_chunk >= end_chunk)
-                       continue;
-               memblock_add_node(PFN_PHYS(start_chunk),
-                                 PFN_PHYS(end_chunk - start_chunk), 0);
-               pfn = max(start_chunk, start_pfn);
-               storage_key_init_range(PFN_PHYS(pfn), PFN_PHYS(end_chunk));
+       for_each_memblock(memory, reg) {
+               storage_key_init_range(reg->base, reg->base + reg->size);
        }
-
        psw_set_key(PAGE_DEFAULT_KEY);
 
-       free_bootmem_with_active_regions(0, max_pfn);
-
-       /*
-        * Reserve memory used for lowcore/command line/kernel image.
-        */
-       reserve_bootmem(0, (unsigned long)_ehead, BOOTMEM_DEFAULT);
-       reserve_bootmem((unsigned long)_stext,
-                       PFN_PHYS(start_pfn) - (unsigned long)_stext,
-                       BOOTMEM_DEFAULT);
-       /*
-        * Reserve the bootmem bitmap itself as well. We do this in two
-        * steps (first step was init_bootmem()) because this catches
-        * the (very unlikely) case of us accidentally initializing the
-        * bootmem allocator with an invalid RAM area.
-        */
-       reserve_bootmem(start_pfn << PAGE_SHIFT, bootmap_size,
-                       BOOTMEM_DEFAULT);
-
-#ifdef CONFIG_CRASH_DUMP
-       if (crashk_res.start)
-               reserve_bootmem(crashk_res.start,
-                               crashk_res.end - crashk_res.start + 1,
-                               BOOTMEM_DEFAULT);
-       if (is_kdump_kernel())
-               reserve_bootmem(elfcorehdr_addr - OLDMEM_BASE,
-                               PAGE_ALIGN(elfcorehdr_size), BOOTMEM_DEFAULT);
-#endif
-#ifdef CONFIG_BLK_DEV_INITRD
-       if (INITRD_START && INITRD_SIZE) {
-               if (INITRD_START + INITRD_SIZE <= memory_end) {
-                       reserve_bootmem(INITRD_START, INITRD_SIZE,
-                                       BOOTMEM_DEFAULT);
-                       initrd_start = INITRD_START;
-                       initrd_end = initrd_start + INITRD_SIZE;
-               } else {
-                       pr_err("initrd extends beyond end of "
-                              "memory (0x%08lx > 0x%08lx) "
-                              "disabling initrd\n",
-                              initrd_start + INITRD_SIZE, memory_end);
-                       initrd_start = initrd_end = 0;
-               }
-       }
-#endif
+       /* Only cosmetics */
+       memblock_enforce_memory_limit(memblock_end_of_DRAM());
 }
 
 /*
@@ -989,23 +835,46 @@ void __init setup_arch(char **cmdline_p)
 
         ROOT_DEV = Root_RAM0;
 
+       /* Is init_mm really needed? */
        init_mm.start_code = PAGE_OFFSET;
        init_mm.end_code = (unsigned long) &_etext;
        init_mm.end_data = (unsigned long) &_edata;
        init_mm.brk = (unsigned long) &_end;
 
        parse_early_param();
-       detect_memory_layout(memory_chunk, memory_end);
        os_info_init();
        setup_ipl();
+
+       /* Do some memory reservations *before* memory is added to memblock */
+       reserve_memory_end();
        reserve_oldmem();
+       reserve_kernel();
+       reserve_initrd();
+       reserve_elfcorehdr();
+       memblock_allow_resize();
+
+       /* Get information about *all* installed memory */
+       detect_memory_memblock();
+
+       remove_oldmem();
+
+       /*
+        * Make sure all chunks are MAX_ORDER aligned so we don't need the
+        * extra checks that HOLES_IN_ZONE would require.
+        *
+        * Is this still required?
+        */
+       memblock_trim_memory(1UL << (MAX_ORDER - 1 + PAGE_SHIFT));
+
        setup_memory_end();
-       reserve_crashkernel();
        setup_memory();
+
+       check_initrd();
+       reserve_crashkernel();
+
        setup_resources();
        setup_vmcoreinfo();
        setup_lowcore();
-
        smp_fill_possible_mask();
         cpu_init();
        s390_init_cpu_topology();
index 6298fed11cedf8bcfcb536474d33552a115f2fe2..fa3b8cdaadacf4cf14cf24976074f0319a0ebcf9 100644 (file)
@@ -333,7 +333,9 @@ static void __init alloc_masks(struct sysinfo_15_1_x *info,
                nr_masks *= info->mag[TOPOLOGY_NR_MAG - offset - 1 - i];
        nr_masks = max(nr_masks, 1);
        for (i = 0; i < nr_masks; i++) {
-               mask->next = alloc_bootmem(sizeof(struct mask_info));
+               mask->next = alloc_bootmem_align(
+                       roundup_pow_of_two(sizeof(struct mask_info)),
+                       roundup_pow_of_two(sizeof(struct mask_info)));
                mask = mask->next;
        }
 }
index cca388253a39f5636af7e10f0d416589abca59df..5535cfe0ee115fcfb48a3c7f27ce61c19a08b871 100644 (file)
 
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/memblock.h>
+#include <linux/init.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
 #include <asm/ipl.h>
 #include <asm/sclp.h>
 #include <asm/setup.h>
 
 #define ADDR2G (1ULL << 31)
 
-static void find_memory_chunks(struct mem_chunk chunk[], unsigned long maxsize)
+#define CHUNK_READ_WRITE 0
+#define CHUNK_READ_ONLY  1
+
+static inline void memblock_physmem_add(phys_addr_t start, phys_addr_t size)
+{
+       memblock_add_range(&memblock.memory, start, size, 0, 0);
+       memblock_add_range(&memblock.physmem, start, size, 0, 0);
+}
+
+void __init detect_memory_memblock(void)
 {
        unsigned long long memsize, rnmax, rzm;
-       unsigned long addr = 0, size;
-       int i = 0, type;
+       unsigned long addr, size;
+       int type;
 
        rzm = sclp_get_rzm();
        rnmax = sclp_get_rnmax();
        memsize = rzm * rnmax;
        if (!rzm)
                rzm = 1ULL << 17;
-       if (sizeof(long) == 4) {
+       if (IS_ENABLED(CONFIG_32BIT)) {
                rzm = min(ADDR2G, rzm);
-               memsize = memsize ? min(ADDR2G, memsize) : ADDR2G;
+               memsize = min(ADDR2G, memsize);
        }
-       if (maxsize)
-               memsize = memsize ? min((unsigned long)memsize, maxsize) : maxsize;
+       max_physmem_end = memsize;
+       addr = 0;
+       /* keep memblock lists close to the kernel */
+       memblock_set_bottom_up(true);
        do {
                size = 0;
                type = tprot(addr);
                do {
                        size += rzm;
-                       if (memsize && addr + size >= memsize)
+                       if (max_physmem_end && addr + size >= max_physmem_end)
                                break;
                } while (type == tprot(addr + size));
                if (type == CHUNK_READ_WRITE || type == CHUNK_READ_ONLY) {
-                       if (memsize && (addr + size > memsize))
-                               size = memsize - addr;
-                       chunk[i].addr = addr;
-                       chunk[i].size = size;
-                       chunk[i].type = type;
-                       i++;
+                       if (max_physmem_end && (addr + size > max_physmem_end))
+                               size = max_physmem_end - addr;
+                       memblock_physmem_add(addr, size);
                }
                addr += size;
-       } while (addr < memsize && i < MEMORY_CHUNKS);
-}
-
-/**
- * detect_memory_layout - fill mem_chunk array with memory layout data
- * @chunk: mem_chunk array to be filled
- * @maxsize: maximum address where memory detection should stop
- *
- * Fills the passed in memory chunk array with the memory layout of the
- * machine. The array must have a size of at least MEMORY_CHUNKS and will
- * be fully initialized afterwards.
- * If the maxsize paramater has a value > 0 memory detection will stop at
- * that address. It is guaranteed that all chunks have an ending address
- * that is smaller than maxsize.
- * If maxsize is 0 all memory will be detected.
- */
-void detect_memory_layout(struct mem_chunk chunk[], unsigned long maxsize)
-{
-       unsigned long flags, flags_dat, cr0;
-
-       memset(chunk, 0, MEMORY_CHUNKS * sizeof(struct mem_chunk));
-       /*
-        * Disable IRQs, DAT and low address protection so tprot does the
-        * right thing and we don't get scheduled away with low address
-        * protection disabled.
-        */
-       local_irq_save(flags);
-       flags_dat = __arch_local_irq_stnsm(0xfb);
-       /*
-        * In case DAT was enabled, make sure chunk doesn't reside in vmalloc
-        * space. We have disabled DAT and any access to vmalloc area will
-        * cause an exception.
-        * If DAT was disabled we are called from early ipl code.
-        */
-       if (test_bit(5, &flags_dat)) {
-               if (WARN_ON_ONCE(is_vmalloc_or_module_addr(chunk)))
-                       goto out;
-       }
-       __ctl_store(cr0, 0, 0);
-       __ctl_clear_bit(0, 28);
-       find_memory_chunks(chunk, maxsize);
-       __ctl_load(cr0, 0, 0);
-out:
-       __arch_local_irq_ssm(flags_dat);
-       local_irq_restore(flags);
-}
-EXPORT_SYMBOL(detect_memory_layout);
-
-/*
- * Create memory hole with given address and size.
- */
-void create_mem_hole(struct mem_chunk mem_chunk[], unsigned long addr,
-                    unsigned long size)
-{
-       int i;
-
-       for (i = 0; i < MEMORY_CHUNKS; i++) {
-               struct mem_chunk *chunk = &mem_chunk[i];
-
-               if (chunk->size == 0)
-                       continue;
-               if (addr > chunk->addr + chunk->size)
-                       continue;
-               if (addr + size <= chunk->addr)
-                       continue;
-               /* Split */
-               if ((addr > chunk->addr) &&
-                   (addr + size < chunk->addr + chunk->size)) {
-                       struct mem_chunk *new = chunk + 1;
-
-                       memmove(new, chunk, (MEMORY_CHUNKS-i-1) * sizeof(*new));
-                       new->addr = addr + size;
-                       new->size = chunk->addr + chunk->size - new->addr;
-                       chunk->size = addr - chunk->addr;
-                       continue;
-               } else if ((addr <= chunk->addr) &&
-                          (addr + size >= chunk->addr + chunk->size)) {
-                       memmove(chunk, chunk + 1, (MEMORY_CHUNKS-i-1) * sizeof(*chunk));
-                       memset(&mem_chunk[MEMORY_CHUNKS-1], 0, sizeof(*chunk));
-               } else if (addr + size < chunk->addr + chunk->size) {
-                       chunk->size =  chunk->addr + chunk->size - addr - size;
-                       chunk->addr = addr + size;
-               } else if (addr > chunk->addr) {
-                       chunk->size = addr - chunk->addr;
-               }
-       }
+       } while (addr < max_physmem_end);
+       memblock_set_bottom_up(false);
+       if (!max_physmem_end)
+               max_physmem_end = memblock_end_of_DRAM();
 }
index 72b04de182838f0e7e1dcc5315b9c9b4260778d6..fe9012a49aa5abf0454bf4fa8f7d421c676ded26 100644 (file)
@@ -10,6 +10,7 @@
 #include <linux/list.h>
 #include <linux/hugetlb.h>
 #include <linux/slab.h>
+#include <linux/memblock.h>
 #include <asm/pgalloc.h>
 #include <asm/pgtable.h>
 #include <asm/setup.h>
@@ -66,7 +67,8 @@ static pte_t __ref *vmem_pte_alloc(unsigned long address)
        if (slab_is_available())
                pte = (pte_t *) page_table_alloc(&init_mm, address);
        else
-               pte = alloc_bootmem(PTRS_PER_PTE * sizeof(pte_t));
+               pte = alloc_bootmem_align(PTRS_PER_PTE * sizeof(pte_t),
+                                         PTRS_PER_PTE * sizeof(pte_t));
        if (!pte)
                return NULL;
        clear_table((unsigned long *) pte, _PAGE_INVALID,
@@ -371,16 +373,14 @@ out:
 void __init vmem_map_init(void)
 {
        unsigned long ro_start, ro_end;
-       unsigned long start, end;
-       int i;
+       struct memblock_region *reg;
+       phys_addr_t start, end;
 
        ro_start = PFN_ALIGN((unsigned long)&_stext);
        ro_end = (unsigned long)&_eshared & PAGE_MASK;
-       for (i = 0; i < MEMORY_CHUNKS; i++) {
-               if (!memory_chunk[i].size)
-                       continue;
-               start = memory_chunk[i].addr;
-               end = memory_chunk[i].addr + memory_chunk[i].size;
+       for_each_memblock(memory, reg) {
+               start = reg->base;
+               end = reg->base + reg->size - 1;
                if (start >= ro_end || end <= ro_start)
                        vmem_add_mem(start, end - start, 0);
                else if (start >= ro_start && end <= ro_end)
@@ -400,23 +400,21 @@ void __init vmem_map_init(void)
 }
 
 /*
- * Convert memory chunk array to a memory segment list so there is a single
- * list that contains both r/w memory and shared memory segments.
+ * Convert memblock.memory  to a memory segment list so there is a single
+ * list that contains all memory segments.
  */
 static int __init vmem_convert_memory_chunk(void)
 {
+       struct memblock_region *reg;
        struct memory_segment *seg;
-       int i;
 
        mutex_lock(&vmem_mutex);
-       for (i = 0; i < MEMORY_CHUNKS; i++) {
-               if (!memory_chunk[i].size)
-                       continue;
+       for_each_memblock(memory, reg) {
                seg = kzalloc(sizeof(*seg), GFP_KERNEL);
                if (!seg)
                        panic("Out of memory...\n");
-               seg->start = memory_chunk[i].addr;
-               seg->size = memory_chunk[i].size;
+               seg->start = reg->base;
+               seg->size = reg->size;
                insert_memory_segment(seg);
        }
        mutex_unlock(&vmem_mutex);
index 3d8e4d63f51418c876f9918e0be77be628d2afb3..1884653e4472423bbb9e95fc7aa1dfdffa085495 100644 (file)
@@ -17,6 +17,8 @@
 #include <linux/miscdevice.h>
 #include <linux/debugfs.h>
 #include <linux/module.h>
+#include <linux/memblock.h>
+
 #include <asm/asm-offsets.h>
 #include <asm/ipl.h>
 #include <asm/sclp.h>
@@ -411,33 +413,24 @@ static ssize_t zcore_memmap_read(struct file *filp, char __user *buf,
                                 size_t count, loff_t *ppos)
 {
        return simple_read_from_buffer(buf, count, ppos, filp->private_data,
-                                      MEMORY_CHUNKS * CHUNK_INFO_SIZE);
+                                      memblock.memory.cnt * CHUNK_INFO_SIZE);
 }
 
 static int zcore_memmap_open(struct inode *inode, struct file *filp)
 {
-       int i;
+       struct memblock_region *reg;
        char *buf;
-       struct mem_chunk *chunk_array;
+       int i = 0;
 
-       chunk_array = kzalloc(MEMORY_CHUNKS * sizeof(struct mem_chunk),
-                             GFP_KERNEL);
-       if (!chunk_array)
-               return -ENOMEM;
-       detect_memory_layout(chunk_array, 0);
-       buf = kzalloc(MEMORY_CHUNKS * CHUNK_INFO_SIZE, GFP_KERNEL);
+       buf = kzalloc(memblock.memory.cnt * CHUNK_INFO_SIZE, GFP_KERNEL);
        if (!buf) {
-               kfree(chunk_array);
                return -ENOMEM;
        }
-       for (i = 0; i < MEMORY_CHUNKS; i++) {
-               sprintf(buf + (i * CHUNK_INFO_SIZE), "%016llx %016llx ",
-                       (unsigned long long) chunk_array[i].addr,
-                       (unsigned long long) chunk_array[i].size);
-               if (chunk_array[i].size == 0)
-                       break;
+       for_each_memblock(memory, reg) {
+               sprintf(buf + (i++ * CHUNK_INFO_SIZE), "%016llx %016llx ",
+                       (unsigned long long) reg->base,
+                       (unsigned long long) reg->size);
        }
-       kfree(chunk_array);
        filp->private_data = buf;
        return nonseekable_open(inode, filp);
 }
@@ -593,21 +586,12 @@ static int __init check_sdias(void)
 
 static int __init get_mem_info(unsigned long *mem, unsigned long *end)
 {
-       int i;
-       struct mem_chunk *chunk_array;
+       struct memblock_region *reg;
 
-       chunk_array = kzalloc(MEMORY_CHUNKS * sizeof(struct mem_chunk),
-                             GFP_KERNEL);
-       if (!chunk_array)
-               return -ENOMEM;
-       detect_memory_layout(chunk_array, 0);
-       for (i = 0; i < MEMORY_CHUNKS; i++) {
-               if (chunk_array[i].size == 0)
-                       break;
-               *mem += chunk_array[i].size;
-               *end = max(*end, chunk_array[i].addr + chunk_array[i].size);
+       for_each_memblock(memory, reg) {
+               *mem += reg->size;
+               *end = max_t(unsigned long, *end, reg->base + reg->size);
        }
-       kfree(chunk_array);
        return 0;
 }