Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * Procedures for maintaining information about logical memory blocks.
4 : : *
5 : : * Peter Bergner, IBM Corp. June 2001.
6 : : * Copyright (C) 2001 Peter Bergner.
7 : : */
8 : :
9 : : #include <linux/kernel.h>
10 : : #include <linux/slab.h>
11 : : #include <linux/init.h>
12 : : #include <linux/bitops.h>
13 : : #include <linux/poison.h>
14 : : #include <linux/pfn.h>
15 : : #include <linux/debugfs.h>
16 : : #include <linux/kmemleak.h>
17 : : #include <linux/seq_file.h>
18 : : #include <linux/memblock.h>
19 : :
20 : : #include <asm/sections.h>
21 : : #include <linux/io.h>
22 : :
23 : : #include "internal.h"
24 : :
25 : : #define INIT_MEMBLOCK_REGIONS 128
26 : : #define INIT_PHYSMEM_REGIONS 4
27 : :
28 : : #ifndef INIT_MEMBLOCK_RESERVED_REGIONS
29 : : # define INIT_MEMBLOCK_RESERVED_REGIONS INIT_MEMBLOCK_REGIONS
30 : : #endif
31 : :
32 : : /**
33 : : * DOC: memblock overview
34 : : *
35 : : * Memblock is a method of managing memory regions during the early
36 : : * boot period when the usual kernel memory allocators are not up and
37 : : * running.
38 : : *
39 : : * Memblock views the system memory as collections of contiguous
40 : : * regions. There are several types of these collections:
41 : : *
42 : : * * ``memory`` - describes the physical memory available to the
43 : : * kernel; this may differ from the actual physical memory installed
44 : : * in the system, for instance when the memory is restricted with
45 : : * ``mem=`` command line parameter
46 : : * * ``reserved`` - describes the regions that were allocated
47 : : * * ``physmap`` - describes the actual physical memory regardless of
48 : : * the possible restrictions; the ``physmap`` type is only available
49 : : * on some architectures.
50 : : *
51 : : * Each region is represented by :c:type:`struct memblock_region` that
52 : : * defines the region extents, its attributes and NUMA node id on NUMA
53 : : * systems. Every memory type is described by the :c:type:`struct
54 : : * memblock_type` which contains an array of memory regions along with
55 : : * the allocator metadata. The memory types are nicely wrapped with
56 : : * :c:type:`struct memblock`. This structure is statically initialzed
57 : : * at build time. The region arrays for the "memory" and "reserved"
58 : : * types are initially sized to %INIT_MEMBLOCK_REGIONS and for the
59 : : * "physmap" type to %INIT_PHYSMEM_REGIONS.
60 : : * The memblock_allow_resize() enables automatic resizing of the region
61 : : * arrays during addition of new regions. This feature should be used
62 : : * with care so that memory allocated for the region array will not
63 : : * overlap with areas that should be reserved, for example initrd.
64 : : *
65 : : * The early architecture setup should tell memblock what the physical
66 : : * memory layout is by using memblock_add() or memblock_add_node()
67 : : * functions. The first function does not assign the region to a NUMA
68 : : * node and it is appropriate for UMA systems. Yet, it is possible to
69 : : * use it on NUMA systems as well and assign the region to a NUMA node
70 : : * later in the setup process using memblock_set_node(). The
71 : : * memblock_add_node() performs such an assignment directly.
72 : : *
73 : : * Once memblock is setup the memory can be allocated using one of the
74 : : * API variants:
75 : : *
76 : : * * memblock_phys_alloc*() - these functions return the **physical**
77 : : * address of the allocated memory
78 : : * * memblock_alloc*() - these functions return the **virtual** address
79 : : * of the allocated memory.
80 : : *
81 : : * Note, that both API variants use implict assumptions about allowed
82 : : * memory ranges and the fallback methods. Consult the documentation
83 : : * of memblock_alloc_internal() and memblock_alloc_range_nid()
84 : : * functions for more elaborate description.
85 : : *
86 : : * As the system boot progresses, the architecture specific mem_init()
87 : : * function frees all the memory to the buddy page allocator.
88 : : *
89 : : * Unless an architecture enables %CONFIG_ARCH_KEEP_MEMBLOCK, the
90 : : * memblock data structures will be discarded after the system
91 : : * initialization completes.
92 : : */
93 : :
94 : : #ifndef CONFIG_NEED_MULTIPLE_NODES
95 : : struct pglist_data __refdata contig_page_data;
96 : : EXPORT_SYMBOL(contig_page_data);
97 : : #endif
98 : :
99 : : unsigned long max_low_pfn;
100 : : unsigned long min_low_pfn;
101 : : unsigned long max_pfn;
102 : : unsigned long long max_possible_pfn;
103 : :
104 : : static struct memblock_region memblock_memory_init_regions[INIT_MEMBLOCK_REGIONS] __initdata_memblock;
105 : : static struct memblock_region memblock_reserved_init_regions[INIT_MEMBLOCK_RESERVED_REGIONS] __initdata_memblock;
106 : : #ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
107 : : static struct memblock_region memblock_physmem_init_regions[INIT_PHYSMEM_REGIONS] __initdata_memblock;
108 : : #endif
109 : :
110 : : struct memblock memblock __initdata_memblock = {
111 : : .memory.regions = memblock_memory_init_regions,
112 : : .memory.cnt = 1, /* empty dummy entry */
113 : : .memory.max = INIT_MEMBLOCK_REGIONS,
114 : : .memory.name = "memory",
115 : :
116 : : .reserved.regions = memblock_reserved_init_regions,
117 : : .reserved.cnt = 1, /* empty dummy entry */
118 : : .reserved.max = INIT_MEMBLOCK_RESERVED_REGIONS,
119 : : .reserved.name = "reserved",
120 : :
121 : : #ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
122 : : .physmem.regions = memblock_physmem_init_regions,
123 : : .physmem.cnt = 1, /* empty dummy entry */
124 : : .physmem.max = INIT_PHYSMEM_REGIONS,
125 : : .physmem.name = "physmem",
126 : : #endif
127 : :
128 : : .bottom_up = false,
129 : : .current_limit = MEMBLOCK_ALLOC_ANYWHERE,
130 : : };
131 : :
132 : : int memblock_debug __initdata_memblock;
133 : : static bool system_has_some_mirror __initdata_memblock = false;
134 : : static int memblock_can_resize __initdata_memblock;
135 : : static int memblock_memory_in_slab __initdata_memblock = 0;
136 : : static int memblock_reserved_in_slab __initdata_memblock = 0;
137 : :
138 : 12936 : static enum memblock_flags __init_memblock choose_memblock_flags(void)
139 : : {
140 [ + - ]: 12936 : return system_has_some_mirror ? MEMBLOCK_MIRROR : MEMBLOCK_NONE;
141 : : }
142 : :
143 : : /* adjust *@size so that (@base + *@size) doesn't overflow, return new size */
144 : 13244 : static inline phys_addr_t memblock_cap_size(phys_addr_t base, phys_addr_t *size)
145 : : {
146 : 13244 : return *size = min(*size, PHYS_ADDR_MAX - base);
147 : : }
148 : :
149 : : /*
150 : : * Address comparison utilities
151 : : */
152 : 11 : static unsigned long __init_memblock memblock_addrs_overlap(phys_addr_t base1, phys_addr_t size1,
153 : : phys_addr_t base2, phys_addr_t size2)
154 : : {
155 [ - + ]: 11 : return ((base1 < (base2 + size2)) && (base2 < (base1 + size1)));
156 : : }
157 : :
158 : 11 : bool __init_memblock memblock_overlaps_region(struct memblock_type *type,
159 : : phys_addr_t base, phys_addr_t size)
160 : : {
161 : 11 : unsigned long i;
162 : :
163 [ + - ]: 11 : for (i = 0; i < type->cnt; i++)
164 [ - + ]: 11 : if (memblock_addrs_overlap(base, size, type->regions[i].base,
165 [ + - ]: 11 : type->regions[i].size))
166 : : break;
167 : 11 : return i < type->cnt;
168 : : }
169 : :
170 : : /**
171 : : * __memblock_find_range_bottom_up - find free area utility in bottom-up
172 : : * @start: start of candidate range
173 : : * @end: end of candidate range, can be %MEMBLOCK_ALLOC_ANYWHERE or
174 : : * %MEMBLOCK_ALLOC_ACCESSIBLE
175 : : * @size: size of free area to find
176 : : * @align: alignment of free area to find
177 : : * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
178 : : * @flags: pick from blocks based on memory attributes
179 : : *
180 : : * Utility called from memblock_find_in_range_node(), find free area bottom-up.
181 : : *
182 : : * Return:
183 : : * Found address on success, 0 on failure.
184 : : */
185 : : static phys_addr_t __init_memblock
186 : 0 : __memblock_find_range_bottom_up(phys_addr_t start, phys_addr_t end,
187 : : phys_addr_t size, phys_addr_t align, int nid,
188 : : enum memblock_flags flags)
189 : : {
190 : 0 : phys_addr_t this_start, this_end, cand;
191 : 0 : u64 i;
192 : :
193 [ # # ]: 0 : for_each_free_mem_range(i, nid, flags, &this_start, &this_end, NULL) {
194 : 0 : this_start = clamp(this_start, start, end);
195 : 0 : this_end = clamp(this_end, start, end);
196 : :
197 : 0 : cand = round_up(this_start, align);
198 [ # # # # ]: 0 : if (cand < this_end && this_end - cand >= size)
199 : 0 : return cand;
200 : : }
201 : :
202 : : return 0;
203 : : }
204 : :
205 : : /**
206 : : * __memblock_find_range_top_down - find free area utility, in top-down
207 : : * @start: start of candidate range
208 : : * @end: end of candidate range, can be %MEMBLOCK_ALLOC_ANYWHERE or
209 : : * %MEMBLOCK_ALLOC_ACCESSIBLE
210 : : * @size: size of free area to find
211 : : * @align: alignment of free area to find
212 : : * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
213 : : * @flags: pick from blocks based on memory attributes
214 : : *
215 : : * Utility called from memblock_find_in_range_node(), find free area top-down.
216 : : *
217 : : * Return:
218 : : * Found address on success, 0 on failure.
219 : : */
220 : : static phys_addr_t __init_memblock
221 : 12936 : __memblock_find_range_top_down(phys_addr_t start, phys_addr_t end,
222 : : phys_addr_t size, phys_addr_t align, int nid,
223 : : enum memblock_flags flags)
224 : : {
225 : 12936 : phys_addr_t this_start, this_end, cand;
226 : 12936 : u64 i;
227 : :
228 [ + - ]: 31383 : for_each_free_mem_range_reverse(i, nid, flags, &this_start, &this_end,
229 : : NULL) {
230 : 31383 : this_start = clamp(this_start, start, end);
231 : 31383 : this_end = clamp(this_end, start, end);
232 : :
233 [ - + ]: 31383 : if (this_end < size)
234 : 0 : continue;
235 : :
236 : 31383 : cand = round_down(this_end - size, align);
237 [ + + ]: 31383 : if (cand >= this_start)
238 : 12936 : return cand;
239 : : }
240 : :
241 : : return 0;
242 : : }
243 : :
244 : : /**
245 : : * memblock_find_in_range_node - find free area in given range and node
246 : : * @size: size of free area to find
247 : : * @align: alignment of free area to find
248 : : * @start: start of candidate range
249 : : * @end: end of candidate range, can be %MEMBLOCK_ALLOC_ANYWHERE or
250 : : * %MEMBLOCK_ALLOC_ACCESSIBLE
251 : : * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
252 : : * @flags: pick from blocks based on memory attributes
253 : : *
254 : : * Find @size free area aligned to @align in the specified range and node.
255 : : *
256 : : * When allocation direction is bottom-up, the @start should be greater
257 : : * than the end of the kernel image. Otherwise, it will be trimmed. The
258 : : * reason is that we want the bottom-up allocation just near the kernel
259 : : * image so it is highly likely that the allocated memory and the kernel
260 : : * will reside in the same node.
261 : : *
262 : : * If bottom-up allocation failed, will try to allocate memory top-down.
263 : : *
264 : : * Return:
265 : : * Found address on success, 0 on failure.
266 : : */
267 : 12936 : static phys_addr_t __init_memblock memblock_find_in_range_node(phys_addr_t size,
268 : : phys_addr_t align, phys_addr_t start,
269 : : phys_addr_t end, int nid,
270 : : enum memblock_flags flags)
271 : : {
272 : 12936 : phys_addr_t kernel_end, ret;
273 : :
274 : : /* pump up @end */
275 [ + + ]: 12936 : if (end == MEMBLOCK_ALLOC_ACCESSIBLE ||
276 : : end == MEMBLOCK_ALLOC_KASAN)
277 : 12914 : end = memblock.current_limit;
278 : :
279 : : /* avoid allocating the first page */
280 : 12936 : start = max_t(phys_addr_t, start, PAGE_SIZE);
281 : 12936 : end = max(start, end);
282 : 12936 : kernel_end = __pa_symbol(_end);
283 : :
284 : : /*
285 : : * try bottom-up allocation only when bottom-up mode
286 : : * is set and @end is above the kernel image.
287 : : */
288 [ - + - - ]: 12936 : if (memblock_bottom_up() && end > kernel_end) {
289 : 0 : phys_addr_t bottom_up_start;
290 : :
291 : : /* make sure we will allocate above the kernel */
292 : 0 : bottom_up_start = max(start, kernel_end);
293 : :
294 : : /* ok, try bottom-up allocation first */
295 : 0 : ret = __memblock_find_range_bottom_up(bottom_up_start, end,
296 : : size, align, nid, flags);
297 [ # # ]: 0 : if (ret)
298 : : return ret;
299 : :
300 : : /*
301 : : * we always limit bottom-up allocation above the kernel,
302 : : * but top-down allocation doesn't have the limit, so
303 : : * retrying top-down allocation may succeed when bottom-up
304 : : * allocation failed.
305 : : *
306 : : * bottom-up allocation is expected to be fail very rarely,
307 : : * so we use WARN_ONCE() here to see the stack trace if
308 : : * fail happens.
309 : : */
310 : : WARN_ONCE(IS_ENABLED(CONFIG_MEMORY_HOTREMOVE),
311 : : "memblock: bottom-up allocation failed, memory hotremove may be affected\n");
312 : : }
313 : :
314 : 12936 : return __memblock_find_range_top_down(start, end, size, align, nid,
315 : : flags);
316 : : }
317 : :
318 : : /**
319 : : * memblock_find_in_range - find free area in given range
320 : : * @start: start of candidate range
321 : : * @end: end of candidate range, can be %MEMBLOCK_ALLOC_ANYWHERE or
322 : : * %MEMBLOCK_ALLOC_ACCESSIBLE
323 : : * @size: size of free area to find
324 : : * @align: alignment of free area to find
325 : : *
326 : : * Find @size free area aligned to @align in the specified range.
327 : : *
328 : : * Return:
329 : : * Found address on success, 0 on failure.
330 : : */
331 : 22 : phys_addr_t __init_memblock memblock_find_in_range(phys_addr_t start,
332 : : phys_addr_t end, phys_addr_t size,
333 : : phys_addr_t align)
334 : : {
335 : 22 : phys_addr_t ret;
336 : 22 : enum memblock_flags flags = choose_memblock_flags();
337 : :
338 : 22 : again:
339 : 22 : ret = memblock_find_in_range_node(size, align, start, end,
340 : : NUMA_NO_NODE, flags);
341 : :
342 [ - + - - ]: 22 : if (!ret && (flags & MEMBLOCK_MIRROR)) {
343 : 0 : pr_warn("Could not allocate %pap bytes of mirrored memory\n",
344 : : &size);
345 : 0 : flags &= ~MEMBLOCK_MIRROR;
346 : 0 : goto again;
347 : : }
348 : :
349 : 22 : return ret;
350 : : }
351 : :
352 : 33 : static void __init_memblock memblock_remove_region(struct memblock_type *type, unsigned long r)
353 : : {
354 : 33 : type->total_size -= type->regions[r].size;
355 : 33 : memmove(&type->regions[r], &type->regions[r + 1],
356 : 33 : (type->cnt - (r + 1)) * sizeof(type->regions[r]));
357 : 33 : type->cnt--;
358 : :
359 : : /* Special case for empty arrays */
360 [ - + ]: 33 : if (type->cnt == 0) {
361 [ # # ]: 0 : WARN_ON(type->total_size != 0);
362 : 0 : type->cnt = 1;
363 : 0 : type->regions[0].base = 0;
364 : 0 : type->regions[0].size = 0;
365 : 0 : type->regions[0].flags = 0;
366 : 0 : memblock_set_region_node(&type->regions[0], MAX_NUMNODES);
367 : : }
368 : 33 : }
369 : :
370 : : #ifndef CONFIG_ARCH_KEEP_MEMBLOCK
371 : : /**
372 : : * memblock_discard - discard memory and reserved arrays if they were allocated
373 : : */
374 : 11 : void __init memblock_discard(void)
375 : : {
376 : 11 : phys_addr_t addr, size;
377 : :
378 [ - + ]: 11 : if (memblock.reserved.regions != memblock_reserved_init_regions) {
379 [ # # ]: 0 : addr = __pa(memblock.reserved.regions);
380 : 0 : size = PAGE_ALIGN(sizeof(struct memblock_region) *
381 : : memblock.reserved.max);
382 : 0 : __memblock_free_late(addr, size);
383 : : }
384 : :
385 [ - + ]: 11 : if (memblock.memory.regions != memblock_memory_init_regions) {
386 [ # # ]: 0 : addr = __pa(memblock.memory.regions);
387 : 0 : size = PAGE_ALIGN(sizeof(struct memblock_region) *
388 : : memblock.memory.max);
389 : 0 : __memblock_free_late(addr, size);
390 : : }
391 : 11 : }
392 : : #endif
393 : :
394 : : /**
395 : : * memblock_double_array - double the size of the memblock regions array
396 : : * @type: memblock type of the regions array being doubled
397 : : * @new_area_start: starting address of memory range to avoid overlap with
398 : : * @new_area_size: size of memory range to avoid overlap with
399 : : *
400 : : * Double the size of the @type regions array. If memblock is being used to
401 : : * allocate memory for a new reserved regions array and there is a previously
402 : : * allocated memory range [@new_area_start, @new_area_start + @new_area_size]
403 : : * waiting to be reserved, ensure the memory used by the new array does
404 : : * not overlap.
405 : : *
406 : : * Return:
407 : : * 0 on success, -1 on failure.
408 : : */
409 : 0 : static int __init_memblock memblock_double_array(struct memblock_type *type,
410 : : phys_addr_t new_area_start,
411 : : phys_addr_t new_area_size)
412 : : {
413 : 0 : struct memblock_region *new_array, *old_array;
414 : 0 : phys_addr_t old_alloc_size, new_alloc_size;
415 : 0 : phys_addr_t old_size, new_size, addr, new_end;
416 : 0 : int use_slab = slab_is_available();
417 : 0 : int *in_slab;
418 : :
419 : : /* We don't allow resizing until we know about the reserved regions
420 : : * of memory that aren't suitable for allocation
421 : : */
422 [ # # ]: 0 : if (!memblock_can_resize)
423 : : return -1;
424 : :
425 : : /* Calculate new doubled size */
426 : 0 : old_size = type->max * sizeof(struct memblock_region);
427 : 0 : new_size = old_size << 1;
428 : : /*
429 : : * We need to allocated new one align to PAGE_SIZE,
430 : : * so we can free them completely later.
431 : : */
432 : 0 : old_alloc_size = PAGE_ALIGN(old_size);
433 : 0 : new_alloc_size = PAGE_ALIGN(new_size);
434 : :
435 : : /* Retrieve the slab flag */
436 [ # # ]: 0 : if (type == &memblock.memory)
437 : : in_slab = &memblock_memory_in_slab;
438 : : else
439 : 0 : in_slab = &memblock_reserved_in_slab;
440 : :
441 : : /* Try to find some space for it */
442 [ # # ]: 0 : if (use_slab) {
443 [ # # ]: 0 : new_array = kmalloc(new_size, GFP_KERNEL);
444 [ # # # # ]: 0 : addr = new_array ? __pa(new_array) : 0;
445 : : } else {
446 : : /* only exclude range when trying to double reserved.regions */
447 [ # # ]: 0 : if (type != &memblock.reserved)
448 : 0 : new_area_start = new_area_size = 0;
449 : :
450 : 0 : addr = memblock_find_in_range(new_area_start + new_area_size,
451 : : memblock.current_limit,
452 : : new_alloc_size, PAGE_SIZE);
453 [ # # ]: 0 : if (!addr && new_area_size)
454 : 0 : addr = memblock_find_in_range(0,
455 : 0 : min(new_area_start, memblock.current_limit),
456 : : new_alloc_size, PAGE_SIZE);
457 : :
458 [ # # ]: 0 : new_array = addr ? __va(addr) : NULL;
459 : : }
460 [ # # ]: 0 : if (!addr) {
461 : 0 : pr_err("memblock: Failed to double %s array from %ld to %ld entries !\n",
462 : : type->name, type->max, type->max * 2);
463 : 0 : return -1;
464 : : }
465 : :
466 : 0 : new_end = addr + new_size - 1;
467 [ # # ]: 0 : memblock_dbg("memblock: %s is doubled to %ld at [%pa-%pa]",
468 : : type->name, type->max * 2, &addr, &new_end);
469 : :
470 : : /*
471 : : * Found space, we now need to move the array over before we add the
472 : : * reserved region since it may be our reserved array itself that is
473 : : * full.
474 : : */
475 : 0 : memcpy(new_array, type->regions, old_size);
476 : 0 : memset(new_array + type->max, 0, old_size);
477 : 0 : old_array = type->regions;
478 : 0 : type->regions = new_array;
479 : 0 : type->max <<= 1;
480 : :
481 : : /* Free old array. We needn't free it if the array is the static one */
482 [ # # ]: 0 : if (*in_slab)
483 : 0 : kfree(old_array);
484 [ # # # # ]: 0 : else if (old_array != memblock_memory_init_regions &&
485 : : old_array != memblock_reserved_init_regions)
486 [ # # ]: 0 : memblock_free(__pa(old_array), old_alloc_size);
487 : :
488 : : /*
489 : : * Reserve the new array if that comes from the memblock. Otherwise, we
490 : : * needn't do it
491 : : */
492 [ # # ]: 0 : if (!use_slab)
493 [ # # ]: 0 : BUG_ON(memblock_reserve(addr, new_alloc_size));
494 : :
495 : : /* Update slab flag */
496 : 0 : *in_slab = use_slab;
497 : :
498 : 0 : return 0;
499 : : }
500 : :
501 : : /**
502 : : * memblock_merge_regions - merge neighboring compatible regions
503 : : * @type: memblock type to scan
504 : : *
505 : : * Scan @type and merge neighboring compatible regions.
506 : : */
507 : : static void __init_memblock memblock_merge_regions(struct memblock_type *type)
508 : : {
509 : : int i = 0;
510 : :
511 : : /* cnt never goes below 1 */
512 : : while (i < type->cnt - 1) {
513 : : struct memblock_region *this = &type->regions[i];
514 : : struct memblock_region *next = &type->regions[i + 1];
515 : :
516 : : if (this->base + this->size != next->base ||
517 : : memblock_get_region_node(this) !=
518 : : memblock_get_region_node(next) ||
519 : : this->flags != next->flags) {
520 : : BUG_ON(this->base + this->size > next->base);
521 : : i++;
522 : : continue;
523 : : }
524 : :
525 : : this->size += next->size;
526 : : /* move forward from next + 1, index of which is i + 2 */
527 : : memmove(next, next + 1, (type->cnt - (i + 2)) * sizeof(*next));
528 : : type->cnt--;
529 : : }
530 : : }
531 : :
532 : : /**
533 : : * memblock_insert_region - insert new memblock region
534 : : * @type: memblock type to insert into
535 : : * @idx: index for the insertion point
536 : : * @base: base address of the new region
537 : : * @size: size of the new region
538 : : * @nid: node id of the new region
539 : : * @flags: flags of the new region
540 : : *
541 : : * Insert new memblock region [@base, @base + @size) into @type at @idx.
542 : : * @type must already have extra room to accommodate the new region.
543 : : */
544 : 13057 : static void __init_memblock memblock_insert_region(struct memblock_type *type,
545 : : int idx, phys_addr_t base,
546 : : phys_addr_t size,
547 : : int nid,
548 : : enum memblock_flags flags)
549 : : {
550 : 13057 : struct memblock_region *rgn = &type->regions[idx];
551 : :
552 [ - + ]: 13057 : BUG_ON(type->cnt >= type->max);
553 : 13057 : memmove(rgn + 1, rgn, (type->cnt - idx) * sizeof(*rgn));
554 : 13057 : rgn->base = base;
555 : 13057 : rgn->size = size;
556 : 13057 : rgn->flags = flags;
557 : 13057 : memblock_set_region_node(rgn, nid);
558 : 13057 : type->cnt++;
559 : 13057 : type->total_size += size;
560 : 13057 : }
561 : :
562 : : /**
563 : : * memblock_add_range - add new memblock region
564 : : * @type: memblock type to add new region into
565 : : * @base: base address of the new region
566 : : * @size: size of the new region
567 : : * @nid: nid of the new region
568 : : * @flags: flags of the new region
569 : : *
570 : : * Add new memblock region [@base, @base + @size) into @type. The new region
571 : : * is allowed to overlap with existing ones - overlaps don't affect already
572 : : * existing regions. @type is guaranteed to be minimal (all neighbouring
573 : : * compatible regions are merged) after the addition.
574 : : *
575 : : * Return:
576 : : * 0 on success, -errno on failure.
577 : : */
578 : 13035 : static int __init_memblock memblock_add_range(struct memblock_type *type,
579 : : phys_addr_t base, phys_addr_t size,
580 : : int nid, enum memblock_flags flags)
581 : : {
582 : 13035 : bool insert = false;
583 : 13035 : phys_addr_t obase = base;
584 : 13035 : phys_addr_t end = base + memblock_cap_size(base, &size);
585 : 13035 : int idx, nr_new;
586 : 13035 : struct memblock_region *rgn;
587 : :
588 [ + - ]: 13035 : if (!size)
589 : : return 0;
590 : :
591 : : /* special case for empty array */
592 [ + + ]: 13035 : if (type->regions[0].size == 0) {
593 [ + - + - : 44 : WARN_ON(type->cnt != 1 || type->total_size);
- + ]
594 : 22 : type->regions[0].base = base;
595 : 22 : type->regions[0].size = size;
596 : 22 : type->regions[0].flags = flags;
597 : 22 : memblock_set_region_node(&type->regions[0], nid);
598 : 22 : type->total_size = size;
599 : 22 : return 0;
600 : : }
601 : 13013 : repeat:
602 : : /*
603 : : * The following is executed twice. Once with %false @insert and
604 : : * then with %true. The first counts the number of regions needed
605 : : * to accommodate the new area. The second actually inserts them.
606 : : */
607 : 26015 : base = obase;
608 : 26015 : nr_new = 0;
609 : :
610 [ + + ]: 117370 : for_each_memblock_type(idx, type, rgn) {
611 : 117304 : phys_addr_t rbase = rgn->base;
612 : 117304 : phys_addr_t rend = rbase + rgn->size;
613 : :
614 [ + + ]: 117304 : if (rbase >= end)
615 : : break;
616 [ + + ]: 91355 : if (rend <= base)
617 : 91322 : continue;
618 : : /*
619 : : * @rgn overlaps. If it separates the lower part of new
620 : : * area, insert that portion.
621 : : */
622 [ + + ]: 33 : if (rbase > base) {
623 : : #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
624 [ - + ]: 22 : WARN_ON(nid != memblock_get_region_node(rgn));
625 : : #endif
626 [ - + ]: 22 : WARN_ON(flags != rgn->flags);
627 : 22 : nr_new++;
628 [ + + ]: 22 : if (insert)
629 : 11 : memblock_insert_region(type, idx++, base,
630 : : rbase - base, nid,
631 : : flags);
632 : : }
633 : : /* area below @rend is dealt with, forget about it */
634 : 33 : base = min(rend, end);
635 : : }
636 : :
637 : : /* insert the remaining portion */
638 [ + + ]: 26015 : if (base < end) {
639 : 26004 : nr_new++;
640 [ + + ]: 26004 : if (insert)
641 : 13002 : memblock_insert_region(type, idx, base, end - base,
642 : : nid, flags);
643 : : }
644 : :
645 [ + + ]: 26015 : if (!nr_new)
646 : : return 0;
647 : :
648 : : /*
649 : : * If this was the first round, resize array and repeat for actual
650 : : * insertions; otherwise, merge and return.
651 : : */
652 [ + + ]: 26004 : if (!insert) {
653 [ - + ]: 13002 : while (type->cnt + nr_new > type->max)
654 [ # # ]: 0 : if (memblock_double_array(type, obase, size) < 0)
655 : : return -ENOMEM;
656 : 13002 : insert = true;
657 : 13002 : goto repeat;
658 : : } else {
659 : 13002 : memblock_merge_regions(type);
660 : 13002 : return 0;
661 : : }
662 : : }
663 : :
664 : : /**
665 : : * memblock_add_node - add new memblock region within a NUMA node
666 : : * @base: base address of the new region
667 : : * @size: size of the new region
668 : : * @nid: nid of the new region
669 : : *
670 : : * Add new memblock region [@base, @base + @size) to the "memory"
671 : : * type. See memblock_add_range() description for mode details
672 : : *
673 : : * Return:
674 : : * 0 on success, -errno on failure.
675 : : */
676 : 0 : int __init_memblock memblock_add_node(phys_addr_t base, phys_addr_t size,
677 : : int nid)
678 : : {
679 : 0 : return memblock_add_range(&memblock.memory, base, size, nid, 0);
680 : : }
681 : :
682 : : /**
683 : : * memblock_add - add new memblock region
684 : : * @base: base address of the new region
685 : : * @size: size of the new region
686 : : *
687 : : * Add new memblock region [@base, @base + @size) to the "memory"
688 : : * type. See memblock_add_range() description for mode details
689 : : *
690 : : * Return:
691 : : * 0 on success, -errno on failure.
692 : : */
693 : 22 : int __init_memblock memblock_add(phys_addr_t base, phys_addr_t size)
694 : : {
695 : 22 : phys_addr_t end = base + size - 1;
696 : :
697 [ - + ]: 22 : memblock_dbg("%s: [%pa-%pa] %pS\n", __func__,
698 : : &base, &end, (void *)_RET_IP_);
699 : :
700 : 22 : return memblock_add_range(&memblock.memory, base, size, MAX_NUMNODES, 0);
701 : : }
702 : :
703 : : /**
704 : : * memblock_isolate_range - isolate given range into disjoint memblocks
705 : : * @type: memblock type to isolate range for
706 : : * @base: base of range to isolate
707 : : * @size: size of range to isolate
708 : : * @start_rgn: out parameter for the start of isolated region
709 : : * @end_rgn: out parameter for the end of isolated region
710 : : *
711 : : * Walk @type and ensure that regions don't cross the boundaries defined by
712 : : * [@base, @base + @size). Crossing regions are split at the boundaries,
713 : : * which may create at most two more regions. The index of the first
714 : : * region inside the range is returned in *@start_rgn and end in *@end_rgn.
715 : : *
716 : : * Return:
717 : : * 0 on success, -errno on failure.
718 : : */
719 : 176 : static int __init_memblock memblock_isolate_range(struct memblock_type *type,
720 : : phys_addr_t base, phys_addr_t size,
721 : : int *start_rgn, int *end_rgn)
722 : : {
723 : 176 : phys_addr_t end = base + memblock_cap_size(base, &size);
724 : 176 : int idx;
725 : 176 : struct memblock_region *rgn;
726 : :
727 : 176 : *start_rgn = *end_rgn = 0;
728 : :
729 [ + - ]: 176 : if (!size)
730 : : return 0;
731 : :
732 : : /* we'll create at most two more regions */
733 [ - + ]: 176 : while (type->cnt + 2 > type->max)
734 [ # # ]: 0 : if (memblock_double_array(type, base, size) < 0)
735 : : return -ENOMEM;
736 : :
737 [ + + ]: 770 : for_each_memblock_type(idx, type, rgn) {
738 : 627 : phys_addr_t rbase = rgn->base;
739 : 627 : phys_addr_t rend = rbase + rgn->size;
740 : :
741 [ + + ]: 627 : if (rbase >= end)
742 : : break;
743 [ + + ]: 594 : if (rend <= base)
744 : 187 : continue;
745 : :
746 [ + + ]: 407 : if (rbase < base) {
747 : : /*
748 : : * @rgn intersects from below. Split and continue
749 : : * to process the next region - the new top half.
750 : : */
751 : 22 : rgn->base = base;
752 : 22 : rgn->size -= base - rbase;
753 : 22 : type->total_size -= base - rbase;
754 : 22 : memblock_insert_region(type, idx, rbase, base - rbase,
755 : : memblock_get_region_node(rgn),
756 : : rgn->flags);
757 [ + + ]: 385 : } else if (rend > end) {
758 : : /*
759 : : * @rgn intersects from above. Split and redo the
760 : : * current region - the new bottom half.
761 : : */
762 : 22 : rgn->base = end;
763 : 22 : rgn->size -= end - rbase;
764 : 22 : type->total_size -= end - rbase;
765 : 22 : memblock_insert_region(type, idx--, rbase, end - rbase,
766 : : memblock_get_region_node(rgn),
767 : : rgn->flags);
768 : : } else {
769 : : /* @rgn is fully contained, record it */
770 [ + + ]: 363 : if (!*end_rgn)
771 : 176 : *start_rgn = idx;
772 : 363 : *end_rgn = idx + 1;
773 : : }
774 : : }
775 : :
776 : : return 0;
777 : : }
778 : :
779 : 33 : static int __init_memblock memblock_remove_range(struct memblock_type *type,
780 : : phys_addr_t base, phys_addr_t size)
781 : : {
782 : 33 : int start_rgn, end_rgn;
783 : 33 : int i, ret;
784 : :
785 : 33 : ret = memblock_isolate_range(type, base, size, &start_rgn, &end_rgn);
786 [ + - ]: 33 : if (ret)
787 : : return ret;
788 : :
789 [ + + ]: 66 : for (i = end_rgn - 1; i >= start_rgn; i--)
790 : 33 : memblock_remove_region(type, i);
791 : : return 0;
792 : : }
793 : :
794 : 0 : int __init_memblock memblock_remove(phys_addr_t base, phys_addr_t size)
795 : : {
796 : 0 : phys_addr_t end = base + size - 1;
797 : :
798 [ # # ]: 0 : memblock_dbg("%s: [%pa-%pa] %pS\n", __func__,
799 : : &base, &end, (void *)_RET_IP_);
800 : :
801 : 0 : return memblock_remove_range(&memblock.memory, base, size);
802 : : }
803 : :
804 : : /**
805 : : * memblock_free - free boot memory block
806 : : * @base: phys starting address of the boot memory block
807 : : * @size: size of the boot memory block in bytes
808 : : *
809 : : * Free boot memory block previously allocated by memblock_alloc_xx() API.
810 : : * The freeing memory will not be released to the buddy allocator.
811 : : */
812 : 33 : int __init_memblock memblock_free(phys_addr_t base, phys_addr_t size)
813 : : {
814 : 33 : phys_addr_t end = base + size - 1;
815 : :
816 [ - + ]: 33 : memblock_dbg("%s: [%pa-%pa] %pS\n", __func__,
817 : : &base, &end, (void *)_RET_IP_);
818 : :
819 : 33 : kmemleak_free_part_phys(base, size);
820 : 33 : return memblock_remove_range(&memblock.reserved, base, size);
821 : : }
822 : :
823 : 13013 : int __init_memblock memblock_reserve(phys_addr_t base, phys_addr_t size)
824 : : {
825 : 13013 : phys_addr_t end = base + size - 1;
826 : :
827 [ - + ]: 13013 : memblock_dbg("%s: [%pa-%pa] %pS\n", __func__,
828 : : &base, &end, (void *)_RET_IP_);
829 : :
830 : 13013 : return memblock_add_range(&memblock.reserved, base, size, MAX_NUMNODES, 0);
831 : : }
832 : :
833 : : #ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
834 : : int __init_memblock memblock_physmem_add(phys_addr_t base, phys_addr_t size)
835 : : {
836 : : phys_addr_t end = base + size - 1;
837 : :
838 : : memblock_dbg("%s: [%pa-%pa] %pS\n", __func__,
839 : : &base, &end, (void *)_RET_IP_);
840 : :
841 : : return memblock_add_range(&memblock.physmem, base, size, MAX_NUMNODES, 0);
842 : : }
843 : : #endif
844 : :
845 : : /**
846 : : * memblock_setclr_flag - set or clear flag for a memory region
847 : : * @base: base address of the region
848 : : * @size: size of the region
849 : : * @set: set or clear the flag
850 : : * @flag: the flag to udpate
851 : : *
852 : : * This function isolates region [@base, @base + @size), and sets/clears flag
853 : : *
854 : : * Return: 0 on success, -errno on failure.
855 : : */
856 : 55 : static int __init_memblock memblock_setclr_flag(phys_addr_t base,
857 : : phys_addr_t size, int set, int flag)
858 : : {
859 : 55 : struct memblock_type *type = &memblock.memory;
860 : 55 : int i, ret, start_rgn, end_rgn;
861 : :
862 : 55 : ret = memblock_isolate_range(type, base, size, &start_rgn, &end_rgn);
863 [ + - ]: 55 : if (ret)
864 : : return ret;
865 : :
866 [ + + ]: 165 : for (i = start_rgn; i < end_rgn; i++) {
867 : 110 : struct memblock_region *r = &type->regions[i];
868 : :
869 [ - + ]: 110 : if (set)
870 : 0 : r->flags |= flag;
871 : : else
872 : 110 : r->flags &= ~flag;
873 : : }
874 : :
875 : 55 : memblock_merge_regions(type);
876 : 55 : return 0;
877 : : }
878 : :
879 : : /**
880 : : * memblock_mark_hotplug - Mark hotpluggable memory with flag MEMBLOCK_HOTPLUG.
881 : : * @base: the base phys addr of the region
882 : : * @size: the size of the region
883 : : *
884 : : * Return: 0 on success, -errno on failure.
885 : : */
886 : 0 : int __init_memblock memblock_mark_hotplug(phys_addr_t base, phys_addr_t size)
887 : : {
888 : 0 : return memblock_setclr_flag(base, size, 1, MEMBLOCK_HOTPLUG);
889 : : }
890 : :
891 : : /**
892 : : * memblock_clear_hotplug - Clear flag MEMBLOCK_HOTPLUG for a specified region.
893 : : * @base: the base phys addr of the region
894 : : * @size: the size of the region
895 : : *
896 : : * Return: 0 on success, -errno on failure.
897 : : */
898 : 55 : int __init_memblock memblock_clear_hotplug(phys_addr_t base, phys_addr_t size)
899 : : {
900 : 55 : return memblock_setclr_flag(base, size, 0, MEMBLOCK_HOTPLUG);
901 : : }
902 : :
903 : : /**
904 : : * memblock_mark_mirror - Mark mirrored memory with flag MEMBLOCK_MIRROR.
905 : : * @base: the base phys addr of the region
906 : : * @size: the size of the region
907 : : *
908 : : * Return: 0 on success, -errno on failure.
909 : : */
910 : 0 : int __init_memblock memblock_mark_mirror(phys_addr_t base, phys_addr_t size)
911 : : {
912 : 0 : system_has_some_mirror = true;
913 : :
914 : 0 : return memblock_setclr_flag(base, size, 1, MEMBLOCK_MIRROR);
915 : : }
916 : :
917 : : /**
918 : : * memblock_mark_nomap - Mark a memory region with flag MEMBLOCK_NOMAP.
919 : : * @base: the base phys addr of the region
920 : : * @size: the size of the region
921 : : *
922 : : * Return: 0 on success, -errno on failure.
923 : : */
924 : 0 : int __init_memblock memblock_mark_nomap(phys_addr_t base, phys_addr_t size)
925 : : {
926 : 0 : return memblock_setclr_flag(base, size, 1, MEMBLOCK_NOMAP);
927 : : }
928 : :
929 : : /**
930 : : * memblock_clear_nomap - Clear flag MEMBLOCK_NOMAP for a specified region.
931 : : * @base: the base phys addr of the region
932 : : * @size: the size of the region
933 : : *
934 : : * Return: 0 on success, -errno on failure.
935 : : */
936 : 0 : int __init_memblock memblock_clear_nomap(phys_addr_t base, phys_addr_t size)
937 : : {
938 : 0 : return memblock_setclr_flag(base, size, 0, MEMBLOCK_NOMAP);
939 : : }
940 : :
941 : : /**
942 : : * __next_reserved_mem_region - next function for for_each_reserved_region()
943 : : * @idx: pointer to u64 loop variable
944 : : * @out_start: ptr to phys_addr_t for start address of the region, can be %NULL
945 : : * @out_end: ptr to phys_addr_t for end address of the region, can be %NULL
946 : : *
947 : : * Iterate over all reserved memory regions.
948 : : */
949 : 341 : void __init_memblock __next_reserved_mem_region(u64 *idx,
950 : : phys_addr_t *out_start,
951 : : phys_addr_t *out_end)
952 : : {
953 : 341 : struct memblock_type *type = &memblock.reserved;
954 : :
955 [ + + ]: 341 : if (*idx < type->cnt) {
956 : 330 : struct memblock_region *r = &type->regions[*idx];
957 : 330 : phys_addr_t base = r->base;
958 : 330 : phys_addr_t size = r->size;
959 : :
960 [ + - ]: 330 : if (out_start)
961 : 330 : *out_start = base;
962 [ + - ]: 330 : if (out_end)
963 : 330 : *out_end = base + size - 1;
964 : :
965 : 330 : *idx += 1;
966 : 330 : return;
967 : : }
968 : :
969 : : /* signal end of iteration */
970 : 11 : *idx = ULLONG_MAX;
971 : : }
972 : :
973 : 31834 : static bool should_skip_region(struct memblock_region *m, int nid, int flags)
974 : : {
975 : 31834 : int m_nid = memblock_get_region_node(m);
976 : :
977 : : /* only memory regions are associated with nodes, check it */
978 : 31834 : if (nid != NUMA_NO_NODE && nid != m_nid)
979 : : return true;
980 : :
981 : : /* skip hotpluggable memory regions if needed */
982 [ - + - + ]: 31834 : if (movable_node_is_enabled() && memblock_is_hotpluggable(m))
983 : : return true;
984 : :
985 : : /* if we want mirror memory skip non-mirror memory regions */
986 [ - + - - : 31834 : if ((flags & MEMBLOCK_MIRROR) && !memblock_is_mirror(m))
- + - - ]
987 : : return true;
988 : :
989 : : /* skip nomap memory unless we were asked for it explicitly */
990 [ + - - + : 31834 : if (!(flags & MEMBLOCK_NOMAP) && memblock_is_nomap(m))
+ - - + ]
991 : : return true;
992 : :
993 : : return false;
994 : : }
995 : :
996 : : /**
997 : : * __next_mem_range - next function for for_each_free_mem_range() etc.
998 : : * @idx: pointer to u64 loop variable
999 : : * @nid: node selector, %NUMA_NO_NODE for all nodes
1000 : : * @flags: pick from blocks based on memory attributes
1001 : : * @type_a: pointer to memblock_type from where the range is taken
1002 : : * @type_b: pointer to memblock_type which excludes memory from being taken
1003 : : * @out_start: ptr to phys_addr_t for start address of the range, can be %NULL
1004 : : * @out_end: ptr to phys_addr_t for end address of the range, can be %NULL
1005 : : * @out_nid: ptr to int for nid of the range, can be %NULL
1006 : : *
1007 : : * Find the first area from *@idx which matches @nid, fill the out
1008 : : * parameters, and update *@idx for the next iteration. The lower 32bit of
1009 : : * *@idx contains index into type_a and the upper 32bit indexes the
1010 : : * areas before each region in type_b. For example, if type_b regions
1011 : : * look like the following,
1012 : : *
1013 : : * 0:[0-16), 1:[32-48), 2:[128-130)
1014 : : *
1015 : : * The upper 32bit indexes the following regions.
1016 : : *
1017 : : * 0:[0-0), 1:[16-32), 2:[48-128), 3:[130-MAX)
1018 : : *
1019 : : * As both region arrays are sorted, the function advances the two indices
1020 : : * in lockstep and returns each intersection.
1021 : : */
1022 : 451 : void __init_memblock __next_mem_range(u64 *idx, int nid,
1023 : : enum memblock_flags flags,
1024 : : struct memblock_type *type_a,
1025 : : struct memblock_type *type_b,
1026 : : phys_addr_t *out_start,
1027 : : phys_addr_t *out_end, int *out_nid)
1028 : : {
1029 : 451 : int idx_a = *idx & 0xffffffff;
1030 : 451 : int idx_b = *idx >> 32;
1031 : :
1032 [ - + - - : 451 : if (WARN_ONCE(nid == MAX_NUMNODES,
- + ]
1033 : : "Usage of MAX_NUMNODES is deprecated. Use NUMA_NO_NODE instead\n"))
1034 : 0 : nid = NUMA_NO_NODE;
1035 : :
1036 [ + + ]: 495 : for (; idx_a < type_a->cnt; idx_a++) {
1037 : 451 : struct memblock_region *m = &type_a->regions[idx_a];
1038 : :
1039 : 451 : phys_addr_t m_start = m->base;
1040 : 451 : phys_addr_t m_end = m->base + m->size;
1041 [ + - ]: 451 : int m_nid = memblock_get_region_node(m);
1042 : :
1043 [ + - ]: 451 : if (should_skip_region(m, nid, flags))
1044 : 0 : continue;
1045 : :
1046 [ + + ]: 451 : if (!type_b) {
1047 [ + - ]: 22 : if (out_start)
1048 : 22 : *out_start = m_start;
1049 [ + - ]: 22 : if (out_end)
1050 : 22 : *out_end = m_end;
1051 [ - + ]: 22 : if (out_nid)
1052 : 0 : *out_nid = m_nid;
1053 : 22 : idx_a++;
1054 : 22 : *idx = (u32)idx_a | (u64)idx_b << 32;
1055 : 22 : return;
1056 : : }
1057 : :
1058 : : /* scan areas before each reservation */
1059 [ + - ]: 473 : for (; idx_b < type_b->cnt + 1; idx_b++) {
1060 : 473 : struct memblock_region *r;
1061 : 473 : phys_addr_t r_start;
1062 : 473 : phys_addr_t r_end;
1063 : :
1064 : 473 : r = &type_b->regions[idx_b];
1065 [ + + ]: 473 : r_start = idx_b ? r[-1].base + r[-1].size : 0;
1066 : 473 : r_end = idx_b < type_b->cnt ?
1067 [ + + ]: 473 : r->base : PHYS_ADDR_MAX;
1068 : :
1069 : : /*
1070 : : * if idx_b advanced past idx_a,
1071 : : * break out to advance idx_a
1072 : : */
1073 [ + + ]: 473 : if (r_start >= m_end)
1074 : : break;
1075 : : /* if the two regions intersect, we're done */
1076 [ + + ]: 429 : if (m_start < r_end) {
1077 [ + - ]: 385 : if (out_start)
1078 : 385 : *out_start =
1079 : 385 : max(m_start, r_start);
1080 [ + - ]: 385 : if (out_end)
1081 : 385 : *out_end = min(m_end, r_end);
1082 [ - + ]: 385 : if (out_nid)
1083 : 0 : *out_nid = m_nid;
1084 : : /*
1085 : : * The region which ends first is
1086 : : * advanced for the next iteration.
1087 : : */
1088 [ + + ]: 385 : if (m_end <= r_end)
1089 : 22 : idx_a++;
1090 : : else
1091 : 363 : idx_b++;
1092 : 385 : *idx = (u32)idx_a | (u64)idx_b << 32;
1093 : 385 : return;
1094 : : }
1095 : : }
1096 : : }
1097 : :
1098 : : /* signal end of iteration */
1099 : 44 : *idx = ULLONG_MAX;
1100 : : }
1101 : :
1102 : : /**
1103 : : * __next_mem_range_rev - generic next function for for_each_*_range_rev()
1104 : : *
1105 : : * @idx: pointer to u64 loop variable
1106 : : * @nid: node selector, %NUMA_NO_NODE for all nodes
1107 : : * @flags: pick from blocks based on memory attributes
1108 : : * @type_a: pointer to memblock_type from where the range is taken
1109 : : * @type_b: pointer to memblock_type which excludes memory from being taken
1110 : : * @out_start: ptr to phys_addr_t for start address of the range, can be %NULL
1111 : : * @out_end: ptr to phys_addr_t for end address of the range, can be %NULL
1112 : : * @out_nid: ptr to int for nid of the range, can be %NULL
1113 : : *
1114 : : * Finds the next range from type_a which is not marked as unsuitable
1115 : : * in type_b.
1116 : : *
1117 : : * Reverse of __next_mem_range().
1118 : : */
1119 : 31383 : void __init_memblock __next_mem_range_rev(u64 *idx, int nid,
1120 : : enum memblock_flags flags,
1121 : : struct memblock_type *type_a,
1122 : : struct memblock_type *type_b,
1123 : : phys_addr_t *out_start,
1124 : : phys_addr_t *out_end, int *out_nid)
1125 : : {
1126 : 31383 : int idx_a = *idx & 0xffffffff;
1127 : 31383 : int idx_b = *idx >> 32;
1128 : :
1129 [ - + - - : 31383 : if (WARN_ONCE(nid == MAX_NUMNODES, "Usage of MAX_NUMNODES is deprecated. Use NUMA_NO_NODE instead\n"))
- + ]
1130 : 0 : nid = NUMA_NO_NODE;
1131 : :
1132 [ + + ]: 31383 : if (*idx == (u64)ULLONG_MAX) {
1133 : 12936 : idx_a = type_a->cnt - 1;
1134 [ + - ]: 12936 : if (type_b != NULL)
1135 : 12936 : idx_b = type_b->cnt;
1136 : : else
1137 : : idx_b = 0;
1138 : : }
1139 : :
1140 [ + - ]: 31383 : for (; idx_a >= 0; idx_a--) {
1141 : 31383 : struct memblock_region *m = &type_a->regions[idx_a];
1142 : :
1143 : 31383 : phys_addr_t m_start = m->base;
1144 : 31383 : phys_addr_t m_end = m->base + m->size;
1145 [ + - ]: 31383 : int m_nid = memblock_get_region_node(m);
1146 : :
1147 [ + - ]: 31383 : if (should_skip_region(m, nid, flags))
1148 : 0 : continue;
1149 : :
1150 [ - + ]: 31383 : if (!type_b) {
1151 [ # # ]: 0 : if (out_start)
1152 : 0 : *out_start = m_start;
1153 [ # # ]: 0 : if (out_end)
1154 : 0 : *out_end = m_end;
1155 [ # # ]: 0 : if (out_nid)
1156 : 0 : *out_nid = m_nid;
1157 : 0 : idx_a--;
1158 : 0 : *idx = (u32)idx_a | (u64)idx_b << 32;
1159 : 0 : return;
1160 : : }
1161 : :
1162 : : /* scan areas before each reservation */
1163 [ + - ]: 44297 : for (; idx_b >= 0; idx_b--) {
1164 : 44297 : struct memblock_region *r;
1165 : 44297 : phys_addr_t r_start;
1166 : 44297 : phys_addr_t r_end;
1167 : :
1168 : 44297 : r = &type_b->regions[idx_b];
1169 [ + - ]: 44297 : r_start = idx_b ? r[-1].base + r[-1].size : 0;
1170 : 44297 : r_end = idx_b < type_b->cnt ?
1171 [ + + ]: 44297 : r->base : PHYS_ADDR_MAX;
1172 : : /*
1173 : : * if idx_b advanced past idx_a,
1174 : : * break out to advance idx_a
1175 : : */
1176 : :
1177 [ + - ]: 44297 : if (r_end <= m_start)
1178 : : break;
1179 : : /* if the two regions intersect, we're done */
1180 [ + + ]: 44297 : if (m_end > r_start) {
1181 [ + - ]: 31383 : if (out_start)
1182 : 31383 : *out_start = max(m_start, r_start);
1183 [ + - ]: 31383 : if (out_end)
1184 : 31383 : *out_end = min(m_end, r_end);
1185 [ - + ]: 31383 : if (out_nid)
1186 : 0 : *out_nid = m_nid;
1187 [ + + ]: 31383 : if (m_start >= r_start)
1188 : 11 : idx_a--;
1189 : : else
1190 : 31372 : idx_b--;
1191 : 31383 : *idx = (u32)idx_a | (u64)idx_b << 32;
1192 : 31383 : return;
1193 : : }
1194 : : }
1195 : : }
1196 : : /* signal end of iteration */
1197 : 0 : *idx = ULLONG_MAX;
1198 : : }
1199 : :
1200 : : #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
1201 : : /*
1202 : : * Common iterator interface used to define for_each_mem_pfn_range().
1203 : : */
1204 : 561 : void __init_memblock __next_mem_pfn_range(int *idx, int nid,
1205 : : unsigned long *out_start_pfn,
1206 : : unsigned long *out_end_pfn, int *out_nid)
1207 : : {
1208 : 561 : struct memblock_type *type = &memblock.memory;
1209 : 561 : struct memblock_region *r;
1210 : :
1211 [ + + ]: 561 : while (++*idx < type->cnt) {
1212 : 374 : r = &type->regions[*idx];
1213 : :
1214 [ - + ]: 374 : if (PFN_UP(r->base) >= PFN_DOWN(r->base + r->size))
1215 : 0 : continue;
1216 [ + + - + ]: 374 : if (nid == MAX_NUMNODES || nid == r->nid)
1217 : : break;
1218 : : }
1219 [ + + ]: 561 : if (*idx >= type->cnt) {
1220 : 187 : *idx = -1;
1221 : 187 : return;
1222 : : }
1223 : :
1224 [ + - ]: 374 : if (out_start_pfn)
1225 : 374 : *out_start_pfn = PFN_UP(r->base);
1226 [ + + ]: 374 : if (out_end_pfn)
1227 : 330 : *out_end_pfn = PFN_DOWN(r->base + r->size);
1228 [ + + ]: 374 : if (out_nid)
1229 : 66 : *out_nid = r->nid;
1230 : : }
1231 : :
1232 : : /**
1233 : : * memblock_set_node - set node ID on memblock regions
1234 : : * @base: base of area to set node ID for
1235 : : * @size: size of area to set node ID for
1236 : : * @type: memblock type to set node ID for
1237 : : * @nid: node ID to set
1238 : : *
1239 : : * Set the nid of memblock @type regions in [@base, @base + @size) to @nid.
1240 : : * Regions which cross the area boundaries are split as necessary.
1241 : : *
1242 : : * Return:
1243 : : * 0 on success, -errno on failure.
1244 : : */
1245 : 88 : int __init_memblock memblock_set_node(phys_addr_t base, phys_addr_t size,
1246 : : struct memblock_type *type, int nid)
1247 : : {
1248 : 88 : int start_rgn, end_rgn;
1249 : 88 : int i, ret;
1250 : :
1251 : 88 : ret = memblock_isolate_range(type, base, size, &start_rgn, &end_rgn);
1252 [ + - ]: 88 : if (ret)
1253 : : return ret;
1254 : :
1255 [ + + ]: 308 : for (i = start_rgn; i < end_rgn; i++)
1256 : 220 : memblock_set_region_node(&type->regions[i], nid);
1257 : :
1258 : 88 : memblock_merge_regions(type);
1259 : 88 : return 0;
1260 : : }
1261 : : #endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
1262 : : #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
1263 : : /**
1264 : : * __next_mem_pfn_range_in_zone - iterator for for_each_*_range_in_zone()
1265 : : *
1266 : : * @idx: pointer to u64 loop variable
1267 : : * @zone: zone in which all of the memory blocks reside
1268 : : * @out_spfn: ptr to ulong for start pfn of the range, can be %NULL
1269 : : * @out_epfn: ptr to ulong for end pfn of the range, can be %NULL
1270 : : *
1271 : : * This function is meant to be a zone/pfn specific wrapper for the
1272 : : * for_each_mem_range type iterators. Specifically they are used in the
1273 : : * deferred memory init routines and as such we were duplicating much of
1274 : : * this logic throughout the code. So instead of having it in multiple
1275 : : * locations it seemed like it would make more sense to centralize this to
1276 : : * one new iterator that does everything they need.
1277 : : */
1278 : : void __init_memblock
1279 : : __next_mem_pfn_range_in_zone(u64 *idx, struct zone *zone,
1280 : : unsigned long *out_spfn, unsigned long *out_epfn)
1281 : : {
1282 : : int zone_nid = zone_to_nid(zone);
1283 : : phys_addr_t spa, epa;
1284 : : int nid;
1285 : :
1286 : : __next_mem_range(idx, zone_nid, MEMBLOCK_NONE,
1287 : : &memblock.memory, &memblock.reserved,
1288 : : &spa, &epa, &nid);
1289 : :
1290 : : while (*idx != U64_MAX) {
1291 : : unsigned long epfn = PFN_DOWN(epa);
1292 : : unsigned long spfn = PFN_UP(spa);
1293 : :
1294 : : /*
1295 : : * Verify the end is at least past the start of the zone and
1296 : : * that we have at least one PFN to initialize.
1297 : : */
1298 : : if (zone->zone_start_pfn < epfn && spfn < epfn) {
1299 : : /* if we went too far just stop searching */
1300 : : if (zone_end_pfn(zone) <= spfn) {
1301 : : *idx = U64_MAX;
1302 : : break;
1303 : : }
1304 : :
1305 : : if (out_spfn)
1306 : : *out_spfn = max(zone->zone_start_pfn, spfn);
1307 : : if (out_epfn)
1308 : : *out_epfn = min(zone_end_pfn(zone), epfn);
1309 : :
1310 : : return;
1311 : : }
1312 : :
1313 : : __next_mem_range(idx, zone_nid, MEMBLOCK_NONE,
1314 : : &memblock.memory, &memblock.reserved,
1315 : : &spa, &epa, &nid);
1316 : : }
1317 : :
1318 : : /* signal end of iteration */
1319 : : if (out_spfn)
1320 : : *out_spfn = ULONG_MAX;
1321 : : if (out_epfn)
1322 : : *out_epfn = 0;
1323 : : }
1324 : :
1325 : : #endif /* CONFIG_DEFERRED_STRUCT_PAGE_INIT */
1326 : :
1327 : : /**
1328 : : * memblock_alloc_range_nid - allocate boot memory block
1329 : : * @size: size of memory block to be allocated in bytes
1330 : : * @align: alignment of the region and block's size
1331 : : * @start: the lower bound of the memory region to allocate (phys address)
1332 : : * @end: the upper bound of the memory region to allocate (phys address)
1333 : : * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
1334 : : * @exact_nid: control the allocation fall back to other nodes
1335 : : *
1336 : : * The allocation is performed from memory region limited by
1337 : : * memblock.current_limit if @end == %MEMBLOCK_ALLOC_ACCESSIBLE.
1338 : : *
1339 : : * If the specified node can not hold the requested memory and @exact_nid
1340 : : * is false, the allocation falls back to any node in the system.
1341 : : *
1342 : : * For systems with memory mirroring, the allocation is attempted first
1343 : : * from the regions with mirroring enabled and then retried from any
1344 : : * memory region.
1345 : : *
1346 : : * In addition, function sets the min_count to 0 using kmemleak_alloc_phys for
1347 : : * allocated boot memory block, so that it is never reported as leaks.
1348 : : *
1349 : : * Return:
1350 : : * Physical address of allocated memory block on success, %0 on failure.
1351 : : */
1352 : 12914 : static phys_addr_t __init memblock_alloc_range_nid(phys_addr_t size,
1353 : : phys_addr_t align, phys_addr_t start,
1354 : : phys_addr_t end, int nid,
1355 : : bool exact_nid)
1356 : : {
1357 : 12914 : enum memblock_flags flags = choose_memblock_flags();
1358 : 12914 : phys_addr_t found;
1359 : :
1360 [ - + - - : 12914 : if (WARN_ONCE(nid == MAX_NUMNODES, "Usage of MAX_NUMNODES is deprecated. Use NUMA_NO_NODE instead\n"))
- + ]
1361 : 0 : nid = NUMA_NO_NODE;
1362 : :
1363 [ + - ]: 12914 : if (!align) {
1364 : : /* Can't use WARNs this early in boot on powerpc */
1365 : 0 : dump_stack();
1366 : 0 : align = SMP_CACHE_BYTES;
1367 : : }
1368 : :
1369 : 12914 : again:
1370 : 12914 : found = memblock_find_in_range_node(size, align, start, end, nid,
1371 : : flags);
1372 [ + - + - ]: 12914 : if (found && !memblock_reserve(found, size))
1373 : 12914 : goto done;
1374 : :
1375 [ # # ]: 0 : if (nid != NUMA_NO_NODE && !exact_nid) {
1376 : 0 : found = memblock_find_in_range_node(size, align, start,
1377 : : end, NUMA_NO_NODE,
1378 : : flags);
1379 [ # # # # ]: 0 : if (found && !memblock_reserve(found, size))
1380 : 0 : goto done;
1381 : : }
1382 : :
1383 [ # # ]: 0 : if (flags & MEMBLOCK_MIRROR) {
1384 : 0 : flags &= ~MEMBLOCK_MIRROR;
1385 : 0 : pr_warn("Could not allocate %pap bytes of mirrored memory\n",
1386 : : &size);
1387 : 0 : goto again;
1388 : : }
1389 : :
1390 : : return 0;
1391 : :
1392 : 12914 : done:
1393 : : /* Skip kmemleak for kasan_init() due to high volume. */
1394 : 12914 : if (end != MEMBLOCK_ALLOC_KASAN)
1395 : : /*
1396 : : * The min_count is set to 0 so that memblock allocated
1397 : : * blocks are never reported as leaks. This is because many
1398 : : * of these blocks are only referred via the physical
1399 : : * address which is not looked up by kmemleak.
1400 : : */
1401 : : kmemleak_alloc_phys(found, size, 0, 0);
1402 : :
1403 : : return found;
1404 : : }
1405 : :
1406 : : /**
1407 : : * memblock_phys_alloc_range - allocate a memory block inside specified range
1408 : : * @size: size of memory block to be allocated in bytes
1409 : : * @align: alignment of the region and block's size
1410 : : * @start: the lower bound of the memory region to allocate (physical address)
1411 : : * @end: the upper bound of the memory region to allocate (physical address)
1412 : : *
1413 : : * Allocate @size bytes in the between @start and @end.
1414 : : *
1415 : : * Return: physical address of the allocated memory block on success,
1416 : : * %0 on failure.
1417 : : */
1418 : 0 : phys_addr_t __init memblock_phys_alloc_range(phys_addr_t size,
1419 : : phys_addr_t align,
1420 : : phys_addr_t start,
1421 : : phys_addr_t end)
1422 : : {
1423 : 0 : return memblock_alloc_range_nid(size, align, start, end, NUMA_NO_NODE,
1424 : : false);
1425 : : }
1426 : :
1427 : : /**
1428 : : * memblock_phys_alloc_try_nid - allocate a memory block from specified MUMA node
1429 : : * @size: size of memory block to be allocated in bytes
1430 : : * @align: alignment of the region and block's size
1431 : : * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
1432 : : *
1433 : : * Allocates memory block from the specified NUMA node. If the node
1434 : : * has no available memory, attempts to allocated from any node in the
1435 : : * system.
1436 : : *
1437 : : * Return: physical address of the allocated memory block on success,
1438 : : * %0 on failure.
1439 : : */
1440 : 11 : phys_addr_t __init memblock_phys_alloc_try_nid(phys_addr_t size, phys_addr_t align, int nid)
1441 : : {
1442 : 11 : return memblock_alloc_range_nid(size, align, 0,
1443 : : MEMBLOCK_ALLOC_ACCESSIBLE, nid, false);
1444 : : }
1445 : :
1446 : : /**
1447 : : * memblock_alloc_internal - allocate boot memory block
1448 : : * @size: size of memory block to be allocated in bytes
1449 : : * @align: alignment of the region and block's size
1450 : : * @min_addr: the lower bound of the memory region to allocate (phys address)
1451 : : * @max_addr: the upper bound of the memory region to allocate (phys address)
1452 : : * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
1453 : : * @exact_nid: control the allocation fall back to other nodes
1454 : : *
1455 : : * Allocates memory block using memblock_alloc_range_nid() and
1456 : : * converts the returned physical address to virtual.
1457 : : *
1458 : : * The @min_addr limit is dropped if it can not be satisfied and the allocation
1459 : : * will fall back to memory below @min_addr. Other constraints, such
1460 : : * as node and mirrored memory will be handled again in
1461 : : * memblock_alloc_range_nid().
1462 : : *
1463 : : * Return:
1464 : : * Virtual address of allocated memory block on success, NULL on failure.
1465 : : */
1466 : 12903 : static void * __init memblock_alloc_internal(
1467 : : phys_addr_t size, phys_addr_t align,
1468 : : phys_addr_t min_addr, phys_addr_t max_addr,
1469 : : int nid, bool exact_nid)
1470 : : {
1471 : 12903 : phys_addr_t alloc;
1472 : :
1473 : : /*
1474 : : * Detect any accidental use of these APIs after slab is ready, as at
1475 : : * this moment memblock may be deinitialized already and its
1476 : : * internal data may be destroyed (after execution of memblock_free_all)
1477 : : */
1478 [ - + - + ]: 12903 : if (WARN_ON_ONCE(slab_is_available()))
1479 : 0 : return kzalloc_node(size, GFP_NOWAIT, nid);
1480 : :
1481 : 12903 : if (max_addr > memblock.current_limit)
1482 : : max_addr = memblock.current_limit;
1483 : :
1484 : 12903 : alloc = memblock_alloc_range_nid(size, align, min_addr, max_addr, nid,
1485 : : exact_nid);
1486 : :
1487 : : /* retry allocation without lower limit */
1488 [ - + ]: 12903 : if (!alloc && min_addr)
1489 : 0 : alloc = memblock_alloc_range_nid(size, align, 0, max_addr, nid,
1490 : : exact_nid);
1491 : :
1492 [ + - ]: 12903 : if (!alloc)
1493 : : return NULL;
1494 : :
1495 : 12903 : return phys_to_virt(alloc);
1496 : : }
1497 : :
1498 : : /**
1499 : : * memblock_alloc_exact_nid_raw - allocate boot memory block on the exact node
1500 : : * without zeroing memory
1501 : : * @size: size of memory block to be allocated in bytes
1502 : : * @align: alignment of the region and block's size
1503 : : * @min_addr: the lower bound of the memory region from where the allocation
1504 : : * is preferred (phys address)
1505 : : * @max_addr: the upper bound of the memory region from where the allocation
1506 : : * is preferred (phys address), or %MEMBLOCK_ALLOC_ACCESSIBLE to
1507 : : * allocate only from memory limited by memblock.current_limit value
1508 : : * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
1509 : : *
1510 : : * Public function, provides additional debug information (including caller
1511 : : * info), if enabled. Does not zero allocated memory.
1512 : : *
1513 : : * Return:
1514 : : * Virtual address of allocated memory block on success, NULL on failure.
1515 : : */
1516 : 11 : void * __init memblock_alloc_exact_nid_raw(
1517 : : phys_addr_t size, phys_addr_t align,
1518 : : phys_addr_t min_addr, phys_addr_t max_addr,
1519 : : int nid)
1520 : : {
1521 : 11 : void *ptr;
1522 : :
1523 [ - + ]: 11 : memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=%pa max_addr=%pa %pS\n",
1524 : : __func__, (u64)size, (u64)align, nid, &min_addr,
1525 : : &max_addr, (void *)_RET_IP_);
1526 : :
1527 : 11 : ptr = memblock_alloc_internal(size, align,
1528 : : min_addr, max_addr, nid, true);
1529 : 11 : if (ptr && size > 0)
1530 : : page_init_poison(ptr, size);
1531 : :
1532 : 11 : return ptr;
1533 : : }
1534 : :
1535 : : /**
1536 : : * memblock_alloc_try_nid_raw - allocate boot memory block without zeroing
1537 : : * memory and without panicking
1538 : : * @size: size of memory block to be allocated in bytes
1539 : : * @align: alignment of the region and block's size
1540 : : * @min_addr: the lower bound of the memory region from where the allocation
1541 : : * is preferred (phys address)
1542 : : * @max_addr: the upper bound of the memory region from where the allocation
1543 : : * is preferred (phys address), or %MEMBLOCK_ALLOC_ACCESSIBLE to
1544 : : * allocate only from memory limited by memblock.current_limit value
1545 : : * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
1546 : : *
1547 : : * Public function, provides additional debug information (including caller
1548 : : * info), if enabled. Does not zero allocated memory, does not panic if request
1549 : : * cannot be satisfied.
1550 : : *
1551 : : * Return:
1552 : : * Virtual address of allocated memory block on success, NULL on failure.
1553 : : */
1554 : 22 : void * __init memblock_alloc_try_nid_raw(
1555 : : phys_addr_t size, phys_addr_t align,
1556 : : phys_addr_t min_addr, phys_addr_t max_addr,
1557 : : int nid)
1558 : : {
1559 : 22 : void *ptr;
1560 : :
1561 [ - + ]: 22 : memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=%pa max_addr=%pa %pS\n",
1562 : : __func__, (u64)size, (u64)align, nid, &min_addr,
1563 : : &max_addr, (void *)_RET_IP_);
1564 : :
1565 : 22 : ptr = memblock_alloc_internal(size, align,
1566 : : min_addr, max_addr, nid, false);
1567 : 22 : if (ptr && size > 0)
1568 : : page_init_poison(ptr, size);
1569 : :
1570 : 22 : return ptr;
1571 : : }
1572 : :
1573 : : /**
1574 : : * memblock_alloc_try_nid - allocate boot memory block
1575 : : * @size: size of memory block to be allocated in bytes
1576 : : * @align: alignment of the region and block's size
1577 : : * @min_addr: the lower bound of the memory region from where the allocation
1578 : : * is preferred (phys address)
1579 : : * @max_addr: the upper bound of the memory region from where the allocation
1580 : : * is preferred (phys address), or %MEMBLOCK_ALLOC_ACCESSIBLE to
1581 : : * allocate only from memory limited by memblock.current_limit value
1582 : : * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
1583 : : *
1584 : : * Public function, provides additional debug information (including caller
1585 : : * info), if enabled. This function zeroes the allocated memory.
1586 : : *
1587 : : * Return:
1588 : : * Virtual address of allocated memory block on success, NULL on failure.
1589 : : */
1590 : 12870 : void * __init memblock_alloc_try_nid(
1591 : : phys_addr_t size, phys_addr_t align,
1592 : : phys_addr_t min_addr, phys_addr_t max_addr,
1593 : : int nid)
1594 : : {
1595 : 12870 : void *ptr;
1596 : :
1597 [ - + ]: 12870 : memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=%pa max_addr=%pa %pS\n",
1598 : : __func__, (u64)size, (u64)align, nid, &min_addr,
1599 : : &max_addr, (void *)_RET_IP_);
1600 : 12870 : ptr = memblock_alloc_internal(size, align,
1601 : : min_addr, max_addr, nid, false);
1602 [ + - ]: 12870 : if (ptr)
1603 : 12870 : memset(ptr, 0, size);
1604 : :
1605 : 12870 : return ptr;
1606 : : }
1607 : :
1608 : : /**
1609 : : * __memblock_free_late - free pages directly to buddy allocator
1610 : : * @base: phys starting address of the boot memory block
1611 : : * @size: size of the boot memory block in bytes
1612 : : *
1613 : : * This is only useful when the memblock allocator has already been torn
1614 : : * down, but we are still initializing the system. Pages are released directly
1615 : : * to the buddy allocator.
1616 : : */
1617 : 0 : void __init __memblock_free_late(phys_addr_t base, phys_addr_t size)
1618 : : {
1619 : 0 : phys_addr_t cursor, end;
1620 : :
1621 : 0 : end = base + size - 1;
1622 [ # # ]: 0 : memblock_dbg("%s: [%pa-%pa] %pS\n",
1623 : : __func__, &base, &end, (void *)_RET_IP_);
1624 : 0 : kmemleak_free_part_phys(base, size);
1625 : 0 : cursor = PFN_UP(base);
1626 : 0 : end = PFN_DOWN(base + size);
1627 : :
1628 [ # # ]: 0 : for (; cursor < end; cursor++) {
1629 : 0 : memblock_free_pages(pfn_to_page(cursor), cursor, 0);
1630 : 0 : totalram_pages_inc();
1631 : : }
1632 : 0 : }
1633 : :
1634 : : /*
1635 : : * Remaining API functions
1636 : : */
1637 : :
1638 : 11 : phys_addr_t __init_memblock memblock_phys_mem_size(void)
1639 : : {
1640 : 11 : return memblock.memory.total_size;
1641 : : }
1642 : :
1643 : 0 : phys_addr_t __init_memblock memblock_reserved_size(void)
1644 : : {
1645 : 0 : return memblock.reserved.total_size;
1646 : : }
1647 : :
1648 : 0 : phys_addr_t __init memblock_mem_size(unsigned long limit_pfn)
1649 : : {
1650 : 0 : unsigned long pages = 0;
1651 : 0 : struct memblock_region *r;
1652 : 0 : unsigned long start_pfn, end_pfn;
1653 : :
1654 [ # # ]: 0 : for_each_memblock(memory, r) {
1655 : 0 : start_pfn = memblock_region_memory_base_pfn(r);
1656 : 0 : end_pfn = memblock_region_memory_end_pfn(r);
1657 : 0 : start_pfn = min_t(unsigned long, start_pfn, limit_pfn);
1658 : 0 : end_pfn = min_t(unsigned long, end_pfn, limit_pfn);
1659 : 0 : pages += end_pfn - start_pfn;
1660 : : }
1661 : :
1662 : 0 : return PFN_PHYS(pages);
1663 : : }
1664 : :
1665 : : /* lowest address */
1666 : 0 : phys_addr_t __init_memblock memblock_start_of_DRAM(void)
1667 : : {
1668 : 0 : return memblock.memory.regions[0].base;
1669 : : }
1670 : :
1671 : 0 : phys_addr_t __init_memblock memblock_end_of_DRAM(void)
1672 : : {
1673 : 0 : int idx = memblock.memory.cnt - 1;
1674 : :
1675 : 0 : return (memblock.memory.regions[idx].base + memblock.memory.regions[idx].size);
1676 : : }
1677 : :
1678 : 0 : static phys_addr_t __init_memblock __find_max_addr(phys_addr_t limit)
1679 : : {
1680 : 0 : phys_addr_t max_addr = PHYS_ADDR_MAX;
1681 : 0 : struct memblock_region *r;
1682 : :
1683 : : /*
1684 : : * translate the memory @limit size into the max address within one of
1685 : : * the memory memblock regions, if the @limit exceeds the total size
1686 : : * of those regions, max_addr will keep original value PHYS_ADDR_MAX
1687 : : */
1688 [ # # ]: 0 : for_each_memblock(memory, r) {
1689 [ # # ]: 0 : if (limit <= r->size) {
1690 : 0 : max_addr = r->base + limit;
1691 : 0 : break;
1692 : : }
1693 : 0 : limit -= r->size;
1694 : : }
1695 : :
1696 : 0 : return max_addr;
1697 : : }
1698 : :
1699 : 0 : void __init memblock_enforce_memory_limit(phys_addr_t limit)
1700 : : {
1701 : 0 : phys_addr_t max_addr = PHYS_ADDR_MAX;
1702 : :
1703 [ # # ]: 0 : if (!limit)
1704 : : return;
1705 : :
1706 : 0 : max_addr = __find_max_addr(limit);
1707 : :
1708 : : /* @limit exceeds the total size of the memory, do nothing */
1709 [ # # ]: 0 : if (max_addr == PHYS_ADDR_MAX)
1710 : : return;
1711 : :
1712 : : /* truncate both memory and reserved regions */
1713 : 0 : memblock_remove_range(&memblock.memory, max_addr,
1714 : : PHYS_ADDR_MAX);
1715 : 0 : memblock_remove_range(&memblock.reserved, max_addr,
1716 : : PHYS_ADDR_MAX);
1717 : : }
1718 : :
1719 : 0 : void __init memblock_cap_memory_range(phys_addr_t base, phys_addr_t size)
1720 : : {
1721 : 0 : int start_rgn, end_rgn;
1722 : 0 : int i, ret;
1723 : :
1724 [ # # ]: 0 : if (!size)
1725 : 0 : return;
1726 : :
1727 : 0 : ret = memblock_isolate_range(&memblock.memory, base, size,
1728 : : &start_rgn, &end_rgn);
1729 [ # # ]: 0 : if (ret)
1730 : : return;
1731 : :
1732 : : /* remove all the MAP regions */
1733 [ # # ]: 0 : for (i = memblock.memory.cnt - 1; i >= end_rgn; i--)
1734 [ # # ]: 0 : if (!memblock_is_nomap(&memblock.memory.regions[i]))
1735 : 0 : memblock_remove_region(&memblock.memory, i);
1736 : :
1737 [ # # ]: 0 : for (i = start_rgn - 1; i >= 0; i--)
1738 [ # # ]: 0 : if (!memblock_is_nomap(&memblock.memory.regions[i]))
1739 : 0 : memblock_remove_region(&memblock.memory, i);
1740 : :
1741 : : /* truncate the reserved regions */
1742 : 0 : memblock_remove_range(&memblock.reserved, 0, base);
1743 : 0 : memblock_remove_range(&memblock.reserved,
1744 : : base + size, PHYS_ADDR_MAX);
1745 : : }
1746 : :
1747 : 0 : void __init memblock_mem_limit_remove_map(phys_addr_t limit)
1748 : : {
1749 : 0 : phys_addr_t max_addr;
1750 : :
1751 [ # # ]: 0 : if (!limit)
1752 : : return;
1753 : :
1754 : 0 : max_addr = __find_max_addr(limit);
1755 : :
1756 : : /* @limit exceeds the total size of the memory, do nothing */
1757 [ # # ]: 0 : if (max_addr == PHYS_ADDR_MAX)
1758 : : return;
1759 : :
1760 : 0 : memblock_cap_memory_range(0, max_addr);
1761 : : }
1762 : :
1763 : : static int __init_memblock memblock_search(struct memblock_type *type, phys_addr_t addr)
1764 : : {
1765 : : unsigned int left = 0, right = type->cnt;
1766 : :
1767 : : do {
1768 : : unsigned int mid = (right + left) / 2;
1769 : :
1770 : : if (addr < type->regions[mid].base)
1771 : : right = mid;
1772 : : else if (addr >= (type->regions[mid].base +
1773 : : type->regions[mid].size))
1774 : : left = mid + 1;
1775 : : else
1776 : : return mid;
1777 : : } while (left < right);
1778 : : return -1;
1779 : : }
1780 : :
1781 : 0 : bool __init_memblock memblock_is_reserved(phys_addr_t addr)
1782 : : {
1783 : 0 : return memblock_search(&memblock.reserved, addr) != -1;
1784 : : }
1785 : :
1786 : 0 : bool __init_memblock memblock_is_memory(phys_addr_t addr)
1787 : : {
1788 : 0 : return memblock_search(&memblock.memory, addr) != -1;
1789 : : }
1790 : :
1791 : 0 : bool __init_memblock memblock_is_map_memory(phys_addr_t addr)
1792 : : {
1793 : 0 : int i = memblock_search(&memblock.memory, addr);
1794 : :
1795 [ # # ]: 0 : if (i == -1)
1796 : : return false;
1797 : 0 : return !memblock_is_nomap(&memblock.memory.regions[i]);
1798 : : }
1799 : :
1800 : : #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
1801 : 1122 : int __init_memblock memblock_search_pfn_nid(unsigned long pfn,
1802 : : unsigned long *start_pfn, unsigned long *end_pfn)
1803 : : {
1804 : 1122 : struct memblock_type *type = &memblock.memory;
1805 : 1122 : int mid = memblock_search(type, PFN_PHYS(pfn));
1806 : :
1807 [ + + ]: 1122 : if (mid == -1)
1808 : : return -1;
1809 : :
1810 : 33 : *start_pfn = PFN_DOWN(type->regions[mid].base);
1811 : 33 : *end_pfn = PFN_DOWN(type->regions[mid].base + type->regions[mid].size);
1812 : :
1813 : 33 : return type->regions[mid].nid;
1814 : : }
1815 : : #endif
1816 : :
1817 : : /**
1818 : : * memblock_is_region_memory - check if a region is a subset of memory
1819 : : * @base: base of region to check
1820 : : * @size: size of region to check
1821 : : *
1822 : : * Check if the region [@base, @base + @size) is a subset of a memory block.
1823 : : *
1824 : : * Return:
1825 : : * 0 if false, non-zero if true
1826 : : */
1827 : 33 : bool __init_memblock memblock_is_region_memory(phys_addr_t base, phys_addr_t size)
1828 : : {
1829 : 33 : int idx = memblock_search(&memblock.memory, base);
1830 : 33 : phys_addr_t end = base + memblock_cap_size(base, &size);
1831 : :
1832 [ + + ]: 33 : if (idx == -1)
1833 : : return false;
1834 : 11 : return (memblock.memory.regions[idx].base +
1835 : 11 : memblock.memory.regions[idx].size) >= end;
1836 : : }
1837 : :
1838 : : /**
1839 : : * memblock_is_region_reserved - check if a region intersects reserved memory
1840 : : * @base: base of region to check
1841 : : * @size: size of region to check
1842 : : *
1843 : : * Check if the region [@base, @base + @size) intersects a reserved
1844 : : * memory block.
1845 : : *
1846 : : * Return:
1847 : : * True if they intersect, false if not.
1848 : : */
1849 : 0 : bool __init_memblock memblock_is_region_reserved(phys_addr_t base, phys_addr_t size)
1850 : : {
1851 : 0 : memblock_cap_size(base, &size);
1852 : 0 : return memblock_overlaps_region(&memblock.reserved, base, size);
1853 : : }
1854 : :
1855 : 11 : void __init_memblock memblock_trim_memory(phys_addr_t align)
1856 : : {
1857 : 11 : phys_addr_t start, end, orig_start, orig_end;
1858 : 11 : struct memblock_region *r;
1859 : :
1860 [ + + ]: 33 : for_each_memblock(memory, r) {
1861 : 22 : orig_start = r->base;
1862 : 22 : orig_end = r->base + r->size;
1863 : 22 : start = round_up(orig_start, align);
1864 : 22 : end = round_down(orig_end, align);
1865 : :
1866 [ + + ]: 22 : if (start == orig_start && end == orig_end)
1867 : 11 : continue;
1868 : :
1869 [ + - ]: 11 : if (start < end) {
1870 : 11 : r->base = start;
1871 : 11 : r->size = end - start;
1872 : : } else {
1873 : 0 : memblock_remove_region(&memblock.memory,
1874 : 0 : r - memblock.memory.regions);
1875 : 0 : r--;
1876 : : }
1877 : : }
1878 : 11 : }
1879 : :
1880 : 22 : void __init_memblock memblock_set_current_limit(phys_addr_t limit)
1881 : : {
1882 : 22 : memblock.current_limit = limit;
1883 : 22 : }
1884 : :
1885 : 0 : phys_addr_t __init_memblock memblock_get_current_limit(void)
1886 : : {
1887 : 0 : return memblock.current_limit;
1888 : : }
1889 : :
1890 : 0 : static void __init_memblock memblock_dump(struct memblock_type *type)
1891 : : {
1892 : 0 : phys_addr_t base, end, size;
1893 : 0 : enum memblock_flags flags;
1894 : 0 : int idx;
1895 : 0 : struct memblock_region *rgn;
1896 : :
1897 : 0 : pr_info(" %s.cnt = 0x%lx\n", type->name, type->cnt);
1898 : :
1899 [ # # ]: 0 : for_each_memblock_type(idx, type, rgn) {
1900 : 0 : char nid_buf[32] = "";
1901 : :
1902 : 0 : base = rgn->base;
1903 : 0 : size = rgn->size;
1904 : 0 : end = base + size - 1;
1905 : 0 : flags = rgn->flags;
1906 : : #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
1907 [ # # ]: 0 : if (memblock_get_region_node(rgn) != MAX_NUMNODES)
1908 : 0 : snprintf(nid_buf, sizeof(nid_buf), " on node %d",
1909 : : memblock_get_region_node(rgn));
1910 : : #endif
1911 : 0 : pr_info(" %s[%#x]\t[%pa-%pa], %pa bytes%s flags: %#x\n",
1912 : : type->name, idx, &base, &end, &size, nid_buf, flags);
1913 : : }
1914 : 0 : }
1915 : :
1916 : 0 : void __init_memblock __memblock_dump_all(void)
1917 : : {
1918 : 0 : pr_info("MEMBLOCK configuration:\n");
1919 : 0 : pr_info(" memory size = %pa reserved size = %pa\n",
1920 : : &memblock.memory.total_size,
1921 : : &memblock.reserved.total_size);
1922 : :
1923 : 0 : memblock_dump(&memblock.memory);
1924 : 0 : memblock_dump(&memblock.reserved);
1925 : : #ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
1926 : : memblock_dump(&memblock.physmem);
1927 : : #endif
1928 : 0 : }
1929 : :
1930 : 11 : void __init memblock_allow_resize(void)
1931 : : {
1932 : 11 : memblock_can_resize = 1;
1933 : 11 : }
1934 : :
1935 : 0 : static int __init early_memblock(char *p)
1936 : : {
1937 [ # # # # ]: 0 : if (p && strstr(p, "debug"))
1938 : 0 : memblock_debug = 1;
1939 : 0 : return 0;
1940 : : }
1941 : : early_param("memblock", early_memblock);
1942 : :
1943 : 55 : static void __init __free_pages_memory(unsigned long start, unsigned long end)
1944 : : {
1945 : 55 : int order;
1946 : :
1947 [ + + ]: 2332 : while (start < end) {
1948 : 2277 : order = min(MAX_ORDER - 1UL, __ffs(start));
1949 : :
1950 [ + + ]: 2453 : while (start + (1UL << order) > end)
1951 : 176 : order--;
1952 : :
1953 : 2277 : memblock_free_pages(pfn_to_page(start), start, order);
1954 : :
1955 : 2277 : start += (1UL << order);
1956 : : }
1957 : 55 : }
1958 : :
1959 : 319 : static unsigned long __init __free_memory_core(phys_addr_t start,
1960 : : phys_addr_t end)
1961 : : {
1962 : 319 : unsigned long start_pfn = PFN_UP(start);
1963 : 319 : unsigned long end_pfn = min_t(unsigned long,
1964 : : PFN_DOWN(end), max_low_pfn);
1965 : :
1966 [ + + ]: 319 : if (start_pfn >= end_pfn)
1967 : : return 0;
1968 : :
1969 : 55 : __free_pages_memory(start_pfn, end_pfn);
1970 : :
1971 : 55 : return end_pfn - start_pfn;
1972 : : }
1973 : :
1974 : 11 : static unsigned long __init free_low_memory_core_early(void)
1975 : : {
1976 : 11 : unsigned long count = 0;
1977 : 11 : phys_addr_t start, end;
1978 : 11 : u64 i;
1979 : :
1980 : 11 : memblock_clear_hotplug(0, -1);
1981 : :
1982 [ + + ]: 341 : for_each_reserved_mem_region(i, &start, &end)
1983 : 330 : reserve_bootmem_region(start, end);
1984 : :
1985 : : /*
1986 : : * We need to use NUMA_NO_NODE instead of NODE_DATA(0)->node_id
1987 : : * because in some case like Node0 doesn't have RAM installed
1988 : : * low ram will be on Node1
1989 : : */
1990 [ + + ]: 330 : for_each_free_mem_range(i, NUMA_NO_NODE, MEMBLOCK_NONE, &start, &end,
1991 : : NULL)
1992 : 319 : count += __free_memory_core(start, end);
1993 : :
1994 : 11 : return count;
1995 : : }
1996 : :
1997 : : static int reset_managed_pages_done __initdata;
1998 : :
1999 : 11 : void reset_node_managed_pages(pg_data_t *pgdat)
2000 : : {
2001 : 11 : struct zone *z;
2002 : :
2003 [ + + - - ]: 55 : for (z = pgdat->node_zones; z < pgdat->node_zones + MAX_NR_ZONES; z++)
2004 : 44 : atomic_long_set(&z->managed_pages, 0);
2005 : 0 : }
2006 : :
2007 : 11 : void __init reset_all_zones_managed_pages(void)
2008 : : {
2009 : 11 : struct pglist_data *pgdat;
2010 : :
2011 [ + - ]: 11 : if (reset_managed_pages_done)
2012 : : return;
2013 : :
2014 [ + + ]: 22 : for_each_online_pgdat(pgdat)
2015 : 11 : reset_node_managed_pages(pgdat);
2016 : :
2017 : 11 : reset_managed_pages_done = 1;
2018 : : }
2019 : :
2020 : : /**
2021 : : * memblock_free_all - release free pages to the buddy allocator
2022 : : *
2023 : : * Return: the number of pages actually released.
2024 : : */
2025 : 11 : unsigned long __init memblock_free_all(void)
2026 : : {
2027 : 11 : unsigned long pages;
2028 : :
2029 : 11 : reset_all_zones_managed_pages();
2030 : :
2031 : 11 : pages = free_low_memory_core_early();
2032 : 11 : totalram_pages_add(pages);
2033 : :
2034 : 11 : return pages;
2035 : : }
2036 : :
2037 : : #if defined(CONFIG_DEBUG_FS) && defined(CONFIG_ARCH_KEEP_MEMBLOCK)
2038 : :
2039 : : static int memblock_debug_show(struct seq_file *m, void *private)
2040 : : {
2041 : : struct memblock_type *type = m->private;
2042 : : struct memblock_region *reg;
2043 : : int i;
2044 : : phys_addr_t end;
2045 : :
2046 : : for (i = 0; i < type->cnt; i++) {
2047 : : reg = &type->regions[i];
2048 : : end = reg->base + reg->size - 1;
2049 : :
2050 : : seq_printf(m, "%4d: ", i);
2051 : : seq_printf(m, "%pa..%pa\n", ®->base, &end);
2052 : : }
2053 : : return 0;
2054 : : }
2055 : : DEFINE_SHOW_ATTRIBUTE(memblock_debug);
2056 : :
2057 : : static int __init memblock_init_debugfs(void)
2058 : : {
2059 : : struct dentry *root = debugfs_create_dir("memblock", NULL);
2060 : :
2061 : : debugfs_create_file("memory", 0444, root,
2062 : : &memblock.memory, &memblock_debug_fops);
2063 : : debugfs_create_file("reserved", 0444, root,
2064 : : &memblock.reserved, &memblock_debug_fops);
2065 : : #ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
2066 : : debugfs_create_file("physmem", 0444, root,
2067 : : &memblock.physmem, &memblock_debug_fops);
2068 : : #endif
2069 : :
2070 : : return 0;
2071 : : }
2072 : : __initcall(memblock_init_debugfs);
2073 : :
2074 : : #endif /* CONFIG_DEBUG_FS */
|
