Lines Matching +full:memory +full:- +full:region
2 * Procedures for maintaining information about logical memory blocks.
33 * Memblock is a method of managing memory regions during the early
34 * boot period when the usual kernel memory allocators are not up and
37 * Memblock views the system memory as collections of contiguous
40 * * ``memory`` - describes the physical memory available to the
41 * kernel; this may differ from the actual physical memory installed
42 * in the system, for instance when the memory is restricted with
44 * * ``reserved`` - describes the regions that were allocated
45 * * ``physmap`` - describes the actual physical memory regardless of
49 * Each region is represented by :c:type:`struct memblock_region` that
50 * defines the region extents, its attributes and NUMA node id on NUMA
51 * systems. Every memory type is described by the :c:type:`struct
52 * memblock_type` which contains an array of memory regions along with
53 * the allocator metadata. The memory types are nicely wrapped with
55 * at build time. The region arrays for the "memory" and "reserved"
59 * the region arrays during addition of new regions. This feature
60 * should be used with care so that memory allocated for the region
65 * memory layout is by using :c:func:`memblock_add` or
67 * assign the region to a NUMA node and it is appropriate for UMA
69 * assign the region to a NUMA node later in the setup process using
73 * Once memblock is setup the memory can be allocated using either
77 * :c:func:`mem_init` function frees all the memory to the buddy page
92 .memory.regions = memblock_memory_init_regions,
93 .memory.cnt = 1, /* empty dummy entry */
94 .memory.max = INIT_MEMBLOCK_REGIONS,
95 .memory.name = "memory",
127 return *size = min(*size, PHYS_ADDR_MAX - base); in memblock_cap_size()
144 for (i = 0; i < type->cnt; i++) in memblock_overlaps_region()
145 if (memblock_addrs_overlap(base, size, type->regions[i].base, in memblock_overlaps_region()
146 type->regions[i].size)) in memblock_overlaps_region()
148 return i < type->cnt; in memblock_overlaps_region()
152 * __memblock_find_range_bottom_up - find free area utility in bottom-up
159 * @flags: pick from blocks based on memory attributes
161 * Utility called from memblock_find_in_range_node(), find free area bottom-up.
179 if (cand < this_end && this_end - cand >= size) in __memblock_find_range_bottom_up()
187 * __memblock_find_range_top_down - find free area utility, in top-down
194 * @flags: pick from blocks based on memory attributes
196 * Utility called from memblock_find_in_range_node(), find free area top-down.
217 cand = round_down(this_end - size, align); in __memblock_find_range_top_down()
226 * memblock_find_in_range_node - find free area in given range and node
233 * @flags: pick from blocks based on memory attributes
237 * When allocation direction is bottom-up, the @start should be greater
239 * reason is that we want the bottom-up allocation just near the kernel
240 * image so it is highly likely that the allocated memory and the kernel
243 * If bottom-up allocation failed, will try to allocate memory top-down.
265 * try bottom-up allocation only when bottom-up mode in memblock_find_in_range_node()
274 /* ok, try bottom-up allocation first */ in memblock_find_in_range_node()
281 * we always limit bottom-up allocation above the kernel, in memblock_find_in_range_node()
282 * but top-down allocation doesn't have the limit, so in memblock_find_in_range_node()
283 * retrying top-down allocation may succeed when bottom-up in memblock_find_in_range_node()
286 * bottom-up allocation is expected to be fail very rarely, in memblock_find_in_range_node()
291 "memblock: bottom-up allocation failed, memory hotremove may be affected\n"); in memblock_find_in_range_node()
299 * memblock_find_in_range - find free area in given range
323 pr_warn("Could not allocate %pap bytes of mirrored memory\n", in memblock_find_in_range()
334 type->total_size -= type->regions[r].size; in memblock_remove_region()
335 memmove(&type->regions[r], &type->regions[r + 1], in memblock_remove_region()
336 (type->cnt - (r + 1)) * sizeof(type->regions[r])); in memblock_remove_region()
337 type->cnt--; in memblock_remove_region()
340 if (type->cnt == 0) { in memblock_remove_region()
341 WARN_ON(type->total_size != 0); in memblock_remove_region()
342 type->cnt = 1; in memblock_remove_region()
343 type->regions[0].base = 0; in memblock_remove_region()
344 type->regions[0].size = 0; in memblock_remove_region()
345 type->regions[0].flags = 0; in memblock_remove_region()
346 memblock_set_region_node(&type->regions[0], MAX_NUMNODES); in memblock_remove_region()
352 * memblock_discard - discard memory and reserved arrays if they were allocated
365 if (memblock.memory.regions != memblock_memory_init_regions) { in memblock_discard()
366 addr = __pa(memblock.memory.regions); in memblock_discard()
368 memblock.memory.max); in memblock_discard()
375 * memblock_double_array - double the size of the memblock regions array
377 * @new_area_start: starting address of memory range to avoid overlap with
378 * @new_area_size: size of memory range to avoid overlap with
381 * allocate memory for a new reserved regions array and there is a previously
382 * allocated memory range [@new_area_start, @new_area_start + @new_area_size]
383 * waiting to be reserved, ensure the memory used by the new array does
387 * 0 on success, -1 on failure.
400 * of memory that aren't suitable for allocation in memblock_double_array()
403 return -1; in memblock_double_array()
406 old_size = type->max * sizeof(struct memblock_region); in memblock_double_array()
416 if (type == &memblock.memory) in memblock_double_array()
430 * is active for memory hotplug operations in memblock_double_array()
452 type->name, type->max, type->max * 2); in memblock_double_array()
453 return -1; in memblock_double_array()
456 new_end = addr + new_size - 1; in memblock_double_array()
457 memblock_dbg("memblock: %s is doubled to %ld at [%pa-%pa]", in memblock_double_array()
458 type->name, type->max * 2, &addr, &new_end); in memblock_double_array()
462 * reserved region since it may be our reserved array itself that is in memblock_double_array()
465 memcpy(new_array, type->regions, old_size); in memblock_double_array()
466 memset(new_array + type->max, 0, old_size); in memblock_double_array()
467 old_array = type->regions; in memblock_double_array()
468 type->regions = new_array; in memblock_double_array()
469 type->max <<= 1; in memblock_double_array()
492 * memblock_merge_regions - merge neighboring compatible regions
502 while (i < type->cnt - 1) { in memblock_merge_regions()
503 struct memblock_region *this = &type->regions[i]; in memblock_merge_regions()
504 struct memblock_region *next = &type->regions[i + 1]; in memblock_merge_regions()
506 if (this->base + this->size != next->base || in memblock_merge_regions()
509 this->flags != next->flags) { in memblock_merge_regions()
510 BUG_ON(this->base + this->size > next->base); in memblock_merge_regions()
515 this->size += next->size; in memblock_merge_regions()
517 memmove(next, next + 1, (type->cnt - (i + 2)) * sizeof(*next)); in memblock_merge_regions()
518 type->cnt--; in memblock_merge_regions()
523 * memblock_insert_region - insert new memblock region
526 * @base: base address of the new region
527 * @size: size of the new region
528 * @nid: node id of the new region
529 * @flags: flags of the new region
531 * Insert new memblock region [@base, @base + @size) into @type at @idx.
532 * @type must already have extra room to accommodate the new region.
540 struct memblock_region *rgn = &type->regions[idx]; in memblock_insert_region()
542 BUG_ON(type->cnt >= type->max); in memblock_insert_region()
543 memmove(rgn + 1, rgn, (type->cnt - idx) * sizeof(*rgn)); in memblock_insert_region()
544 rgn->base = base; in memblock_insert_region()
545 rgn->size = size; in memblock_insert_region()
546 rgn->flags = flags; in memblock_insert_region()
548 type->cnt++; in memblock_insert_region()
549 type->total_size += size; in memblock_insert_region()
553 * memblock_add_range - add new memblock region
554 * @type: memblock type to add new region into
555 * @base: base address of the new region
556 * @size: size of the new region
557 * @nid: nid of the new region
558 * @flags: flags of the new region
560 * Add new memblock region [@base, @base + @size) into @type. The new region
561 * is allowed to overlap with existing ones - overlaps don't affect already
566 * 0 on success, -errno on failure.
582 if (type->regions[0].size == 0) { in memblock_add_range()
583 WARN_ON(type->cnt != 1 || type->total_size); in memblock_add_range()
584 type->regions[0].base = base; in memblock_add_range()
585 type->regions[0].size = size; in memblock_add_range()
586 type->regions[0].flags = flags; in memblock_add_range()
587 memblock_set_region_node(&type->regions[0], nid); in memblock_add_range()
588 type->total_size = size; in memblock_add_range()
601 phys_addr_t rbase = rgn->base; in memblock_add_range()
602 phys_addr_t rend = rbase + rgn->size; in memblock_add_range()
616 WARN_ON(flags != rgn->flags); in memblock_add_range()
620 rbase - base, nid, in memblock_add_range()
631 memblock_insert_region(type, idx, base, end - base, in memblock_add_range()
643 while (type->cnt + nr_new > type->max) in memblock_add_range()
645 return -ENOMEM; in memblock_add_range()
655 * memblock_add_node - add new memblock region within a NUMA node
656 * @base: base address of the new region
657 * @size: size of the new region
658 * @nid: nid of the new region
660 * Add new memblock region [@base, @base + @size) to the "memory"
664 * 0 on success, -errno on failure.
669 return memblock_add_range(&memblock.memory, base, size, nid, 0); in memblock_add_node()
673 * memblock_add - add new memblock region
674 * @base: base address of the new region
675 * @size: size of the new region
677 * Add new memblock region [@base, @base + @size) to the "memory"
681 * 0 on success, -errno on failure.
685 phys_addr_t end = base + size - 1; in memblock_add()
687 memblock_dbg("memblock_add: [%pa-%pa] %pF\n", in memblock_add()
690 return memblock_add_range(&memblock.memory, base, size, MAX_NUMNODES, 0); in memblock_add()
694 * memblock_isolate_range - isolate given range into disjoint memblocks
698 * @start_rgn: out parameter for the start of isolated region
699 * @end_rgn: out parameter for the end of isolated region
704 * region inside the range is returned in *@start_rgn and end in *@end_rgn.
707 * 0 on success, -errno on failure.
723 while (type->cnt + 2 > type->max) in memblock_isolate_range()
725 return -ENOMEM; in memblock_isolate_range()
728 phys_addr_t rbase = rgn->base; in memblock_isolate_range()
729 phys_addr_t rend = rbase + rgn->size; in memblock_isolate_range()
739 * to process the next region - the new top half. in memblock_isolate_range()
741 rgn->base = base; in memblock_isolate_range()
742 rgn->size -= base - rbase; in memblock_isolate_range()
743 type->total_size -= base - rbase; in memblock_isolate_range()
744 memblock_insert_region(type, idx, rbase, base - rbase, in memblock_isolate_range()
746 rgn->flags); in memblock_isolate_range()
750 * current region - the new bottom half. in memblock_isolate_range()
752 rgn->base = end; in memblock_isolate_range()
753 rgn->size -= end - rbase; in memblock_isolate_range()
754 type->total_size -= end - rbase; in memblock_isolate_range()
755 memblock_insert_region(type, idx--, rbase, end - rbase, in memblock_isolate_range()
757 rgn->flags); in memblock_isolate_range()
779 for (i = end_rgn - 1; i >= start_rgn; i--) in memblock_remove_range()
786 phys_addr_t end = base + size - 1; in memblock_remove()
788 memblock_dbg("memblock_remove: [%pa-%pa] %pS\n", in memblock_remove()
791 return memblock_remove_range(&memblock.memory, base, size); in memblock_remove()
797 phys_addr_t end = base + size - 1; in memblock_free()
799 memblock_dbg(" memblock_free: [%pa-%pa] %pF\n", in memblock_free()
808 phys_addr_t end = base + size - 1; in memblock_reserve()
810 memblock_dbg("memblock_reserve: [%pa-%pa] %pF\n", in memblock_reserve()
817 * memblock_setclr_flag - set or clear flag for a memory region
818 * @base: base address of the region
819 * @size: size of the region
823 * This function isolates region [@base, @base + @size), and sets/clears flag
825 * Return: 0 on success, -errno on failure.
830 struct memblock_type *type = &memblock.memory; in memblock_setclr_flag()
839 memblock_set_region_flags(&type->regions[i], flag); in memblock_setclr_flag()
841 memblock_clear_region_flags(&type->regions[i], flag); in memblock_setclr_flag()
848 * memblock_mark_hotplug - Mark hotpluggable memory with flag MEMBLOCK_HOTPLUG.
849 * @base: the base phys addr of the region
850 * @size: the size of the region
852 * Return: 0 on success, -errno on failure.
860 * memblock_clear_hotplug - Clear flag MEMBLOCK_HOTPLUG for a specified region.
861 * @base: the base phys addr of the region
862 * @size: the size of the region
864 * Return: 0 on success, -errno on failure.
872 * memblock_mark_mirror - Mark mirrored memory with flag MEMBLOCK_MIRROR.
873 * @base: the base phys addr of the region
874 * @size: the size of the region
876 * Return: 0 on success, -errno on failure.
886 * memblock_mark_nomap - Mark a memory region with flag MEMBLOCK_NOMAP.
887 * @base: the base phys addr of the region
888 * @size: the size of the region
890 * Return: 0 on success, -errno on failure.
898 * memblock_clear_nomap - Clear flag MEMBLOCK_NOMAP for a specified region.
899 * @base: the base phys addr of the region
900 * @size: the size of the region
902 * Return: 0 on success, -errno on failure.
910 * __next_reserved_mem_region - next function for for_each_reserved_region()
912 * @out_start: ptr to phys_addr_t for start address of the region, can be %NULL
913 * @out_end: ptr to phys_addr_t for end address of the region, can be %NULL
915 * Iterate over all reserved memory regions.
923 if (*idx < type->cnt) { in __next_reserved_mem_region()
924 struct memblock_region *r = &type->regions[*idx]; in __next_reserved_mem_region()
925 phys_addr_t base = r->base; in __next_reserved_mem_region()
926 phys_addr_t size = r->size; in __next_reserved_mem_region()
931 *out_end = base + size - 1; in __next_reserved_mem_region()
942 * __next__mem_range - next function for for_each_free_mem_range() etc.
945 * @flags: pick from blocks based on memory attributes
947 * @type_b: pointer to memblock_type which excludes memory from being taken
955 * areas before each region in type_b. For example, if type_b regions
958 * 0:[0-16), 1:[32-48), 2:[128-130)
962 * 0:[0-0), 1:[16-32), 2:[48-128), 3:[130-MAX)
964 * As both region arrays are sorted, the function advances the two indices
981 for (; idx_a < type_a->cnt; idx_a++) { in __next_mem_range()
982 struct memblock_region *m = &type_a->regions[idx_a]; in __next_mem_range()
984 phys_addr_t m_start = m->base; in __next_mem_range()
985 phys_addr_t m_end = m->base + m->size; in __next_mem_range()
988 /* only memory regions are associated with nodes, check it */ in __next_mem_range()
992 /* skip hotpluggable memory regions if needed */ in __next_mem_range()
996 /* if we want mirror memory skip non-mirror memory regions */ in __next_mem_range()
1000 /* skip nomap memory unless we were asked for it explicitly */ in __next_mem_range()
1017 for (; idx_b < type_b->cnt + 1; idx_b++) { in __next_mem_range()
1022 r = &type_b->regions[idx_b]; in __next_mem_range()
1023 r_start = idx_b ? r[-1].base + r[-1].size : 0; in __next_mem_range()
1024 r_end = idx_b < type_b->cnt ? in __next_mem_range()
1025 r->base : PHYS_ADDR_MAX; in __next_mem_range()
1043 * The region which ends first is in __next_mem_range()
1061 * __next_mem_range_rev - generic next function for for_each_*_range_rev()
1065 * @flags: pick from blocks based on memory attributes
1067 * @type_b: pointer to memblock_type which excludes memory from being taken
1091 idx_a = type_a->cnt - 1; in __next_mem_range_rev()
1093 idx_b = type_b->cnt; in __next_mem_range_rev()
1098 for (; idx_a >= 0; idx_a--) { in __next_mem_range_rev()
1099 struct memblock_region *m = &type_a->regions[idx_a]; in __next_mem_range_rev()
1101 phys_addr_t m_start = m->base; in __next_mem_range_rev()
1102 phys_addr_t m_end = m->base + m->size; in __next_mem_range_rev()
1105 /* only memory regions are associated with nodes, check it */ in __next_mem_range_rev()
1109 /* skip hotpluggable memory regions if needed */ in __next_mem_range_rev()
1113 /* if we want mirror memory skip non-mirror memory regions */ in __next_mem_range_rev()
1117 /* skip nomap memory unless we were asked for it explicitly */ in __next_mem_range_rev()
1128 idx_a--; in __next_mem_range_rev()
1134 for (; idx_b >= 0; idx_b--) { in __next_mem_range_rev()
1139 r = &type_b->regions[idx_b]; in __next_mem_range_rev()
1140 r_start = idx_b ? r[-1].base + r[-1].size : 0; in __next_mem_range_rev()
1141 r_end = idx_b < type_b->cnt ? in __next_mem_range_rev()
1142 r->base : PHYS_ADDR_MAX; in __next_mem_range_rev()
1159 idx_a--; in __next_mem_range_rev()
1161 idx_b--; in __next_mem_range_rev()
1179 struct memblock_type *type = &memblock.memory; in __next_mem_pfn_range()
1182 while (++*idx < type->cnt) { in __next_mem_pfn_range()
1183 r = &type->regions[*idx]; in __next_mem_pfn_range()
1185 if (PFN_UP(r->base) >= PFN_DOWN(r->base + r->size)) in __next_mem_pfn_range()
1187 if (nid == MAX_NUMNODES || nid == r->nid) in __next_mem_pfn_range()
1190 if (*idx >= type->cnt) { in __next_mem_pfn_range()
1191 *idx = -1; in __next_mem_pfn_range()
1196 *out_start_pfn = PFN_UP(r->base); in __next_mem_pfn_range()
1198 *out_end_pfn = PFN_DOWN(r->base + r->size); in __next_mem_pfn_range()
1200 *out_nid = r->nid; in __next_mem_pfn_range()
1204 * memblock_set_node - set node ID on memblock regions
1214 * 0 on success, -errno on failure.
1227 memblock_set_region_node(&type->regions[i], nid); in memblock_set_node()
1323 * memblock_virt_alloc_internal - allocate boot memory block
1324 * @size: size of memory block to be allocated in bytes
1325 * @align: alignment of the region and block's size
1326 * @min_addr: the lower bound of the memory region to allocate (phys address)
1327 * @max_addr: the upper bound of the memory region to allocate (phys address)
1331 * will fall back to memory below @min_addr. Also, allocation may fall back
1333 * hold the requested memory.
1335 * The allocation is performed from memory region limited by
1338 * The memory block is aligned on %SMP_CACHE_BYTES if @align == 0.
1340 * The phys address of allocated boot memory block is converted to virtual and
1341 * allocated memory is reset to 0.
1344 * allocated boot memory block, so that it is never reported as leaks.
1347 * Virtual address of allocated memory block on success, NULL on failure.
1395 pr_warn("Could not allocate %pap bytes of mirrored memory\n", in memblock_virt_alloc_internal()
1416 * memblock_virt_alloc_try_nid_raw - allocate boot memory block without zeroing
1417 * memory and without panicking
1418 * @size: size of memory block to be allocated in bytes
1419 * @align: alignment of the region and block's size
1420 * @min_addr: the lower bound of the memory region from where the allocation
1422 * @max_addr: the upper bound of the memory region from where the allocation
1424 * allocate only from memory limited by memblock.current_limit value
1428 * info), if enabled. Does not zero allocated memory, does not panic if request
1432 * Virtual address of allocated memory block on success, NULL on failure.
1455 * memblock_virt_alloc_try_nid_nopanic - allocate boot memory block
1456 * @size: size of memory block to be allocated in bytes
1457 * @align: alignment of the region and block's size
1458 * @min_addr: the lower bound of the memory region from where the allocation
1460 * @max_addr: the upper bound of the memory region from where the allocation
1462 * allocate only from memory limited by memblock.current_limit value
1466 * info), if enabled. This function zeroes the allocated memory.
1469 * Virtual address of allocated memory block on success, NULL on failure.
1490 * memblock_virt_alloc_try_nid - allocate boot memory block with panicking
1491 * @size: size of memory block to be allocated in bytes
1492 * @align: alignment of the region and block's size
1493 * @min_addr: the lower bound of the memory region from where the allocation
1495 * @max_addr: the upper bound of the memory region from where the allocation
1497 * allocate only from memory limited by memblock.current_limit value
1505 * Virtual address of allocated memory block on success, NULL on failure.
1531 * __memblock_free_early - free boot memory block
1532 * @base: phys starting address of the boot memory block
1533 * @size: size of the boot memory block in bytes
1535 * Free boot memory block previously allocated by memblock_virt_alloc_xx() API.
1536 * The freeing memory will not be released to the buddy allocator.
1544 * __memblock_free_late - free bootmem block pages directly to buddy allocator
1545 * @base: phys starting address of the boot memory block
1546 * @size: size of the boot memory block in bytes
1556 end = base + size - 1; in __memblock_free_late()
1557 memblock_dbg("%s: [%pa-%pa] %pF\n", in __memblock_free_late()
1575 return memblock.memory.total_size; in memblock_phys_mem_size()
1589 for_each_memblock(memory, r) { in memblock_mem_size()
1594 pages += end_pfn - start_pfn; in memblock_mem_size()
1603 return memblock.memory.regions[0].base; in memblock_start_of_DRAM()
1608 int idx = memblock.memory.cnt - 1; in memblock_end_of_DRAM()
1610 return (memblock.memory.regions[idx].base + memblock.memory.regions[idx].size); in memblock_end_of_DRAM()
1619 * translate the memory @limit size into the max address within one of in __find_max_addr()
1620 * the memory memblock regions, if the @limit exceeds the total size in __find_max_addr()
1623 for_each_memblock(memory, r) { in __find_max_addr()
1624 if (limit <= r->size) { in __find_max_addr()
1625 max_addr = r->base + limit; in __find_max_addr()
1628 limit -= r->size; in __find_max_addr()
1643 /* @limit exceeds the total size of the memory, do nothing */ in memblock_enforce_memory_limit()
1647 /* truncate both memory and reserved regions */ in memblock_enforce_memory_limit()
1648 memblock_remove_range(&memblock.memory, max_addr, in memblock_enforce_memory_limit()
1662 ret = memblock_isolate_range(&memblock.memory, base, size, in memblock_cap_memory_range()
1668 for (i = memblock.memory.cnt - 1; i >= end_rgn; i--) in memblock_cap_memory_range()
1669 if (!memblock_is_nomap(&memblock.memory.regions[i])) in memblock_cap_memory_range()
1670 memblock_remove_region(&memblock.memory, i); in memblock_cap_memory_range()
1672 for (i = start_rgn - 1; i >= 0; i--) in memblock_cap_memory_range()
1673 if (!memblock_is_nomap(&memblock.memory.regions[i])) in memblock_cap_memory_range()
1674 memblock_remove_region(&memblock.memory, i); in memblock_cap_memory_range()
1691 /* @limit exceeds the total size of the memory, do nothing */ in memblock_mem_limit_remove_map()
1700 unsigned int left = 0, right = type->cnt; in memblock_search()
1705 if (addr < type->regions[mid].base) in memblock_search()
1707 else if (addr >= (type->regions[mid].base + in memblock_search()
1708 type->regions[mid].size)) in memblock_search()
1713 return -1; in memblock_search()
1718 return memblock_search(&memblock.reserved, addr) != -1; in memblock_is_reserved()
1723 return memblock_search(&memblock.memory, addr) != -1; in memblock_is_memory()
1728 int i = memblock_search(&memblock.memory, addr); in memblock_is_map_memory()
1730 if (i == -1) in memblock_is_map_memory()
1732 return !memblock_is_nomap(&memblock.memory.regions[i]); in memblock_is_map_memory()
1739 struct memblock_type *type = &memblock.memory; in memblock_search_pfn_nid()
1742 if (mid == -1) in memblock_search_pfn_nid()
1743 return -1; in memblock_search_pfn_nid()
1745 *start_pfn = PFN_DOWN(type->regions[mid].base); in memblock_search_pfn_nid()
1746 *end_pfn = PFN_DOWN(type->regions[mid].base + type->regions[mid].size); in memblock_search_pfn_nid()
1748 return type->regions[mid].nid; in memblock_search_pfn_nid()
1753 * memblock_is_region_memory - check if a region is a subset of memory
1754 * @base: base of region to check
1755 * @size: size of region to check
1757 * Check if the region [@base, @base + @size) is a subset of a memory block.
1760 * 0 if false, non-zero if true
1764 int idx = memblock_search(&memblock.memory, base); in memblock_is_region_memory()
1767 if (idx == -1) in memblock_is_region_memory()
1769 return (memblock.memory.regions[idx].base + in memblock_is_region_memory()
1770 memblock.memory.regions[idx].size) >= end; in memblock_is_region_memory()
1774 * memblock_is_region_reserved - check if a region intersects reserved memory
1775 * @base: base of region to check
1776 * @size: size of region to check
1778 * Check if the region [@base, @base + @size) intersects a reserved
1779 * memory block.
1795 for_each_memblock(memory, r) { in memblock_trim_memory()
1796 orig_start = r->base; in memblock_trim_memory()
1797 orig_end = r->base + r->size; in memblock_trim_memory()
1805 r->base = start; in memblock_trim_memory()
1806 r->size = end - start; in memblock_trim_memory()
1808 memblock_remove_region(&memblock.memory, in memblock_trim_memory()
1809 r - memblock.memory.regions); in memblock_trim_memory()
1810 r--; in memblock_trim_memory()
1832 pr_info(" %s.cnt = 0x%lx\n", type->name, type->cnt); in memblock_dump()
1837 base = rgn->base; in memblock_dump()
1838 size = rgn->size; in memblock_dump()
1839 end = base + size - 1; in memblock_dump()
1840 flags = rgn->flags; in memblock_dump()
1846 pr_info(" %s[%#x]\t[%pa-%pa], %pa bytes%s flags: %#x\n", in memblock_dump()
1847 type->name, idx, &base, &end, &size, nid_buf, flags); in memblock_dump()
1854 pr_info(" memory size = %pa reserved size = %pa\n", in __memblock_dump_all()
1855 &memblock.memory.total_size, in __memblock_dump_all()
1858 memblock_dump(&memblock.memory); in __memblock_dump_all()
1882 struct memblock_type *type = m->private; in memblock_debug_show()
1887 for (i = 0; i < type->cnt; i++) { in memblock_debug_show()
1888 reg = &type->regions[i]; in memblock_debug_show()
1889 end = reg->base + reg->size - 1; in memblock_debug_show()
1892 seq_printf(m, "%pa..%pa\n", ®->base, &end); in memblock_debug_show()
1902 return -ENXIO; in memblock_init_debugfs()
1903 debugfs_create_file("memory", 0444, root, in memblock_init_debugfs()
1904 &memblock.memory, &memblock_debug_fops); in memblock_init_debugfs()