Lines Matching +full:reserved +full:- +full:memory
1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Procedures for maintaining information about logical memory blocks.
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
39 * Memblock views the system memory as collections of contiguous
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
46 * * ``reserved`` - describes the regions that were allocated
47 * * ``physmem`` - describes the actual physical memory available during
48 * boot regardless of the possible restrictions and memory hot(un)plug;
53 * systems. Every memory type is described by the struct memblock_type
54 * which contains an array of memory regions along with
55 * the allocator metadata. The "memory" and "reserved" types are nicely
58 * %INIT_MEMBLOCK_REGIONS for "memory" and %INIT_MEMBLOCK_RESERVED_REGIONS
59 * for "reserved". The region array for "physmem" is initially sized to
63 * with care so that memory allocated for the region array will not
64 * overlap with areas that should be reserved, for example initrd.
67 * memory layout is by using memblock_add() or memblock_add_node()
74 * Once memblock is setup the memory can be allocated using one of the
77 * * memblock_phys_alloc*() - these functions return the **physical**
78 * address of the allocated memory
79 * * memblock_alloc*() - these functions return the **virtual** address
80 * of the allocated memory.
83 * memory ranges and the fallback methods. Consult the documentation
88 * function frees all the memory to the buddy page allocator.
132 .memory.regions = memblock_memory_init_regions,
133 .memory.cnt = 1, /* empty dummy entry */
134 .memory.max = INIT_MEMBLOCK_REGIONS,
135 .memory.name = "memory",
137 .reserved.regions = memblock_reserved_init_regions,
138 .reserved.cnt = 1, /* empty dummy entry */
139 .reserved.max = INIT_MEMBLOCK_RESERVED_REGIONS,
140 .reserved.name = "reserved",
156 * keep a pointer to &memblock.memory in the text section to use it in
161 static __refdata struct memblock_type *memblock_memory = &memblock.memory;
164 for (i = 0, rgn = &memblock_type->regions[0]; \
165 i < memblock_type->cnt; \
166 i++, rgn = &memblock_type->regions[i])
189 return *size = min(*size, PHYS_ADDR_MAX - base); in memblock_cap_size()
208 for (i = 0; i < type->cnt; i++) in memblock_overlaps_region()
209 if (memblock_addrs_overlap(base, size, type->regions[i].base, in memblock_overlaps_region()
210 type->regions[i].size)) in memblock_overlaps_region()
212 return i < type->cnt; in memblock_overlaps_region()
216 * __memblock_find_range_bottom_up - find free area utility in bottom-up
223 * @flags: pick from blocks based on memory attributes
225 * Utility called from memblock_find_in_range_node(), find free area bottom-up.
243 if (cand < this_end && this_end - cand >= size) in __memblock_find_range_bottom_up()
251 * __memblock_find_range_top_down - find free area utility, in top-down
258 * @flags: pick from blocks based on memory attributes
260 * Utility called from memblock_find_in_range_node(), find free area top-down.
281 cand = round_down(this_end - size, align); in __memblock_find_range_top_down()
290 * memblock_find_in_range_node - find free area in given range and node
297 * @flags: pick from blocks based on memory attributes
327 * memblock_find_in_range - find free area in given range
351 pr_warn("Could not allocate %pap bytes of mirrored memory\n", in memblock_find_in_range()
362 type->total_size -= type->regions[r].size; in memblock_remove_region()
363 memmove(&type->regions[r], &type->regions[r + 1], in memblock_remove_region()
364 (type->cnt - (r + 1)) * sizeof(type->regions[r])); in memblock_remove_region()
365 type->cnt--; in memblock_remove_region()
368 if (type->cnt == 0) { in memblock_remove_region()
369 WARN_ON(type->total_size != 0); in memblock_remove_region()
370 type->cnt = 1; in memblock_remove_region()
371 type->regions[0].base = 0; in memblock_remove_region()
372 type->regions[0].size = 0; in memblock_remove_region()
373 type->regions[0].flags = 0; in memblock_remove_region()
374 memblock_set_region_node(&type->regions[0], MAX_NUMNODES); in memblock_remove_region()
380 * memblock_discard - discard memory and reserved arrays if they were allocated
386 if (memblock.reserved.regions != memblock_reserved_init_regions) { in memblock_discard()
387 addr = __pa(memblock.reserved.regions); in memblock_discard()
389 memblock.reserved.max); in memblock_discard()
391 kfree(memblock.reserved.regions); in memblock_discard()
396 if (memblock.memory.regions != memblock_memory_init_regions) { in memblock_discard()
397 addr = __pa(memblock.memory.regions); in memblock_discard()
399 memblock.memory.max); in memblock_discard()
401 kfree(memblock.memory.regions); in memblock_discard()
411 * memblock_double_array - double the size of the memblock regions array
413 * @new_area_start: starting address of memory range to avoid overlap with
414 * @new_area_size: size of memory range to avoid overlap with
417 * allocate memory for a new reserved regions array and there is a previously
418 * allocated memory range [@new_area_start, @new_area_start + @new_area_size]
419 * waiting to be reserved, ensure the memory used by the new array does
423 * 0 on success, -1 on failure.
435 /* We don't allow resizing until we know about the reserved regions in memblock_double_array()
436 * of memory that aren't suitable for allocation in memblock_double_array()
439 return -1; in memblock_double_array()
442 old_size = type->max * sizeof(struct memblock_region); in memblock_double_array()
452 if (type == &memblock.memory) in memblock_double_array()
462 /* only exclude range when trying to double reserved.regions */ in memblock_double_array()
463 if (type != &memblock.reserved) in memblock_double_array()
478 type->name, type->max, type->max * 2); in memblock_double_array()
479 return -1; in memblock_double_array()
482 new_end = addr + new_size - 1; in memblock_double_array()
483 memblock_dbg("memblock: %s is doubled to %ld at [%pa-%pa]", in memblock_double_array()
484 type->name, type->max * 2, &addr, &new_end); in memblock_double_array()
488 * reserved region since it may be our reserved array itself that is in memblock_double_array()
491 memcpy(new_array, type->regions, old_size); in memblock_double_array()
492 memset(new_array + type->max, 0, old_size); in memblock_double_array()
493 old_array = type->regions; in memblock_double_array()
494 type->regions = new_array; in memblock_double_array()
495 type->max <<= 1; in memblock_double_array()
518 * memblock_merge_regions - merge neighboring compatible regions
528 while (i < type->cnt - 1) { in memblock_merge_regions()
529 struct memblock_region *this = &type->regions[i]; in memblock_merge_regions()
530 struct memblock_region *next = &type->regions[i + 1]; in memblock_merge_regions()
532 if (this->base + this->size != next->base || in memblock_merge_regions()
535 this->flags != next->flags) { in memblock_merge_regions()
536 BUG_ON(this->base + this->size > next->base); in memblock_merge_regions()
541 this->size += next->size; in memblock_merge_regions()
543 memmove(next, next + 1, (type->cnt - (i + 2)) * sizeof(*next)); in memblock_merge_regions()
544 type->cnt--; in memblock_merge_regions()
549 * memblock_insert_region - insert new memblock region
566 struct memblock_region *rgn = &type->regions[idx]; in memblock_insert_region()
568 BUG_ON(type->cnt >= type->max); in memblock_insert_region()
569 memmove(rgn + 1, rgn, (type->cnt - idx) * sizeof(*rgn)); in memblock_insert_region()
570 rgn->base = base; in memblock_insert_region()
571 rgn->size = size; in memblock_insert_region()
572 rgn->flags = flags; in memblock_insert_region()
574 type->cnt++; in memblock_insert_region()
575 type->total_size += size; in memblock_insert_region()
579 * memblock_add_range - add new memblock region
587 * is allowed to overlap with existing ones - overlaps don't affect already
592 * 0 on success, -errno on failure.
608 if (type->regions[0].size == 0) { in memblock_add_range()
609 WARN_ON(type->cnt != 1 || type->total_size); in memblock_add_range()
610 type->regions[0].base = base; in memblock_add_range()
611 type->regions[0].size = size; in memblock_add_range()
612 type->regions[0].flags = flags; in memblock_add_range()
613 memblock_set_region_node(&type->regions[0], nid); in memblock_add_range()
614 type->total_size = size; in memblock_add_range()
627 phys_addr_t rbase = rgn->base; in memblock_add_range()
628 phys_addr_t rend = rbase + rgn->size; in memblock_add_range()
642 WARN_ON(flags != rgn->flags); in memblock_add_range()
646 rbase - base, nid, in memblock_add_range()
657 memblock_insert_region(type, idx, base, end - base, in memblock_add_range()
669 while (type->cnt + nr_new > type->max) in memblock_add_range()
671 return -ENOMEM; in memblock_add_range()
681 * memblock_add_node - add new memblock region within a NUMA node
686 * Add new memblock region [@base, @base + @size) to the "memory"
690 * 0 on success, -errno on failure.
695 return memblock_add_range(&memblock.memory, base, size, nid, 0); in memblock_add_node()
699 * memblock_add - add new memblock region
703 * Add new memblock region [@base, @base + @size) to the "memory"
707 * 0 on success, -errno on failure.
711 phys_addr_t end = base + size - 1; in memblock_add()
713 memblock_dbg("%s: [%pa-%pa] %pS\n", __func__, in memblock_add()
716 return memblock_add_range(&memblock.memory, base, size, MAX_NUMNODES, 0); in memblock_add()
720 * memblock_isolate_range - isolate given range into disjoint memblocks
733 * 0 on success, -errno on failure.
749 while (type->cnt + 2 > type->max) in memblock_isolate_range()
751 return -ENOMEM; in memblock_isolate_range()
754 phys_addr_t rbase = rgn->base; in memblock_isolate_range()
755 phys_addr_t rend = rbase + rgn->size; in memblock_isolate_range()
765 * to process the next region - the new top half. in memblock_isolate_range()
767 rgn->base = base; in memblock_isolate_range()
768 rgn->size -= base - rbase; in memblock_isolate_range()
769 type->total_size -= base - rbase; in memblock_isolate_range()
770 memblock_insert_region(type, idx, rbase, base - rbase, in memblock_isolate_range()
772 rgn->flags); in memblock_isolate_range()
776 * current region - the new bottom half. in memblock_isolate_range()
778 rgn->base = end; in memblock_isolate_range()
779 rgn->size -= end - rbase; in memblock_isolate_range()
780 type->total_size -= end - rbase; in memblock_isolate_range()
781 memblock_insert_region(type, idx--, rbase, end - rbase, in memblock_isolate_range()
783 rgn->flags); in memblock_isolate_range()
805 for (i = end_rgn - 1; i >= start_rgn; i--) in memblock_remove_range()
812 phys_addr_t end = base + size - 1; in memblock_remove()
814 memblock_dbg("%s: [%pa-%pa] %pS\n", __func__, in memblock_remove()
817 return memblock_remove_range(&memblock.memory, base, size); in memblock_remove()
821 * memblock_free - free boot memory block
822 * @base: phys starting address of the boot memory block
823 * @size: size of the boot memory block in bytes
825 * Free boot memory block previously allocated by memblock_alloc_xx() API.
826 * The freeing memory will not be released to the buddy allocator.
830 phys_addr_t end = base + size - 1; in memblock_free()
832 memblock_dbg("%s: [%pa-%pa] %pS\n", __func__, in memblock_free()
836 return memblock_remove_range(&memblock.reserved, base, size); in memblock_free()
844 phys_addr_t end = base + size - 1; in memblock_reserve()
846 memblock_dbg("%s: [%pa-%pa] %pS\n", __func__, in memblock_reserve()
849 return memblock_add_range(&memblock.reserved, base, size, MAX_NUMNODES, 0); in memblock_reserve()
855 phys_addr_t end = base + size - 1; in memblock_physmem_add()
857 memblock_dbg("%s: [%pa-%pa] %pS\n", __func__, in memblock_physmem_add()
865 * memblock_setclr_flag - set or clear flag for a memory region
873 * Return: 0 on success, -errno on failure.
878 struct memblock_type *type = &memblock.memory; in memblock_setclr_flag()
886 struct memblock_region *r = &type->regions[i]; in memblock_setclr_flag()
889 r->flags |= flag; in memblock_setclr_flag()
891 r->flags &= ~flag; in memblock_setclr_flag()
899 * memblock_mark_hotplug - Mark hotpluggable memory with flag MEMBLOCK_HOTPLUG.
903 * Return: 0 on success, -errno on failure.
911 * memblock_clear_hotplug - Clear flag MEMBLOCK_HOTPLUG for a specified region.
915 * Return: 0 on success, -errno on failure.
923 * memblock_mark_mirror - Mark mirrored memory with flag MEMBLOCK_MIRROR.
927 * Return: 0 on success, -errno on failure.
937 * memblock_mark_nomap - Mark a memory region with flag MEMBLOCK_NOMAP.
941 * Return: 0 on success, -errno on failure.
949 * memblock_clear_nomap - Clear flag MEMBLOCK_NOMAP for a specified region.
953 * Return: 0 on success, -errno on failure.
966 /* we never skip regions when iterating memblock.reserved or physmem */ in should_skip_region()
970 /* only memory regions are associated with nodes, check it */ in should_skip_region()
974 /* skip hotpluggable memory regions if needed */ in should_skip_region()
979 /* if we want mirror memory skip non-mirror memory regions */ in should_skip_region()
983 /* skip nomap memory unless we were asked for it explicitly */ in should_skip_region()
991 * __next_mem_range - next function for for_each_free_mem_range() etc.
994 * @flags: pick from blocks based on memory attributes
996 * @type_b: pointer to memblock_type which excludes memory from being taken
1007 * 0:[0-16), 1:[32-48), 2:[128-130)
1011 * 0:[0-0), 1:[16-32), 2:[48-128), 3:[130-MAX)
1028 for (; idx_a < type_a->cnt; idx_a++) { in __next_mem_range()
1029 struct memblock_region *m = &type_a->regions[idx_a]; in __next_mem_range()
1031 phys_addr_t m_start = m->base; in __next_mem_range()
1032 phys_addr_t m_end = m->base + m->size; in __next_mem_range()
1051 for (; idx_b < type_b->cnt + 1; idx_b++) { in __next_mem_range()
1056 r = &type_b->regions[idx_b]; in __next_mem_range()
1057 r_start = idx_b ? r[-1].base + r[-1].size : 0; in __next_mem_range()
1058 r_end = idx_b < type_b->cnt ? in __next_mem_range()
1059 r->base : PHYS_ADDR_MAX; in __next_mem_range()
1095 * __next_mem_range_rev - generic next function for for_each_*_range_rev()
1099 * @flags: pick from blocks based on memory attributes
1101 * @type_b: pointer to memblock_type which excludes memory from being taken
1125 idx_a = type_a->cnt - 1; in __next_mem_range_rev()
1127 idx_b = type_b->cnt; in __next_mem_range_rev()
1132 for (; idx_a >= 0; idx_a--) { in __next_mem_range_rev()
1133 struct memblock_region *m = &type_a->regions[idx_a]; in __next_mem_range_rev()
1135 phys_addr_t m_start = m->base; in __next_mem_range_rev()
1136 phys_addr_t m_end = m->base + m->size; in __next_mem_range_rev()
1149 idx_a--; in __next_mem_range_rev()
1155 for (; idx_b >= 0; idx_b--) { in __next_mem_range_rev()
1160 r = &type_b->regions[idx_b]; in __next_mem_range_rev()
1161 r_start = idx_b ? r[-1].base + r[-1].size : 0; in __next_mem_range_rev()
1162 r_end = idx_b < type_b->cnt ? in __next_mem_range_rev()
1163 r->base : PHYS_ADDR_MAX; in __next_mem_range_rev()
1180 idx_a--; in __next_mem_range_rev()
1182 idx_b--; in __next_mem_range_rev()
1199 struct memblock_type *type = &memblock.memory; in __next_mem_pfn_range()
1203 while (++*idx < type->cnt) { in __next_mem_pfn_range()
1204 r = &type->regions[*idx]; in __next_mem_pfn_range()
1207 if (PFN_UP(r->base) >= PFN_DOWN(r->base + r->size)) in __next_mem_pfn_range()
1212 if (*idx >= type->cnt) { in __next_mem_pfn_range()
1213 *idx = -1; in __next_mem_pfn_range()
1218 *out_start_pfn = PFN_UP(r->base); in __next_mem_pfn_range()
1220 *out_end_pfn = PFN_DOWN(r->base + r->size); in __next_mem_pfn_range()
1226 * memblock_set_node - set node ID on memblock regions
1236 * 0 on success, -errno on failure.
1250 memblock_set_region_node(&type->regions[i], nid); in memblock_set_node()
1259 * __next_mem_pfn_range_in_zone - iterator for for_each_*_range_in_zone()
1262 * @zone: zone in which all of the memory blocks reside
1268 * deferred memory init routines and as such we were duplicating much of
1282 &memblock.memory, &memblock.reserved, in __next_mem_pfn_range_in_zone()
1293 if (zone->zone_start_pfn < epfn && spfn < epfn) { in __next_mem_pfn_range_in_zone()
1301 *out_spfn = max(zone->zone_start_pfn, spfn); in __next_mem_pfn_range_in_zone()
1309 &memblock.memory, &memblock.reserved, in __next_mem_pfn_range_in_zone()
1323 * memblock_alloc_range_nid - allocate boot memory block
1324 * @size: size of memory block to be allocated in bytes
1326 * @start: the lower bound of the memory region to allocate (phys address)
1327 * @end: the upper bound of the memory region to allocate (phys address)
1331 * The allocation is performed from memory region limited by
1334 * If the specified node can not hold the requested memory and @exact_nid
1337 * For systems with memory mirroring, the allocation is attempted first
1339 * memory region.
1342 * allocated boot memory block, so that it is never reported as leaks.
1345 * Physical address of allocated memory block on success, %0 on failure.
1380 pr_warn("Could not allocate %pap bytes of mirrored memory\n", in memblock_alloc_range_nid()
1402 * memblock_phys_alloc_range - allocate a memory block inside specified range
1403 * @size: size of memory block to be allocated in bytes
1405 * @start: the lower bound of the memory region to allocate (physical address)
1406 * @end: the upper bound of the memory region to allocate (physical address)
1410 * Return: physical address of the allocated memory block on success,
1426 * memblock_phys_alloc_try_nid - allocate a memory block from specified MUMA node
1427 * @size: size of memory block to be allocated in bytes
1431 * Allocates memory block from the specified NUMA node. If the node
1432 * has no available memory, attempts to allocated from any node in the
1435 * Return: physical address of the allocated memory block on success,
1445 * memblock_alloc_internal - allocate boot memory block
1446 * @size: size of memory block to be allocated in bytes
1448 * @min_addr: the lower bound of the memory region to allocate (phys address)
1449 * @max_addr: the upper bound of the memory region to allocate (phys address)
1453 * Allocates memory block using memblock_alloc_range_nid() and
1457 * will fall back to memory below @min_addr. Other constraints, such
1458 * as node and mirrored memory will be handled again in
1462 * Virtual address of allocated memory block on success, NULL on failure.
1497 * memblock_alloc_exact_nid_raw - allocate boot memory block on the exact node
1498 * without zeroing memory
1499 * @size: size of memory block to be allocated in bytes
1501 * @min_addr: the lower bound of the memory region from where the allocation
1503 * @max_addr: the upper bound of the memory region from where the allocation
1505 * allocate only from memory limited by memblock.current_limit value
1509 * info), if enabled. Does not zero allocated memory.
1512 * Virtual address of allocated memory block on success, NULL on failure.
1534 * memblock_alloc_try_nid_raw - allocate boot memory block without zeroing
1535 * memory and without panicking
1536 * @size: size of memory block to be allocated in bytes
1538 * @min_addr: the lower bound of the memory region from where the allocation
1540 * @max_addr: the upper bound of the memory region from where the allocation
1542 * allocate only from memory limited by memblock.current_limit value
1546 * info), if enabled. Does not zero allocated memory, does not panic if request
1550 * Virtual address of allocated memory block on success, NULL on failure.
1572 * memblock_alloc_try_nid - allocate boot memory block
1573 * @size: size of memory block to be allocated in bytes
1575 * @min_addr: the lower bound of the memory region from where the allocation
1577 * @max_addr: the upper bound of the memory region from where the allocation
1579 * allocate only from memory limited by memblock.current_limit value
1583 * info), if enabled. This function zeroes the allocated memory.
1586 * Virtual address of allocated memory block on success, NULL on failure.
1607 * __memblock_free_late - free pages directly to buddy allocator
1608 * @base: phys starting address of the boot memory block
1609 * @size: size of the boot memory block in bytes
1619 end = base + size - 1; in __memblock_free_late()
1620 memblock_dbg("%s: [%pa-%pa] %pS\n", in __memblock_free_late()
1638 return memblock.memory.total_size; in memblock_phys_mem_size()
1643 return memblock.reserved.total_size; in memblock_reserved_size()
1649 return memblock.memory.regions[0].base; in memblock_start_of_DRAM()
1654 int idx = memblock.memory.cnt - 1; in memblock_end_of_DRAM()
1656 return (memblock.memory.regions[idx].base + memblock.memory.regions[idx].size); in memblock_end_of_DRAM()
1666 * translate the memory @limit size into the max address within one of in __find_max_addr()
1667 * the memory memblock regions, if the @limit exceeds the total size in __find_max_addr()
1671 if (limit <= r->size) { in __find_max_addr()
1672 max_addr = r->base + limit; in __find_max_addr()
1675 limit -= r->size; in __find_max_addr()
1690 /* @limit exceeds the total size of the memory, do nothing */ in memblock_enforce_memory_limit()
1694 /* truncate both memory and reserved regions */ in memblock_enforce_memory_limit()
1695 memblock_remove_range(&memblock.memory, max_addr, in memblock_enforce_memory_limit()
1697 memblock_remove_range(&memblock.reserved, max_addr, in memblock_enforce_memory_limit()
1709 ret = memblock_isolate_range(&memblock.memory, base, size, in memblock_cap_memory_range()
1715 for (i = memblock.memory.cnt - 1; i >= end_rgn; i--) in memblock_cap_memory_range()
1716 if (!memblock_is_nomap(&memblock.memory.regions[i])) in memblock_cap_memory_range()
1717 memblock_remove_region(&memblock.memory, i); in memblock_cap_memory_range()
1719 for (i = start_rgn - 1; i >= 0; i--) in memblock_cap_memory_range()
1720 if (!memblock_is_nomap(&memblock.memory.regions[i])) in memblock_cap_memory_range()
1721 memblock_remove_region(&memblock.memory, i); in memblock_cap_memory_range()
1723 /* truncate the reserved regions */ in memblock_cap_memory_range()
1724 memblock_remove_range(&memblock.reserved, 0, base); in memblock_cap_memory_range()
1725 memblock_remove_range(&memblock.reserved, in memblock_cap_memory_range()
1738 /* @limit exceeds the total size of the memory, do nothing */ in memblock_mem_limit_remove_map()
1747 unsigned int left = 0, right = type->cnt; in memblock_search()
1752 if (addr < type->regions[mid].base) in memblock_search()
1754 else if (addr >= (type->regions[mid].base + in memblock_search()
1755 type->regions[mid].size)) in memblock_search()
1760 return -1; in memblock_search()
1765 return memblock_search(&memblock.reserved, addr) != -1; in memblock_is_reserved()
1770 return memblock_search(&memblock.memory, addr) != -1; in memblock_is_memory()
1775 int i = memblock_search(&memblock.memory, addr); in memblock_is_map_memory()
1777 if (i == -1) in memblock_is_map_memory()
1779 return !memblock_is_nomap(&memblock.memory.regions[i]); in memblock_is_map_memory()
1785 struct memblock_type *type = &memblock.memory; in memblock_search_pfn_nid()
1788 if (mid == -1) in memblock_search_pfn_nid()
1789 return -1; in memblock_search_pfn_nid()
1791 *start_pfn = PFN_DOWN(type->regions[mid].base); in memblock_search_pfn_nid()
1792 *end_pfn = PFN_DOWN(type->regions[mid].base + type->regions[mid].size); in memblock_search_pfn_nid()
1794 return memblock_get_region_node(&type->regions[mid]); in memblock_search_pfn_nid()
1798 * memblock_is_region_memory - check if a region is a subset of memory
1802 * Check if the region [@base, @base + @size) is a subset of a memory block.
1805 * 0 if false, non-zero if true
1809 int idx = memblock_search(&memblock.memory, base); in memblock_is_region_memory()
1812 if (idx == -1) in memblock_is_region_memory()
1814 return (memblock.memory.regions[idx].base + in memblock_is_region_memory()
1815 memblock.memory.regions[idx].size) >= end; in memblock_is_region_memory()
1819 * memblock_is_region_reserved - check if a region intersects reserved memory
1823 * Check if the region [@base, @base + @size) intersects a reserved
1824 * memory block.
1831 return memblock_overlaps_region(&memblock.reserved, base, size); in memblock_is_region_reserved()
1840 orig_start = r->base; in memblock_trim_memory()
1841 orig_end = r->base + r->size; in memblock_trim_memory()
1849 r->base = start; in memblock_trim_memory()
1850 r->size = end - start; in memblock_trim_memory()
1852 memblock_remove_region(&memblock.memory, in memblock_trim_memory()
1853 r - memblock.memory.regions); in memblock_trim_memory()
1854 r--; in memblock_trim_memory()
1876 pr_info(" %s.cnt = 0x%lx\n", type->name, type->cnt); in memblock_dump()
1881 base = rgn->base; in memblock_dump()
1882 size = rgn->size; in memblock_dump()
1883 end = base + size - 1; in memblock_dump()
1884 flags = rgn->flags; in memblock_dump()
1890 pr_info(" %s[%#x]\t[%pa-%pa], %pa bytes%s flags: %#x\n", in memblock_dump()
1891 type->name, idx, &base, &end, &size, nid_buf, flags); in memblock_dump()
1898 pr_info(" memory size = %pa reserved size = %pa\n", in __memblock_dump_all()
1899 &memblock.memory.total_size, in __memblock_dump_all()
1900 &memblock.reserved.total_size); in __memblock_dump_all()
1902 memblock_dump(&memblock.memory); in __memblock_dump_all()
1903 memblock_dump(&memblock.reserved); in __memblock_dump_all()
1944 order = min(MAX_ORDER - 1UL, __ffs(start)); in __free_pages_memory()
1947 order--; in __free_pages_memory()
1965 totalram_pages_add(defer_end - defer_start); in defer_free_memblock()
1967 pr_info("%s: size %luM free %luM [%luM - %luM] total %luM\n", __func__, in defer_free_memblock()
1969 (defer_end - defer_start) >> (20 - PAGE_SHIFT), in defer_free_memblock()
1970 defer_end >> (20 - PAGE_SHIFT), in defer_free_memblock()
1971 defer_start >> (20 - PAGE_SHIFT), in defer_free_memblock()
1972 totalram_pages() >> (20 - PAGE_SHIFT)); in defer_free_memblock()
1988 if ((end - start) > defer_free_block_size) { in __free_memory_core()
1998 return end_pfn - start_pfn; in __free_memory_core()
2007 memblock_clear_hotplug(0, -1); in free_low_memory_core_early()
2013 * We need to use NUMA_NO_NODE instead of NODE_DATA(0)->node_id in free_low_memory_core_early()
2030 for (z = pgdat->node_zones; z < pgdat->node_zones + MAX_NR_ZONES; z++) in reset_node_managed_pages()
2031 atomic_long_set(&z->managed_pages, 0); in reset_node_managed_pages()
2048 * memblock_free_all - release free pages to the buddy allocator
2068 struct memblock_type *type = m->private; in memblock_debug_show()
2073 for (i = 0; i < type->cnt; i++) { in memblock_debug_show()
2074 reg = &type->regions[i]; in memblock_debug_show()
2075 end = reg->base + reg->size - 1; in memblock_debug_show()
2078 seq_printf(m, "%pa..%pa\n", ®->base, &end); in memblock_debug_show()
2088 debugfs_create_file("memory", 0444, root, in memblock_init_debugfs()
2089 &memblock.memory, &memblock_debug_fops); in memblock_init_debugfs()
2090 debugfs_create_file("reserved", 0444, root, in memblock_init_debugfs()
2091 &memblock.reserved, &memblock_debug_fops); in memblock_init_debugfs()