tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

mm/memblock: add memblock_alloc_or_panic interface

Before SLUB initialization, various subsystems used memblock_alloc to
allocate memory. In most cases, when memory allocation fails, an
immediate panic is required. To simplify this behavior and reduce
repetitive checks, introduce `memblock_alloc_or_panic`. This function
ensures that memory allocation failures result in a panic automatically,
improving code readability and consistency across subsystems that require
this behavior.

[guoweikang.kernel@gmail.com: arch/s390: save_area_alloc default failure behavior changed to panic]
Link: https://lkml.kernel.org/r/20250109033136.2845676-1-guoweikang.kernel@gmail.com
Link: https://lore.kernel.org/lkml/Z2fknmnNtiZbCc7x@kernel.org/
Link: https://lkml.kernel.org/r/20250102072528.650926-1-guoweikang.kernel@gmail.com
Signed-off-by: Guo Weikang <guoweikang.kernel@gmail.com>
Acked-by: Geert Uytterhoeven <geert@linux-m68k.org> [m68k]
Reviewed-by: Alexander Gordeev <agordeev@linux.ibm.com> [s390]
Acked-by: Mike Rapoport (Microsoft) <rppt@kernel.org>
Cc: Alexander Gordeev <agordeev@linux.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

authored by

Guo Weikang and committed by
Andrew Morton c6f23979 f8d4a6ca

+144 -431
+1 -4
arch/alpha/kernel/core_cia.c
··· 331 331 long i; 332 332 333 333 /* Use minimal 1K map. */ 334 - ppte = memblock_alloc(CIA_BROKEN_TBIA_SIZE, 32768); 335 - if (!ppte) 336 - panic("%s: Failed to allocate %u bytes align=0x%x\n", 337 - __func__, CIA_BROKEN_TBIA_SIZE, 32768); 334 + ppte = memblock_alloc_or_panic(CIA_BROKEN_TBIA_SIZE, 32768); 338 335 pte = (virt_to_phys(ppte) >> (PAGE_SHIFT - 1)) | 1; 339 336 340 337 for (i = 0; i < CIA_BROKEN_TBIA_SIZE / sizeof(unsigned long); ++i)
+2 -8
arch/alpha/kernel/core_marvel.c
··· 81 81 char *name; 82 82 83 83 sprintf(tmp, "PCI %s PE %d PORT %d", str, pe, port); 84 - name = memblock_alloc(strlen(tmp) + 1, SMP_CACHE_BYTES); 85 - if (!name) 86 - panic("%s: Failed to allocate %zu bytes\n", __func__, 87 - strlen(tmp) + 1); 84 + name = memblock_alloc_or_panic(strlen(tmp) + 1, SMP_CACHE_BYTES); 88 85 strcpy(name, tmp); 89 86 90 87 return name; ··· 116 119 return NULL; 117 120 } 118 121 119 - io7 = memblock_alloc(sizeof(*io7), SMP_CACHE_BYTES); 120 - if (!io7) 121 - panic("%s: Failed to allocate %zu bytes\n", __func__, 122 - sizeof(*io7)); 122 + io7 = memblock_alloc_or_panic(sizeof(*io7), SMP_CACHE_BYTES); 123 123 io7->pe = pe; 124 124 raw_spin_lock_init(&io7->irq_lock); 125 125
+2 -11
arch/alpha/kernel/pci.c
··· 391 391 { 392 392 struct pci_controller *hose; 393 393 394 - hose = memblock_alloc(sizeof(*hose), SMP_CACHE_BYTES); 395 - if (!hose) 396 - panic("%s: Failed to allocate %zu bytes\n", __func__, 397 - sizeof(*hose)); 394 + hose = memblock_alloc_or_panic(sizeof(*hose), SMP_CACHE_BYTES); 398 395 399 396 *hose_tail = hose; 400 397 hose_tail = &hose->next; ··· 402 405 struct resource * __init 403 406 alloc_resource(void) 404 407 { 405 - void *ptr = memblock_alloc(sizeof(struct resource), SMP_CACHE_BYTES); 406 - 407 - if (!ptr) 408 - panic("%s: Failed to allocate %zu bytes\n", __func__, 409 - sizeof(struct resource)); 410 - 411 - return ptr; 408 + return memblock_alloc_or_panic(sizeof(struct resource), SMP_CACHE_BYTES); 412 409 } 413 410 414 411
+2 -8
arch/alpha/kernel/pci_iommu.c
··· 71 71 if (align < mem_size) 72 72 align = mem_size; 73 73 74 - arena = memblock_alloc(sizeof(*arena), SMP_CACHE_BYTES); 75 - if (!arena) 76 - panic("%s: Failed to allocate %zu bytes\n", __func__, 77 - sizeof(*arena)); 78 - arena->ptes = memblock_alloc(mem_size, align); 79 - if (!arena->ptes) 80 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 81 - __func__, mem_size, align); 74 + arena = memblock_alloc_or_panic(sizeof(*arena), SMP_CACHE_BYTES); 75 + arena->ptes = memblock_alloc_or_panic(mem_size, align); 82 76 83 77 spin_lock_init(&arena->lock); 84 78 arena->hose = hose;
+2 -8
arch/arm/kernel/setup.c
··· 880 880 */ 881 881 boot_alias_start = phys_to_idmap(start); 882 882 if (arm_has_idmap_alias() && boot_alias_start != IDMAP_INVALID_ADDR) { 883 - res = memblock_alloc(sizeof(*res), SMP_CACHE_BYTES); 884 - if (!res) 885 - panic("%s: Failed to allocate %zu bytes\n", 886 - __func__, sizeof(*res)); 883 + res = memblock_alloc_or_panic(sizeof(*res), SMP_CACHE_BYTES); 887 884 res->name = "System RAM (boot alias)"; 888 885 res->start = boot_alias_start; 889 886 res->end = phys_to_idmap(res_end); ··· 888 891 request_resource(&iomem_resource, res); 889 892 } 890 893 891 - res = memblock_alloc(sizeof(*res), SMP_CACHE_BYTES); 892 - if (!res) 893 - panic("%s: Failed to allocate %zu bytes\n", __func__, 894 - sizeof(*res)); 894 + res = memblock_alloc_or_panic(sizeof(*res), SMP_CACHE_BYTES); 895 895 res->name = "System RAM"; 896 896 res->start = start; 897 897 res->end = res_end;
+3 -14
arch/arm/mm/mmu.c
··· 726 726 727 727 static void __init *early_alloc(unsigned long sz) 728 728 { 729 - void *ptr = memblock_alloc(sz, sz); 729 + return memblock_alloc_or_panic(sz, sz); 730 730 731 - if (!ptr) 732 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 733 - __func__, sz, sz); 734 - 735 - return ptr; 736 731 } 737 732 738 733 static void *__init late_alloc(unsigned long sz) ··· 1022 1027 if (!nr) 1023 1028 return; 1024 1029 1025 - svm = memblock_alloc(sizeof(*svm) * nr, __alignof__(*svm)); 1026 - if (!svm) 1027 - panic("%s: Failed to allocate %zu bytes align=0x%zx\n", 1028 - __func__, sizeof(*svm) * nr, __alignof__(*svm)); 1030 + svm = memblock_alloc_or_panic(sizeof(*svm) * nr, __alignof__(*svm)); 1029 1031 1030 1032 for (md = io_desc; nr; md++, nr--) { 1031 1033 create_mapping(md); ··· 1044 1052 struct vm_struct *vm; 1045 1053 struct static_vm *svm; 1046 1054 1047 - svm = memblock_alloc(sizeof(*svm), __alignof__(*svm)); 1048 - if (!svm) 1049 - panic("%s: Failed to allocate %zu bytes align=0x%zx\n", 1050 - __func__, sizeof(*svm), __alignof__(*svm)); 1055 + svm = memblock_alloc_or_panic(sizeof(*svm), __alignof__(*svm)); 1051 1056 1052 1057 vm = &svm->vm; 1053 1058 vm->addr = (void *)addr;
+1 -4
arch/arm/mm/nommu.c
··· 162 162 mpu_setup(); 163 163 164 164 /* allocate the zero page. */ 165 - zero_page = (void *)memblock_alloc(PAGE_SIZE, PAGE_SIZE); 166 - if (!zero_page) 167 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 168 - __func__, PAGE_SIZE, PAGE_SIZE); 165 + zero_page = (void *)memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 169 166 170 167 bootmem_init(); 171 168
+1 -3
arch/arm64/kernel/setup.c
··· 223 223 224 224 num_standard_resources = memblock.memory.cnt; 225 225 res_size = num_standard_resources * sizeof(*standard_resources); 226 - standard_resources = memblock_alloc(res_size, SMP_CACHE_BYTES); 227 - if (!standard_resources) 228 - panic("%s: Failed to allocate %zu bytes\n", __func__, res_size); 226 + standard_resources = memblock_alloc_or_panic(res_size, SMP_CACHE_BYTES); 229 227 230 228 for_each_mem_region(region) { 231 229 res = &standard_resources[i++];
+1 -1
arch/loongarch/kernel/setup.c
··· 431 431 432 432 num_standard_resources = memblock.memory.cnt; 433 433 res_size = num_standard_resources * sizeof(*standard_resources); 434 - standard_resources = memblock_alloc(res_size, SMP_CACHE_BYTES); 434 + standard_resources = memblock_alloc_or_panic(res_size, SMP_CACHE_BYTES); 435 435 436 436 for_each_mem_region(region) { 437 437 res = &standard_resources[i++];
+3 -10
arch/loongarch/mm/init.c
··· 174 174 pmd_t *pmd; 175 175 176 176 if (p4d_none(p4dp_get(p4d))) { 177 - pud = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 178 - if (!pud) 179 - panic("%s: Failed to allocate memory\n", __func__); 177 + pud = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 180 178 p4d_populate(&init_mm, p4d, pud); 181 179 #ifndef __PAGETABLE_PUD_FOLDED 182 180 pud_init(pud); ··· 183 185 184 186 pud = pud_offset(p4d, addr); 185 187 if (pud_none(pudp_get(pud))) { 186 - pmd = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 187 - if (!pmd) 188 - panic("%s: Failed to allocate memory\n", __func__); 188 + pmd = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 189 189 pud_populate(&init_mm, pud, pmd); 190 190 #ifndef __PAGETABLE_PMD_FOLDED 191 191 pmd_init(pmd); ··· 194 198 if (!pmd_present(pmdp_get(pmd))) { 195 199 pte_t *pte; 196 200 197 - pte = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 198 - if (!pte) 199 - panic("%s: Failed to allocate memory\n", __func__); 200 - 201 + pte = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 201 202 pmd_populate_kernel(&init_mm, pmd, pte); 202 203 kernel_pte_init(pte); 203 204 }
+1 -4
arch/m68k/mm/init.c
··· 68 68 69 69 high_memory = (void *) end_mem; 70 70 71 - empty_zero_page = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 72 - if (!empty_zero_page) 73 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 74 - __func__, PAGE_SIZE, PAGE_SIZE); 71 + empty_zero_page = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 75 72 max_zone_pfn[ZONE_DMA] = end_mem >> PAGE_SHIFT; 76 73 free_area_init(max_zone_pfn); 77 74 }
+2 -8
arch/m68k/mm/mcfmmu.c
··· 42 42 unsigned long max_zone_pfn[MAX_NR_ZONES] = { 0 }; 43 43 int i; 44 44 45 - empty_zero_page = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 46 - if (!empty_zero_page) 47 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 48 - __func__, PAGE_SIZE, PAGE_SIZE); 45 + empty_zero_page = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 49 46 50 47 pg_dir = swapper_pg_dir; 51 48 memset(swapper_pg_dir, 0, sizeof(swapper_pg_dir)); 52 49 53 50 size = num_pages * sizeof(pte_t); 54 51 size = (size + PAGE_SIZE) & ~(PAGE_SIZE-1); 55 - next_pgtable = (unsigned long) memblock_alloc(size, PAGE_SIZE); 56 - if (!next_pgtable) 57 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 58 - __func__, size, PAGE_SIZE); 52 + next_pgtable = (unsigned long) memblock_alloc_or_panic(size, PAGE_SIZE); 59 53 60 54 pg_dir += PAGE_OFFSET >> PGDIR_SHIFT; 61 55
+1 -4
arch/m68k/mm/motorola.c
··· 500 500 * initialize the bad page table and bad page to point 501 501 * to a couple of allocated pages 502 502 */ 503 - empty_zero_page = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 504 - if (!empty_zero_page) 505 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 506 - __func__, PAGE_SIZE, PAGE_SIZE); 503 + empty_zero_page = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 507 504 508 505 /* 509 506 * Set up SFC/DFC registers
+2 -8
arch/m68k/mm/sun3mmu.c
··· 44 44 unsigned long max_zone_pfn[MAX_NR_ZONES] = { 0, }; 45 45 unsigned long size; 46 46 47 - empty_zero_page = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 48 - if (!empty_zero_page) 49 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 50 - __func__, PAGE_SIZE, PAGE_SIZE); 47 + empty_zero_page = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 51 48 52 49 address = PAGE_OFFSET; 53 50 pg_dir = swapper_pg_dir; ··· 54 57 size = num_pages * sizeof(pte_t); 55 58 size = (size + PAGE_SIZE) & ~(PAGE_SIZE-1); 56 59 57 - next_pgtable = (unsigned long)memblock_alloc(size, PAGE_SIZE); 58 - if (!next_pgtable) 59 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 60 - __func__, size, PAGE_SIZE); 60 + next_pgtable = (unsigned long)memblock_alloc_or_panic(size, PAGE_SIZE); 61 61 bootmem_end = (next_pgtable + size + PAGE_SIZE) & PAGE_MASK; 62 62 63 63 /* Map whole memory from PAGE_OFFSET (0x0E000000) */
+1 -5
arch/m68k/sun3/sun3dvma.c
··· 252 252 253 253 list_add(&(hole->list), &hole_list); 254 254 255 - iommu_use = memblock_alloc(IOMMU_TOTAL_ENTRIES * sizeof(unsigned long), 255 + iommu_use = memblock_alloc_or_panic(IOMMU_TOTAL_ENTRIES * sizeof(unsigned long), 256 256 SMP_CACHE_BYTES); 257 - if (!iommu_use) 258 - panic("%s: Failed to allocate %zu bytes\n", __func__, 259 - IOMMU_TOTAL_ENTRIES * sizeof(unsigned long)); 260 - 261 257 dvma_unmap_iommu(DVMA_START, DVMA_SIZE); 262 258 263 259 sun3_dvma_init();
+1 -4
arch/mips/kernel/setup.c
··· 704 704 for_each_mem_range(i, &start, &end) { 705 705 struct resource *res; 706 706 707 - res = memblock_alloc(sizeof(struct resource), SMP_CACHE_BYTES); 708 - if (!res) 709 - panic("%s: Failed to allocate %zu bytes\n", __func__, 710 - sizeof(struct resource)); 707 + res = memblock_alloc_or_panic(sizeof(struct resource), SMP_CACHE_BYTES); 711 708 712 709 res->start = start; 713 710 /*
+1 -4
arch/openrisc/mm/ioremap.c
··· 38 38 if (likely(mem_init_done)) { 39 39 pte = (pte_t *)get_zeroed_page(GFP_KERNEL); 40 40 } else { 41 - pte = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 42 - if (!pte) 43 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 44 - __func__, PAGE_SIZE, PAGE_SIZE); 41 + pte = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 45 42 } 46 43 47 44 return pte;
+5 -15
arch/parisc/mm/init.c
··· 377 377 378 378 #if CONFIG_PGTABLE_LEVELS == 3 379 379 if (pud_none(*pud)) { 380 - pmd = memblock_alloc(PAGE_SIZE << PMD_TABLE_ORDER, 380 + pmd = memblock_alloc_or_panic(PAGE_SIZE << PMD_TABLE_ORDER, 381 381 PAGE_SIZE << PMD_TABLE_ORDER); 382 - if (!pmd) 383 - panic("pmd allocation failed.\n"); 384 382 pud_populate(NULL, pud, pmd); 385 383 } 386 384 #endif ··· 386 388 pmd = pmd_offset(pud, vaddr); 387 389 for (tmp1 = start_pmd; tmp1 < PTRS_PER_PMD; tmp1++, pmd++) { 388 390 if (pmd_none(*pmd)) { 389 - pg_table = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 390 - if (!pg_table) 391 - panic("page table allocation failed\n"); 391 + pg_table = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 392 392 pmd_populate_kernel(NULL, pmd, pg_table); 393 393 } 394 394 ··· 644 648 } 645 649 #endif 646 650 647 - empty_zero_page = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 648 - if (!empty_zero_page) 649 - panic("zero page allocation failed.\n"); 651 + empty_zero_page = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 650 652 651 653 } 652 654 ··· 681 687 682 688 #if CONFIG_PGTABLE_LEVELS == 3 683 689 if (pud_none(*pud)) { 684 - pmd = memblock_alloc(PAGE_SIZE << PMD_TABLE_ORDER, 690 + pmd = memblock_alloc_or_panic(PAGE_SIZE << PMD_TABLE_ORDER, 685 691 PAGE_SIZE << PMD_TABLE_ORDER); 686 - if (!pmd) 687 - panic("fixmap: pmd allocation failed.\n"); 688 692 pud_populate(NULL, pud, pmd); 689 693 } 690 694 #endif 691 695 692 696 pmd = pmd_offset(pud, addr); 693 697 do { 694 - pte_t *pte = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 695 - if (!pte) 696 - panic("fixmap: pte allocation failed.\n"); 698 + pte_t *pte = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 697 699 698 700 pmd_populate_kernel(&init_mm, pmd, pte); 699 701
+4 -6
arch/powerpc/kernel/dt_cpu_ftrs.c
··· 1087 1087 /* Count and allocate space for cpu features */ 1088 1088 of_scan_flat_dt_subnodes(node, count_cpufeatures_subnodes, 1089 1089 &nr_dt_cpu_features); 1090 - dt_cpu_features = memblock_alloc(sizeof(struct dt_cpu_feature) * nr_dt_cpu_features, PAGE_SIZE); 1091 - if (!dt_cpu_features) 1092 - panic("%s: Failed to allocate %zu bytes align=0x%lx\n", 1093 - __func__, 1094 - sizeof(struct dt_cpu_feature) * nr_dt_cpu_features, 1095 - PAGE_SIZE); 1090 + dt_cpu_features = 1091 + memblock_alloc_or_panic( 1092 + sizeof(struct dt_cpu_feature) * nr_dt_cpu_features, 1093 + PAGE_SIZE); 1096 1094 1097 1095 cpufeatures_setup_start(isa); 1098 1096
+1 -4
arch/powerpc/kernel/pci_32.c
··· 213 213 struct property* of_prop; 214 214 struct device_node *dn; 215 215 216 - of_prop = memblock_alloc(sizeof(struct property) + 256, 216 + of_prop = memblock_alloc_or_panic(sizeof(struct property) + 256, 217 217 SMP_CACHE_BYTES); 218 - if (!of_prop) 219 - panic("%s: Failed to allocate %zu bytes\n", __func__, 220 - sizeof(struct property) + 256); 221 218 dn = of_find_node_by_path("/"); 222 219 if (dn) { 223 220 memset(of_prop, -1, sizeof(struct property) + 256);
+1 -4
arch/powerpc/kernel/setup-common.c
··· 458 458 459 459 DBG("smp_setup_cpu_maps()\n"); 460 460 461 - cpu_to_phys_id = memblock_alloc(nr_cpu_ids * sizeof(u32), 461 + cpu_to_phys_id = memblock_alloc_or_panic(nr_cpu_ids * sizeof(u32), 462 462 __alignof__(u32)); 463 - if (!cpu_to_phys_id) 464 - panic("%s: Failed to allocate %zu bytes align=0x%zx\n", 465 - __func__, nr_cpu_ids * sizeof(u32), __alignof__(u32)); 466 463 467 464 for_each_node_by_type(dn, "cpu") { 468 465 const __be32 *intserv;
+1 -7
arch/powerpc/kernel/setup_32.c
··· 140 140 141 141 static void *__init alloc_stack(void) 142 142 { 143 - void *ptr = memblock_alloc(THREAD_SIZE, THREAD_ALIGN); 144 - 145 - if (!ptr) 146 - panic("cannot allocate %d bytes for stack at %pS\n", 147 - THREAD_SIZE, (void *)_RET_IP_); 148 - 149 - return ptr; 143 + return memblock_alloc_or_panic(THREAD_SIZE, THREAD_ALIGN); 150 144 } 151 145 152 146 void __init irqstack_early_init(void)
+1 -4
arch/powerpc/mm/book3s32/mmu.c
··· 377 377 * Find some memory for the hash table. 378 378 */ 379 379 if ( ppc_md.progress ) ppc_md.progress("hash:find piece", 0x322); 380 - Hash = memblock_alloc(Hash_size, Hash_size); 381 - if (!Hash) 382 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 383 - __func__, Hash_size, Hash_size); 380 + Hash = memblock_alloc_or_panic(Hash_size, Hash_size); 384 381 _SDR1 = __pa(Hash) | SDR1_LOW_BITS; 385 382 386 383 pr_info("Total memory = %lldMB; using %ldkB for hash table\n",
+1 -5
arch/powerpc/mm/book3s64/pgtable.c
··· 330 330 unsigned long ptcr; 331 331 332 332 /* Initialize the Partition Table with no entries */ 333 - partition_tb = memblock_alloc(patb_size, patb_size); 334 - if (!partition_tb) 335 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 336 - __func__, patb_size, patb_size); 337 - 333 + partition_tb = memblock_alloc_or_panic(patb_size, patb_size); 338 334 ptcr = __pa(partition_tb) | (PATB_SIZE_SHIFT - 12); 339 335 set_ptcr_when_no_uv(ptcr); 340 336 powernv_set_nmmu_ptcr(ptcr);
+4 -4
arch/powerpc/mm/kasan/init_book3e_64.c
··· 40 40 pgdp = pgd_offset_k(ea); 41 41 p4dp = p4d_offset(pgdp, ea); 42 42 if (kasan_pud_table(*p4dp)) { 43 - pudp = memblock_alloc(PUD_TABLE_SIZE, PUD_TABLE_SIZE); 43 + pudp = memblock_alloc_or_panic(PUD_TABLE_SIZE, PUD_TABLE_SIZE); 44 44 memcpy(pudp, kasan_early_shadow_pud, PUD_TABLE_SIZE); 45 45 p4d_populate(&init_mm, p4dp, pudp); 46 46 } 47 47 pudp = pud_offset(p4dp, ea); 48 48 if (kasan_pmd_table(*pudp)) { 49 - pmdp = memblock_alloc(PMD_TABLE_SIZE, PMD_TABLE_SIZE); 49 + pmdp = memblock_alloc_or_panic(PMD_TABLE_SIZE, PMD_TABLE_SIZE); 50 50 memcpy(pmdp, kasan_early_shadow_pmd, PMD_TABLE_SIZE); 51 51 pud_populate(&init_mm, pudp, pmdp); 52 52 } 53 53 pmdp = pmd_offset(pudp, ea); 54 54 if (kasan_pte_table(*pmdp)) { 55 - ptep = memblock_alloc(PTE_TABLE_SIZE, PTE_TABLE_SIZE); 55 + ptep = memblock_alloc_or_panic(PTE_TABLE_SIZE, PTE_TABLE_SIZE); 56 56 memcpy(ptep, kasan_early_shadow_pte, PTE_TABLE_SIZE); 57 57 pmd_populate_kernel(&init_mm, pmdp, ptep); 58 58 } ··· 74 74 k_start = ALIGN_DOWN((unsigned long)kasan_mem_to_shadow(start), PAGE_SIZE); 75 75 k_end = ALIGN((unsigned long)kasan_mem_to_shadow(end), PAGE_SIZE); 76 76 77 - va = memblock_alloc(k_end - k_start, PAGE_SIZE); 77 + va = memblock_alloc_or_panic(k_end - k_start, PAGE_SIZE); 78 78 for (k_cur = k_start; k_cur < k_end; k_cur += PAGE_SIZE, va += PAGE_SIZE) 79 79 kasan_map_kernel_page(k_cur, __pa(va), PAGE_KERNEL); 80 80 }
+1 -1
arch/powerpc/mm/kasan/init_book3s_64.c
··· 32 32 k_start = ALIGN_DOWN((unsigned long)kasan_mem_to_shadow(start), PAGE_SIZE); 33 33 k_end = ALIGN((unsigned long)kasan_mem_to_shadow(end), PAGE_SIZE); 34 34 35 - va = memblock_alloc(k_end - k_start, PAGE_SIZE); 35 + va = memblock_alloc_or_panic(k_end - k_start, PAGE_SIZE); 36 36 for (k_cur = k_start; k_cur < k_end; k_cur += PAGE_SIZE, va += PAGE_SIZE) 37 37 map_kernel_page(k_cur, __pa(va), PAGE_KERNEL); 38 38 }
+3 -13
arch/powerpc/mm/nohash/mmu_context.c
··· 385 385 /* 386 386 * Allocate the maps used by context management 387 387 */ 388 - context_map = memblock_alloc(CTX_MAP_SIZE, SMP_CACHE_BYTES); 389 - if (!context_map) 390 - panic("%s: Failed to allocate %zu bytes\n", __func__, 391 - CTX_MAP_SIZE); 392 - context_mm = memblock_alloc(sizeof(void *) * (LAST_CONTEXT + 1), 388 + context_map = memblock_alloc_or_panic(CTX_MAP_SIZE, SMP_CACHE_BYTES); 389 + context_mm = memblock_alloc_or_panic(sizeof(void *) * (LAST_CONTEXT + 1), 393 390 SMP_CACHE_BYTES); 394 - if (!context_mm) 395 - panic("%s: Failed to allocate %zu bytes\n", __func__, 396 - sizeof(void *) * (LAST_CONTEXT + 1)); 397 391 if (IS_ENABLED(CONFIG_SMP)) { 398 - stale_map[boot_cpuid] = memblock_alloc(CTX_MAP_SIZE, SMP_CACHE_BYTES); 399 - if (!stale_map[boot_cpuid]) 400 - panic("%s: Failed to allocate %zu bytes\n", __func__, 401 - CTX_MAP_SIZE); 402 - 392 + stale_map[boot_cpuid] = memblock_alloc_or_panic(CTX_MAP_SIZE, SMP_CACHE_BYTES); 403 393 cpuhp_setup_state_nocalls(CPUHP_POWERPC_MMU_CTX_PREPARE, 404 394 "powerpc/mmu/ctx:prepare", 405 395 mmu_ctx_cpu_prepare, mmu_ctx_cpu_dead);
+1 -6
arch/powerpc/mm/pgtable_32.c
··· 50 50 51 51 void __init *early_alloc_pgtable(unsigned long size) 52 52 { 53 - void *ptr = memblock_alloc(size, size); 53 + return memblock_alloc_or_panic(size, size); 54 54 55 - if (!ptr) 56 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 57 - __func__, size, size); 58 - 59 - return ptr; 60 55 } 61 56 62 57 pte_t __init *early_pte_alloc_kernel(pmd_t *pmdp, unsigned long va)
+1 -4
arch/powerpc/platforms/powermac/nvram.c
··· 514 514 printk(KERN_ERR "nvram: no address\n"); 515 515 return -EINVAL; 516 516 } 517 - nvram_image = memblock_alloc(NVRAM_SIZE, SMP_CACHE_BYTES); 518 - if (!nvram_image) 519 - panic("%s: Failed to allocate %u bytes\n", __func__, 520 - NVRAM_SIZE); 517 + nvram_image = memblock_alloc_or_panic(NVRAM_SIZE, SMP_CACHE_BYTES); 521 518 nvram_data = ioremap(addr, NVRAM_SIZE*2); 522 519 nvram_naddrs = 1; /* Make sure we get the correct case */ 523 520
+1 -4
arch/powerpc/platforms/powernv/opal.c
··· 180 180 /* 181 181 * Allocate a buffer to hold the MC recoverable ranges. 182 182 */ 183 - mc_recoverable_range = memblock_alloc(size, __alignof__(u64)); 184 - if (!mc_recoverable_range) 185 - panic("%s: Failed to allocate %u bytes align=0x%lx\n", 186 - __func__, size, __alignof__(u64)); 183 + mc_recoverable_range = memblock_alloc_or_panic(size, __alignof__(u64)); 187 184 188 185 for (i = 0; i < mc_recoverable_range_len; i++) { 189 186 mc_recoverable_range[i].start_addr =
+1 -4
arch/powerpc/platforms/ps3/setup.c
··· 115 115 if (!p->size) 116 116 return; 117 117 118 - p->address = memblock_alloc(p->size, p->align); 119 - if (!p->address) 120 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 121 - __func__, p->size, p->align); 118 + p->address = memblock_alloc_or_panic(p->size, p->align); 122 119 123 120 printk(KERN_INFO "%s: %lu bytes at %p\n", p->name, p->size, 124 121 p->address);
+1 -4
arch/powerpc/sysdev/msi_bitmap.c
··· 124 124 if (bmp->bitmap_from_slab) 125 125 bmp->bitmap = kzalloc(size, GFP_KERNEL); 126 126 else { 127 - bmp->bitmap = memblock_alloc(size, SMP_CACHE_BYTES); 128 - if (!bmp->bitmap) 129 - panic("%s: Failed to allocate %u bytes\n", __func__, 130 - size); 127 + bmp->bitmap = memblock_alloc_or_panic(size, SMP_CACHE_BYTES); 131 128 /* the bitmap won't be freed from memblock allocator */ 132 129 kmemleak_not_leak(bmp->bitmap); 133 130 }
+1 -3
arch/riscv/kernel/setup.c
··· 147 147 res_idx = num_resources - 1; 148 148 149 149 mem_res_sz = num_resources * sizeof(*mem_res); 150 - mem_res = memblock_alloc(mem_res_sz, SMP_CACHE_BYTES); 151 - if (!mem_res) 152 - panic("%s: Failed to allocate %zu bytes\n", __func__, mem_res_sz); 150 + mem_res = memblock_alloc_or_panic(mem_res_sz, SMP_CACHE_BYTES); 153 151 154 152 /* 155 153 * Start by adding the reserved regions, if they overlap
+7 -7
arch/riscv/mm/kasan_init.c
··· 32 32 pte_t *ptep, *p; 33 33 34 34 if (pmd_none(pmdp_get(pmd))) { 35 - p = memblock_alloc(PTRS_PER_PTE * sizeof(pte_t), PAGE_SIZE); 35 + p = memblock_alloc_or_panic(PTRS_PER_PTE * sizeof(pte_t), PAGE_SIZE); 36 36 set_pmd(pmd, pfn_pmd(PFN_DOWN(__pa(p)), PAGE_TABLE)); 37 37 } 38 38 ··· 54 54 unsigned long next; 55 55 56 56 if (pud_none(pudp_get(pud))) { 57 - p = memblock_alloc(PTRS_PER_PMD * sizeof(pmd_t), PAGE_SIZE); 57 + p = memblock_alloc_or_panic(PTRS_PER_PMD * sizeof(pmd_t), PAGE_SIZE); 58 58 set_pud(pud, pfn_pud(PFN_DOWN(__pa(p)), PAGE_TABLE)); 59 59 } 60 60 ··· 85 85 unsigned long next; 86 86 87 87 if (p4d_none(p4dp_get(p4d))) { 88 - p = memblock_alloc(PTRS_PER_PUD * sizeof(pud_t), PAGE_SIZE); 88 + p = memblock_alloc_or_panic(PTRS_PER_PUD * sizeof(pud_t), PAGE_SIZE); 89 89 set_p4d(p4d, pfn_p4d(PFN_DOWN(__pa(p)), PAGE_TABLE)); 90 90 } 91 91 ··· 116 116 unsigned long next; 117 117 118 118 if (pgd_none(pgdp_get(pgd))) { 119 - p = memblock_alloc(PTRS_PER_P4D * sizeof(p4d_t), PAGE_SIZE); 119 + p = memblock_alloc_or_panic(PTRS_PER_P4D * sizeof(p4d_t), PAGE_SIZE); 120 120 set_pgd(pgd, pfn_pgd(PFN_DOWN(__pa(p)), PAGE_TABLE)); 121 121 } 122 122 ··· 385 385 next = pud_addr_end(vaddr, end); 386 386 387 387 if (pud_none(pudp_get(pud_k))) { 388 - p = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 388 + p = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 389 389 set_pud(pud_k, pfn_pud(PFN_DOWN(__pa(p)), PAGE_TABLE)); 390 390 continue; 391 391 } ··· 405 405 next = p4d_addr_end(vaddr, end); 406 406 407 407 if (p4d_none(p4dp_get(p4d_k))) { 408 - p = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 408 + p = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 409 409 set_p4d(p4d_k, pfn_p4d(PFN_DOWN(__pa(p)), PAGE_TABLE)); 410 410 continue; 411 411 } ··· 424 424 next = pgd_addr_end(vaddr, end); 425 425 426 426 if (pgd_none(pgdp_get(pgd_k))) { 427 - p = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 427 + p = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 428 428 set_pgd(pgd_k, pfn_pgd(PFN_DOWN(__pa(p)), PAGE_TABLE)); 429 429 continue; 430 430 }
+1 -3
arch/s390/kernel/crash_dump.c
··· 63 63 { 64 64 struct save_area *sa; 65 65 66 - sa = memblock_alloc(sizeof(*sa), 8); 67 - if (!sa) 68 - return NULL; 66 + sa = memblock_alloc_or_panic(sizeof(*sa), 8); 69 67 70 68 if (is_boot_cpu) 71 69 list_add(&sa->list, &dump_save_areas);
+2 -6
arch/s390/kernel/numa.c
··· 21 21 nodes_clear(node_possible_map); 22 22 node_set(0, node_possible_map); 23 23 node_set_online(0); 24 - for (nid = 0; nid < MAX_NUMNODES; nid++) { 25 - NODE_DATA(nid) = memblock_alloc(sizeof(pg_data_t), 8); 26 - if (!NODE_DATA(nid)) 27 - panic("%s: Failed to allocate %zu bytes align=0x%x\n", 28 - __func__, sizeof(pg_data_t), 8); 29 - } 24 + for (nid = 0; nid < MAX_NUMNODES; nid++) 25 + NODE_DATA(nid) = memblock_alloc_or_panic(sizeof(pg_data_t), 8); 30 26 NODE_DATA(0)->node_spanned_pages = memblock_end_of_DRAM() >> PAGE_SHIFT; 31 27 NODE_DATA(0)->node_id = 0; 32 28 }
+4 -16
arch/s390/kernel/setup.c
··· 384 384 { 385 385 unsigned long stack; 386 386 387 - stack = (unsigned long)memblock_alloc(THREAD_SIZE, THREAD_SIZE); 388 - if (!stack) { 389 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 390 - __func__, THREAD_SIZE, THREAD_SIZE); 391 - } 387 + stack = (unsigned long)memblock_alloc_or_panic(THREAD_SIZE, THREAD_SIZE); 392 388 return stack; 393 389 } 394 390 ··· 508 512 bss_resource.end = __pa_symbol(__bss_stop) - 1; 509 513 510 514 for_each_mem_range(i, &start, &end) { 511 - res = memblock_alloc(sizeof(*res), 8); 512 - if (!res) 513 - panic("%s: Failed to allocate %zu bytes align=0x%x\n", 514 - __func__, sizeof(*res), 8); 515 + res = memblock_alloc_or_panic(sizeof(*res), 8); 515 516 res->flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM; 516 517 517 518 res->name = "System RAM"; ··· 527 534 std_res->start > res->end) 528 535 continue; 529 536 if (std_res->end > res->end) { 530 - sub_res = memblock_alloc(sizeof(*sub_res), 8); 531 - if (!sub_res) 532 - panic("%s: Failed to allocate %zu bytes align=0x%x\n", 533 - __func__, sizeof(*sub_res), 8); 537 + sub_res = memblock_alloc_or_panic(sizeof(*sub_res), 8); 534 538 *sub_res = *std_res; 535 539 sub_res->end = res->end; 536 540 std_res->start = res->end + 1; ··· 814 824 { 815 825 struct sysinfo_3_2_2 *vmms; 816 826 817 - vmms = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 818 - if (!vmms) 819 - panic("Failed to allocate memory for sysinfo structure\n"); 827 + vmms = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 820 828 if (stsi(vmms, 3, 2, 2) == 0 && vmms->count) 821 829 add_device_randomness(&vmms->vm, sizeof(vmms->vm[0]) * vmms->count); 822 830 memblock_free(vmms, PAGE_SIZE);
+2 -9
arch/s390/kernel/smp.c
··· 611 611 if (!dump_available()) 612 612 return; 613 613 sa = save_area_alloc(true); 614 - regs = memblock_alloc(512, 8); 615 - if (!sa || !regs) 616 - panic("could not allocate memory for boot CPU save area\n"); 614 + regs = memblock_alloc_or_panic(512, 8); 617 615 copy_oldmem_kernel(regs, __LC_FPREGS_SAVE_AREA, 512); 618 616 save_area_add_regs(sa, regs); 619 617 memblock_free(regs, 512); ··· 644 646 SIGP_CC_NOT_OPERATIONAL) 645 647 continue; 646 648 sa = save_area_alloc(false); 647 - if (!sa) 648 - panic("could not allocate memory for save area\n"); 649 649 __pcpu_sigp_relax(addr, SIGP_STORE_STATUS_AT_ADDRESS, __pa(page)); 650 650 save_area_add_regs(sa, page); 651 651 if (cpu_has_vx()) { ··· 788 792 u16 address; 789 793 790 794 /* Get CPU information */ 791 - info = memblock_alloc(sizeof(*info), 8); 792 - if (!info) 793 - panic("%s: Failed to allocate %zu bytes align=0x%x\n", 794 - __func__, sizeof(*info), 8); 795 + info = memblock_alloc_or_panic(sizeof(*info), 8); 795 796 smp_get_core_info(info, 1); 796 797 /* Find boot CPU type */ 797 798 if (sclp.has_core_type) {
+2 -8
arch/s390/kernel/topology.c
··· 548 548 nr_masks *= info->mag[TOPOLOGY_NR_MAG - offset - 1 - i]; 549 549 nr_masks = max(nr_masks, 1); 550 550 for (i = 0; i < nr_masks; i++) { 551 - mask->next = memblock_alloc(sizeof(*mask->next), 8); 552 - if (!mask->next) 553 - panic("%s: Failed to allocate %zu bytes align=0x%x\n", 554 - __func__, sizeof(*mask->next), 8); 551 + mask->next = memblock_alloc_or_panic(sizeof(*mask->next), 8); 555 552 mask = mask->next; 556 553 } 557 554 } ··· 566 569 } 567 570 if (!MACHINE_HAS_TOPOLOGY) 568 571 goto out; 569 - tl_info = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 570 - if (!tl_info) 571 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 572 - __func__, PAGE_SIZE, PAGE_SIZE); 572 + tl_info = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 573 573 info = tl_info; 574 574 store_topology(info); 575 575 pr_info("The CPU configuration topology of the machine is: %d %d %d %d %d %d / %d\n",
+2 -8
arch/sh/mm/init.c
··· 137 137 if (pud_none(*pud)) { 138 138 pmd_t *pmd; 139 139 140 - pmd = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 141 - if (!pmd) 142 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 143 - __func__, PAGE_SIZE, PAGE_SIZE); 140 + pmd = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 144 141 pud_populate(&init_mm, pud, pmd); 145 142 BUG_ON(pmd != pmd_offset(pud, 0)); 146 143 } ··· 150 153 if (pmd_none(*pmd)) { 151 154 pte_t *pte; 152 155 153 - pte = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 154 - if (!pte) 155 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 156 - __func__, PAGE_SIZE, PAGE_SIZE); 156 + pte = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 157 157 pmd_populate_kernel(&init_mm, pmd, pte); 158 158 BUG_ON(pte != pte_offset_kernel(pmd, 0)); 159 159 }
+1 -3
arch/sparc/kernel/prom_32.c
··· 28 28 { 29 29 void *ret; 30 30 31 - ret = memblock_alloc(size, SMP_CACHE_BYTES); 32 - if (!ret) 33 - panic("%s: Failed to allocate %lu bytes\n", __func__, size); 31 + ret = memblock_alloc_or_panic(size, SMP_CACHE_BYTES); 34 32 35 33 prom_early_allocated += size; 36 34
+3 -11
arch/sparc/mm/srmmu.c
··· 277 277 278 278 bitmap_bits = srmmu_nocache_size >> SRMMU_NOCACHE_BITMAP_SHIFT; 279 279 280 - srmmu_nocache_pool = memblock_alloc(srmmu_nocache_size, 280 + srmmu_nocache_pool = memblock_alloc_or_panic(srmmu_nocache_size, 281 281 SRMMU_NOCACHE_ALIGN_MAX); 282 - if (!srmmu_nocache_pool) 283 - panic("%s: Failed to allocate %lu bytes align=0x%x\n", 284 - __func__, srmmu_nocache_size, SRMMU_NOCACHE_ALIGN_MAX); 285 282 memset(srmmu_nocache_pool, 0, srmmu_nocache_size); 286 283 287 284 srmmu_nocache_bitmap = 288 - memblock_alloc(BITS_TO_LONGS(bitmap_bits) * sizeof(long), 285 + memblock_alloc_or_panic(BITS_TO_LONGS(bitmap_bits) * sizeof(long), 289 286 SMP_CACHE_BYTES); 290 - if (!srmmu_nocache_bitmap) 291 - panic("%s: Failed to allocate %zu bytes\n", __func__, 292 - BITS_TO_LONGS(bitmap_bits) * sizeof(long)); 293 287 bit_map_init(&srmmu_nocache_map, srmmu_nocache_bitmap, bitmap_bits); 294 288 295 289 srmmu_swapper_pg_dir = __srmmu_get_nocache(SRMMU_PGD_TABLE_SIZE, SRMMU_PGD_TABLE_SIZE); ··· 446 452 unsigned long size; 447 453 448 454 size = numctx * sizeof(struct ctx_list); 449 - ctx_list_pool = memblock_alloc(size, SMP_CACHE_BYTES); 450 - if (!ctx_list_pool) 451 - panic("%s: Failed to allocate %lu bytes\n", __func__, size); 455 + ctx_list_pool = memblock_alloc_or_panic(size, SMP_CACHE_BYTES); 452 456 453 457 for (ctx = 0; ctx < numctx; ctx++) { 454 458 struct ctx_list *clist;
+1 -4
arch/um/drivers/net_kern.c
··· 636 636 return 1; 637 637 } 638 638 639 - new = memblock_alloc(sizeof(*new), SMP_CACHE_BYTES); 640 - if (!new) 641 - panic("%s: Failed to allocate %zu bytes\n", __func__, 642 - sizeof(*new)); 639 + new = memblock_alloc_or_panic(sizeof(*new), SMP_CACHE_BYTES); 643 640 644 641 INIT_LIST_HEAD(&new->list); 645 642 new->index = n;
+1 -4
arch/um/drivers/vector_kern.c
··· 1694 1694 str, error); 1695 1695 return 1; 1696 1696 } 1697 - new = memblock_alloc(sizeof(*new), SMP_CACHE_BYTES); 1698 - if (!new) 1699 - panic("%s: Failed to allocate %zu bytes\n", __func__, 1700 - sizeof(*new)); 1697 + new = memblock_alloc_or_panic(sizeof(*new), SMP_CACHE_BYTES); 1701 1698 INIT_LIST_HEAD(&new->list); 1702 1699 new->unit = n; 1703 1700 new->arguments = str;
+1 -3
arch/um/kernel/load_file.c
··· 48 48 return NULL; 49 49 } 50 50 51 - area = memblock_alloc(*size, SMP_CACHE_BYTES); 52 - if (!area) 53 - panic("%s: Failed to allocate %llu bytes\n", __func__, *size); 51 + area = memblock_alloc_or_panic(*size, SMP_CACHE_BYTES); 54 52 55 53 if (__uml_load_file(filename, area, *size)) { 56 54 memblock_free(area, *size);
+1 -3
arch/x86/coco/sev/core.c
··· 1572 1572 struct svsm_ca *caa; 1573 1573 1574 1574 /* Allocate the SVSM CA page if an SVSM is present */ 1575 - caa = memblock_alloc(sizeof(*caa), PAGE_SIZE); 1576 - if (!caa) 1577 - panic("Can't allocate SVSM CA page\n"); 1575 + caa = memblock_alloc_or_panic(sizeof(*caa), PAGE_SIZE); 1578 1576 1579 1577 per_cpu(svsm_caa, cpu) = caa; 1580 1578 per_cpu(svsm_caa_pa, cpu) = __pa(caa);
+1 -4
arch/x86/kernel/acpi/boot.c
··· 911 911 * the resource tree during the lateinit timeframe. 912 912 */ 913 913 #define HPET_RESOURCE_NAME_SIZE 9 914 - hpet_res = memblock_alloc(sizeof(*hpet_res) + HPET_RESOURCE_NAME_SIZE, 914 + hpet_res = memblock_alloc_or_panic(sizeof(*hpet_res) + HPET_RESOURCE_NAME_SIZE, 915 915 SMP_CACHE_BYTES); 916 - if (!hpet_res) 917 - panic("%s: Failed to allocate %zu bytes\n", __func__, 918 - sizeof(*hpet_res) + HPET_RESOURCE_NAME_SIZE); 919 916 920 917 hpet_res->name = (void *)&hpet_res[1]; 921 918 hpet_res->flags = IORESOURCE_MEM;
+2 -7
arch/x86/kernel/apic/io_apic.c
··· 2503 2503 n = IOAPIC_RESOURCE_NAME_SIZE + sizeof(struct resource); 2504 2504 n *= nr_ioapics; 2505 2505 2506 - mem = memblock_alloc(n, SMP_CACHE_BYTES); 2507 - if (!mem) 2508 - panic("%s: Failed to allocate %lu bytes\n", __func__, n); 2506 + mem = memblock_alloc_or_panic(n, SMP_CACHE_BYTES); 2509 2507 res = (void *)mem; 2510 2508 2511 2509 mem += sizeof(struct resource) * nr_ioapics; ··· 2562 2564 #ifdef CONFIG_X86_32 2563 2565 fake_ioapic_page: 2564 2566 #endif 2565 - ioapic_phys = (unsigned long)memblock_alloc(PAGE_SIZE, 2567 + ioapic_phys = (unsigned long)memblock_alloc_or_panic(PAGE_SIZE, 2566 2568 PAGE_SIZE); 2567 - if (!ioapic_phys) 2568 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 2569 - __func__, PAGE_SIZE, PAGE_SIZE); 2570 2569 ioapic_phys = __pa(ioapic_phys); 2571 2570 } 2572 2571 io_apic_set_fixmap(idx, ioapic_phys);
+1 -4
arch/x86/kernel/e820.c
··· 1146 1146 struct resource *res; 1147 1147 u64 end; 1148 1148 1149 - res = memblock_alloc(sizeof(*res) * e820_table->nr_entries, 1149 + res = memblock_alloc_or_panic(sizeof(*res) * e820_table->nr_entries, 1150 1150 SMP_CACHE_BYTES); 1151 - if (!res) 1152 - panic("%s: Failed to allocate %zu bytes\n", __func__, 1153 - sizeof(*res) * e820_table->nr_entries); 1154 1151 e820_res = res; 1155 1152 1156 1153 for (i = 0; i < e820_table->nr_entries; i++) {
+1 -5
arch/x86/platform/olpc/olpc_dt.c
··· 136 136 * fast enough on the platforms we care about while minimizing 137 137 * wasted bootmem) and hand off chunks of it to callers. 138 138 */ 139 - res = memblock_alloc(chunk_size, SMP_CACHE_BYTES); 140 - if (!res) 141 - panic("%s: Failed to allocate %zu bytes\n", __func__, 142 - chunk_size); 143 - BUG_ON(!res); 139 + res = memblock_alloc_or_panic(chunk_size, SMP_CACHE_BYTES); 144 140 prom_early_allocated += chunk_size; 145 141 memset(res, 0, chunk_size); 146 142 free_mem = chunk_size;
+1 -7
arch/x86/xen/p2m.c
··· 178 178 static void * __ref alloc_p2m_page(void) 179 179 { 180 180 if (unlikely(!slab_is_available())) { 181 - void *ptr = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 182 - 183 - if (!ptr) 184 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 185 - __func__, PAGE_SIZE, PAGE_SIZE); 186 - 187 - return ptr; 181 + return memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE); 188 182 } 189 183 190 184 return (void *)__get_free_page(GFP_KERNEL);
+1 -5
arch/xtensa/mm/kasan_init.c
··· 39 39 unsigned long i, j; 40 40 unsigned long vaddr = (unsigned long)start; 41 41 pmd_t *pmd = pmd_off_k(vaddr); 42 - pte_t *pte = memblock_alloc(n_pages * sizeof(pte_t), PAGE_SIZE); 43 - 44 - if (!pte) 45 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 46 - __func__, n_pages * sizeof(pte_t), PAGE_SIZE); 42 + pte_t *pte = memblock_alloc_or_panic(n_pages * sizeof(pte_t), PAGE_SIZE); 47 43 48 44 pr_debug("%s: %p - %p\n", __func__, start, end); 49 45
+1 -4
drivers/clk/ti/clk.c
··· 449 449 { 450 450 struct clk_iomap *io; 451 451 452 - io = memblock_alloc(sizeof(*io), SMP_CACHE_BYTES); 453 - if (!io) 454 - panic("%s: Failed to allocate %zu bytes\n", __func__, 455 - sizeof(*io)); 452 + io = memblock_alloc_or_panic(sizeof(*io), SMP_CACHE_BYTES); 456 453 457 454 io->mem = mem; 458 455
+1 -5
drivers/macintosh/smu.c
··· 492 492 goto fail_np; 493 493 } 494 494 495 - smu = memblock_alloc(sizeof(struct smu_device), SMP_CACHE_BYTES); 496 - if (!smu) 497 - panic("%s: Failed to allocate %zu bytes\n", __func__, 498 - sizeof(struct smu_device)); 499 - 495 + smu = memblock_alloc_or_panic(sizeof(struct smu_device), SMP_CACHE_BYTES); 500 496 spin_lock_init(&smu->lock); 501 497 INIT_LIST_HEAD(&smu->cmd_list); 502 498 INIT_LIST_HEAD(&smu->cmd_i2c_list);
+1 -7
drivers/of/fdt.c
··· 1126 1126 1127 1127 static void * __init early_init_dt_alloc_memory_arch(u64 size, u64 align) 1128 1128 { 1129 - void *ptr = memblock_alloc(size, align); 1130 - 1131 - if (!ptr) 1132 - panic("%s: Failed to allocate %llu bytes align=0x%llx\n", 1133 - __func__, size, align); 1134 - 1135 - return ptr; 1129 + return memblock_alloc_or_panic(size, align); 1136 1130 } 1137 1131 1138 1132 bool __init early_init_dt_verify(void *dt_virt, phys_addr_t dt_phys)
+1 -7
drivers/of/unittest.c
··· 3666 3666 3667 3667 static void * __init dt_alloc_memory(u64 size, u64 align) 3668 3668 { 3669 - void *ptr = memblock_alloc(size, align); 3670 - 3671 - if (!ptr) 3672 - panic("%s: Failed to allocate %llu bytes align=0x%llx\n", 3673 - __func__, size, align); 3674 - 3675 - return ptr; 3669 + return memblock_alloc_or_panic(size, align); 3676 3670 } 3677 3671 3678 3672 /*
+6
include/linux/memblock.h
··· 421 421 MEMBLOCK_ALLOC_ACCESSIBLE, NUMA_NO_NODE); 422 422 } 423 423 424 + void *__memblock_alloc_or_panic(phys_addr_t size, phys_addr_t align, 425 + const char *func); 426 + 427 + #define memblock_alloc_or_panic(size, align) \ 428 + __memblock_alloc_or_panic(size, align, __func__) 429 + 424 430 static inline void *memblock_alloc_raw(phys_addr_t size, 425 431 phys_addr_t align) 426 432 {
+4 -14
init/main.c
··· 640 640 641 641 len = xlen + strlen(boot_command_line) + ilen + 1; 642 642 643 - saved_command_line = memblock_alloc(len, SMP_CACHE_BYTES); 644 - if (!saved_command_line) 645 - panic("%s: Failed to allocate %zu bytes\n", __func__, len); 643 + saved_command_line = memblock_alloc_or_panic(len, SMP_CACHE_BYTES); 646 644 647 645 len = xlen + strlen(command_line) + 1; 648 646 649 - static_command_line = memblock_alloc(len, SMP_CACHE_BYTES); 650 - if (!static_command_line) 651 - panic("%s: Failed to allocate %zu bytes\n", __func__, len); 647 + static_command_line = memblock_alloc_or_panic(len, SMP_CACHE_BYTES); 652 648 653 649 if (xlen) { 654 650 /* ··· 1141 1145 str_entry = strsep(&str, ","); 1142 1146 if (str_entry) { 1143 1147 pr_debug("blacklisting initcall %s\n", str_entry); 1144 - entry = memblock_alloc(sizeof(*entry), 1148 + entry = memblock_alloc_or_panic(sizeof(*entry), 1145 1149 SMP_CACHE_BYTES); 1146 - if (!entry) 1147 - panic("%s: Failed to allocate %zu bytes\n", 1148 - __func__, sizeof(*entry)); 1149 - entry->buf = memblock_alloc(strlen(str_entry) + 1, 1150 + entry->buf = memblock_alloc_or_panic(strlen(str_entry) + 1, 1150 1151 SMP_CACHE_BYTES); 1151 - if (!entry->buf) 1152 - panic("%s: Failed to allocate %zu bytes\n", 1153 - __func__, strlen(str_entry) + 1); 1154 1152 strcpy(entry->buf, str_entry); 1155 1153 list_add(&entry->next, &blacklisted_initcalls); 1156 1154 }
+1 -4
kernel/power/snapshot.c
··· 1011 1011 } 1012 1012 } 1013 1013 /* This allocation cannot fail */ 1014 - region = memblock_alloc(sizeof(struct nosave_region), 1014 + region = memblock_alloc_or_panic(sizeof(struct nosave_region), 1015 1015 SMP_CACHE_BYTES); 1016 - if (!region) 1017 - panic("%s: Failed to allocate %zu bytes\n", __func__, 1018 - sizeof(struct nosave_region)); 1019 1016 region->start_pfn = start_pfn; 1020 1017 region->end_pfn = end_pfn; 1021 1018 list_add_tail(&region->list, &nosave_regions);
+1 -4
lib/cpumask.c
··· 83 83 */ 84 84 void __init alloc_bootmem_cpumask_var(cpumask_var_t *mask) 85 85 { 86 - *mask = memblock_alloc(cpumask_size(), SMP_CACHE_BYTES); 87 - if (!*mask) 88 - panic("%s: Failed to allocate %u bytes\n", __func__, 89 - cpumask_size()); 86 + *mask = memblock_alloc_or_panic(cpumask_size(), SMP_CACHE_BYTES); 90 87 } 91 88 92 89 /**
+2 -6
mm/kmsan/shadow.c
··· 280 280 281 281 start = (void *)PAGE_ALIGN_DOWN((u64)start); 282 282 size = PAGE_ALIGN((u64)end - (u64)start); 283 - shadow = memblock_alloc(size, PAGE_SIZE); 284 - origin = memblock_alloc(size, PAGE_SIZE); 285 - 286 - if (!shadow || !origin) 287 - panic("%s: Failed to allocate metadata memory for early boot range of size %llu", 288 - __func__, size); 283 + shadow = memblock_alloc_or_panic(size, PAGE_SIZE); 284 + origin = memblock_alloc_or_panic(size, PAGE_SIZE); 289 285 290 286 for (u64 addr = 0; addr < size; addr += PAGE_SIZE) { 291 287 page = virt_to_page_or_null((char *)start + addr);
+20
mm/memblock.c
··· 1692 1692 } 1693 1693 1694 1694 /** 1695 + * __memblock_alloc_or_panic - Try to allocate memory and panic on failure 1696 + * @size: size of memory block to be allocated in bytes 1697 + * @align: alignment of the region and block's size 1698 + * @func: caller func name 1699 + * 1700 + * This function attempts to allocate memory using memblock_alloc, 1701 + * and in case of failure, it calls panic with the formatted message. 1702 + * This function should not be used directly, please use the macro memblock_alloc_or_panic. 1703 + */ 1704 + void *__init __memblock_alloc_or_panic(phys_addr_t size, phys_addr_t align, 1705 + const char *func) 1706 + { 1707 + void *addr = memblock_alloc(size, align); 1708 + 1709 + if (unlikely(!addr)) 1710 + panic("%s: Failed to allocate %pap bytes\n", func, &size); 1711 + return addr; 1712 + } 1713 + 1714 + /** 1695 1715 * memblock_free_late - free pages directly to buddy allocator 1696 1716 * @base: phys starting address of the boot memory block 1697 1717 * @size: size of the boot memory block in bytes
+1 -7
mm/numa.c
··· 37 37 void __init alloc_offline_node_data(int nid) 38 38 { 39 39 pg_data_t *pgdat; 40 - 41 - pgdat = memblock_alloc(sizeof(*pgdat), SMP_CACHE_BYTES); 42 - if (!pgdat) 43 - panic("Cannot allocate %zuB for node %d.\n", 44 - sizeof(*pgdat), nid); 45 - 46 - node_data[nid] = pgdat; 40 + node_data[nid] = memblock_alloc_or_panic(sizeof(*pgdat), SMP_CACHE_BYTES); 47 41 } 48 42 49 43 /* Stub functions: */
+14 -56
mm/percpu.c
··· 1359 1359 /* allocate chunk */ 1360 1360 alloc_size = struct_size(chunk, populated, 1361 1361 BITS_TO_LONGS(region_size >> PAGE_SHIFT)); 1362 - chunk = memblock_alloc(alloc_size, SMP_CACHE_BYTES); 1363 - if (!chunk) 1364 - panic("%s: Failed to allocate %zu bytes\n", __func__, 1365 - alloc_size); 1362 + chunk = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES); 1366 1363 1367 1364 INIT_LIST_HEAD(&chunk->list); 1368 1365 ··· 1371 1374 region_bits = pcpu_chunk_map_bits(chunk); 1372 1375 1373 1376 alloc_size = BITS_TO_LONGS(region_bits) * sizeof(chunk->alloc_map[0]); 1374 - chunk->alloc_map = memblock_alloc(alloc_size, SMP_CACHE_BYTES); 1375 - if (!chunk->alloc_map) 1376 - panic("%s: Failed to allocate %zu bytes\n", __func__, 1377 - alloc_size); 1377 + chunk->alloc_map = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES); 1378 1378 1379 1379 alloc_size = 1380 1380 BITS_TO_LONGS(region_bits + 1) * sizeof(chunk->bound_map[0]); 1381 - chunk->bound_map = memblock_alloc(alloc_size, SMP_CACHE_BYTES); 1382 - if (!chunk->bound_map) 1383 - panic("%s: Failed to allocate %zu bytes\n", __func__, 1384 - alloc_size); 1381 + chunk->bound_map = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES); 1385 1382 1386 1383 alloc_size = pcpu_chunk_nr_blocks(chunk) * sizeof(chunk->md_blocks[0]); 1387 - chunk->md_blocks = memblock_alloc(alloc_size, SMP_CACHE_BYTES); 1388 - if (!chunk->md_blocks) 1389 - panic("%s: Failed to allocate %zu bytes\n", __func__, 1390 - alloc_size); 1391 - 1384 + chunk->md_blocks = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES); 1392 1385 #ifdef NEED_PCPUOBJ_EXT 1393 1386 /* first chunk is free to use */ 1394 1387 chunk->obj_exts = NULL; ··· 2582 2595 2583 2596 /* process group information and build config tables accordingly */ 2584 2597 alloc_size = ai->nr_groups * sizeof(group_offsets[0]); 2585 - group_offsets = memblock_alloc(alloc_size, SMP_CACHE_BYTES); 2586 - if (!group_offsets) 2587 - panic("%s: Failed to allocate %zu bytes\n", __func__, 2588 - alloc_size); 2598 + group_offsets = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES); 2589 2599 2590 2600 alloc_size = ai->nr_groups * sizeof(group_sizes[0]); 2591 - group_sizes = memblock_alloc(alloc_size, SMP_CACHE_BYTES); 2592 - if (!group_sizes) 2593 - panic("%s: Failed to allocate %zu bytes\n", __func__, 2594 - alloc_size); 2601 + group_sizes = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES); 2595 2602 2596 2603 alloc_size = nr_cpu_ids * sizeof(unit_map[0]); 2597 - unit_map = memblock_alloc(alloc_size, SMP_CACHE_BYTES); 2598 - if (!unit_map) 2599 - panic("%s: Failed to allocate %zu bytes\n", __func__, 2600 - alloc_size); 2604 + unit_map = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES); 2601 2605 2602 2606 alloc_size = nr_cpu_ids * sizeof(unit_off[0]); 2603 - unit_off = memblock_alloc(alloc_size, SMP_CACHE_BYTES); 2604 - if (!unit_off) 2605 - panic("%s: Failed to allocate %zu bytes\n", __func__, 2606 - alloc_size); 2607 + unit_off = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES); 2607 2608 2608 2609 for (cpu = 0; cpu < nr_cpu_ids; cpu++) 2609 2610 unit_map[cpu] = UINT_MAX; ··· 2660 2685 pcpu_free_slot = pcpu_sidelined_slot + 1; 2661 2686 pcpu_to_depopulate_slot = pcpu_free_slot + 1; 2662 2687 pcpu_nr_slots = pcpu_to_depopulate_slot + 1; 2663 - pcpu_chunk_lists = memblock_alloc(pcpu_nr_slots * 2688 + pcpu_chunk_lists = memblock_alloc_or_panic(pcpu_nr_slots * 2664 2689 sizeof(pcpu_chunk_lists[0]), 2665 2690 SMP_CACHE_BYTES); 2666 - if (!pcpu_chunk_lists) 2667 - panic("%s: Failed to allocate %zu bytes\n", __func__, 2668 - pcpu_nr_slots * sizeof(pcpu_chunk_lists[0])); 2669 2691 2670 2692 for (i = 0; i < pcpu_nr_slots; i++) 2671 2693 INIT_LIST_HEAD(&pcpu_chunk_lists[i]); ··· 3127 3155 pmd_t *pmd; 3128 3156 3129 3157 if (pgd_none(*pgd)) { 3130 - p4d = memblock_alloc(P4D_TABLE_SIZE, P4D_TABLE_SIZE); 3131 - if (!p4d) 3132 - goto err_alloc; 3158 + p4d = memblock_alloc_or_panic(P4D_TABLE_SIZE, P4D_TABLE_SIZE); 3133 3159 pgd_populate(&init_mm, pgd, p4d); 3134 3160 } 3135 3161 3136 3162 p4d = p4d_offset(pgd, addr); 3137 3163 if (p4d_none(*p4d)) { 3138 - pud = memblock_alloc(PUD_TABLE_SIZE, PUD_TABLE_SIZE); 3139 - if (!pud) 3140 - goto err_alloc; 3164 + pud = memblock_alloc_or_panic(PUD_TABLE_SIZE, PUD_TABLE_SIZE); 3141 3165 p4d_populate(&init_mm, p4d, pud); 3142 3166 } 3143 3167 3144 3168 pud = pud_offset(p4d, addr); 3145 3169 if (pud_none(*pud)) { 3146 - pmd = memblock_alloc(PMD_TABLE_SIZE, PMD_TABLE_SIZE); 3147 - if (!pmd) 3148 - goto err_alloc; 3170 + pmd = memblock_alloc_or_panic(PMD_TABLE_SIZE, PMD_TABLE_SIZE); 3149 3171 pud_populate(&init_mm, pud, pmd); 3150 3172 } 3151 3173 ··· 3147 3181 if (!pmd_present(*pmd)) { 3148 3182 pte_t *new; 3149 3183 3150 - new = memblock_alloc(PTE_TABLE_SIZE, PTE_TABLE_SIZE); 3151 - if (!new) 3152 - goto err_alloc; 3184 + new = memblock_alloc_or_panic(PTE_TABLE_SIZE, PTE_TABLE_SIZE); 3153 3185 pmd_populate_kernel(&init_mm, pmd, new); 3154 3186 } 3155 3187 3156 3188 return; 3157 - 3158 - err_alloc: 3159 - panic("%s: Failed to allocate memory\n", __func__); 3160 3189 } 3161 3190 3162 3191 /** ··· 3198 3237 /* unaligned allocations can't be freed, round up to page size */ 3199 3238 pages_size = PFN_ALIGN(unit_pages * num_possible_cpus() * 3200 3239 sizeof(pages[0])); 3201 - pages = memblock_alloc(pages_size, SMP_CACHE_BYTES); 3202 - if (!pages) 3203 - panic("%s: Failed to allocate %zu bytes\n", __func__, 3204 - pages_size); 3240 + pages = memblock_alloc_or_panic(pages_size, SMP_CACHE_BYTES); 3205 3241 3206 3242 /* allocate pages */ 3207 3243 j = 0;
+1 -4
mm/sparse.c
··· 257 257 258 258 size = sizeof(struct mem_section *) * NR_SECTION_ROOTS; 259 259 align = 1 << (INTERNODE_CACHE_SHIFT); 260 - mem_section = memblock_alloc(size, align); 261 - if (!mem_section) 262 - panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 263 - __func__, size, align); 260 + mem_section = memblock_alloc_or_panic(size, align); 264 261 } 265 262 #endif 266 263