1#ifndef _LINUX_MEMBLOCK_H 2#define _LINUX_MEMBLOCK_H 3#ifdef __KERNEL__ 4 5#ifdef CONFIG_HAVE_MEMBLOCK 6/* 7 * Logical memory blocks. 8 * 9 * Copyright (C) 2001 Peter Bergner, IBM Corp. 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License 13 * as published by the Free Software Foundation; either version 14 * 2 of the License, or (at your option) any later version. 15 */ 16 17#include <linux/init.h> 18#include <linux/mm.h> 19 20#define INIT_MEMBLOCK_REGIONS 128 21#define INIT_PHYSMEM_REGIONS 4 22 23/* Definition of memblock flags. */ 24#define MEMBLOCK_HOTPLUG 0x1 /* hotpluggable region */ 25 26struct memblock_region { 27 phys_addr_t base; 28 phys_addr_t size; 29 unsigned long flags; 30#ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP 31 int nid; 32#endif 33}; 34 35struct memblock_type { 36 unsigned long cnt; /* number of regions */ 37 unsigned long max; /* size of the allocated array */ 38 phys_addr_t total_size; /* size of all regions */ 39 struct memblock_region *regions; 40}; 41 42struct memblock { 43 bool bottom_up; /* is bottom up direction? */ 44 phys_addr_t current_limit; 45 struct memblock_type memory; 46 struct memblock_type reserved; 47#ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP 48 struct memblock_type physmem; 49#endif 50}; 51 52extern struct memblock memblock; 53extern int memblock_debug; 54#ifdef CONFIG_MOVABLE_NODE 55/* If movable_node boot option specified */ 56extern bool movable_node_enabled; 57#endif /* CONFIG_MOVABLE_NODE */ 58 59#define memblock_dbg(fmt, ...) \ 60 if (memblock_debug) printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__) 61 62phys_addr_t memblock_find_in_range_node(phys_addr_t size, phys_addr_t align, 63 phys_addr_t start, phys_addr_t end, 64 int nid); 65phys_addr_t memblock_find_in_range(phys_addr_t start, phys_addr_t end, 66 phys_addr_t size, phys_addr_t align); 67phys_addr_t get_allocated_memblock_reserved_regions_info(phys_addr_t *addr); 68phys_addr_t get_allocated_memblock_memory_regions_info(phys_addr_t *addr); 69void memblock_allow_resize(void); 70int memblock_add_node(phys_addr_t base, phys_addr_t size, int nid); 71int memblock_add(phys_addr_t base, phys_addr_t size); 72int memblock_remove(phys_addr_t base, phys_addr_t size); 73int memblock_free(phys_addr_t base, phys_addr_t size); 74int memblock_reserve(phys_addr_t base, phys_addr_t size); 75void memblock_trim_memory(phys_addr_t align); 76int memblock_mark_hotplug(phys_addr_t base, phys_addr_t size); 77int memblock_clear_hotplug(phys_addr_t base, phys_addr_t size); 78 79/* Low level functions */ 80int memblock_add_range(struct memblock_type *type, 81 phys_addr_t base, phys_addr_t size, 82 int nid, unsigned long flags); 83 84int memblock_remove_range(struct memblock_type *type, 85 phys_addr_t base, 86 phys_addr_t size); 87 88void __next_mem_range(u64 *idx, int nid, struct memblock_type *type_a, 89 struct memblock_type *type_b, phys_addr_t *out_start, 90 phys_addr_t *out_end, int *out_nid); 91 92void __next_mem_range_rev(u64 *idx, int nid, struct memblock_type *type_a, 93 struct memblock_type *type_b, phys_addr_t *out_start, 94 phys_addr_t *out_end, int *out_nid); 95 96/** 97 * for_each_mem_range - iterate through memblock areas from type_a and not 98 * included in type_b. Or just type_a if type_b is NULL. 99 * @i: u64 used as loop variable 100 * @type_a: ptr to memblock_type to iterate 101 * @type_b: ptr to memblock_type which excludes from the iteration 102 * @nid: node selector, %NUMA_NO_NODE for all nodes 103 * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL 104 * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL 105 * @p_nid: ptr to int for nid of the range, can be %NULL 106 */ 107#define for_each_mem_range(i, type_a, type_b, nid, \ 108 p_start, p_end, p_nid) \ 109 for (i = 0, __next_mem_range(&i, nid, type_a, type_b, \ 110 p_start, p_end, p_nid); \ 111 i != (u64)ULLONG_MAX; \ 112 __next_mem_range(&i, nid, type_a, type_b, \ 113 p_start, p_end, p_nid)) 114 115/** 116 * for_each_mem_range_rev - reverse iterate through memblock areas from 117 * type_a and not included in type_b. Or just type_a if type_b is NULL. 118 * @i: u64 used as loop variable 119 * @type_a: ptr to memblock_type to iterate 120 * @type_b: ptr to memblock_type which excludes from the iteration 121 * @nid: node selector, %NUMA_NO_NODE for all nodes 122 * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL 123 * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL 124 * @p_nid: ptr to int for nid of the range, can be %NULL 125 */ 126#define for_each_mem_range_rev(i, type_a, type_b, nid, \ 127 p_start, p_end, p_nid) \ 128 for (i = (u64)ULLONG_MAX, \ 129 __next_mem_range_rev(&i, nid, type_a, type_b, \ 130 p_start, p_end, p_nid); \ 131 i != (u64)ULLONG_MAX; \ 132 __next_mem_range_rev(&i, nid, type_a, type_b, \ 133 p_start, p_end, p_nid)) 134 135#ifdef CONFIG_MOVABLE_NODE 136static inline bool memblock_is_hotpluggable(struct memblock_region *m) 137{ 138 return m->flags & MEMBLOCK_HOTPLUG; 139} 140 141static inline bool movable_node_is_enabled(void) 142{ 143 return movable_node_enabled; 144} 145#else 146static inline bool memblock_is_hotpluggable(struct memblock_region *m) 147{ 148 return false; 149} 150static inline bool movable_node_is_enabled(void) 151{ 152 return false; 153} 154#endif 155 156#ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP 157int memblock_search_pfn_nid(unsigned long pfn, unsigned long *start_pfn, 158 unsigned long *end_pfn); 159void __next_mem_pfn_range(int *idx, int nid, unsigned long *out_start_pfn, 160 unsigned long *out_end_pfn, int *out_nid); 161 162/** 163 * for_each_mem_pfn_range - early memory pfn range iterator 164 * @i: an integer used as loop variable 165 * @nid: node selector, %MAX_NUMNODES for all nodes 166 * @p_start: ptr to ulong for start pfn of the range, can be %NULL 167 * @p_end: ptr to ulong for end pfn of the range, can be %NULL 168 * @p_nid: ptr to int for nid of the range, can be %NULL 169 * 170 * Walks over configured memory ranges. 171 */ 172#define for_each_mem_pfn_range(i, nid, p_start, p_end, p_nid) \ 173 for (i = -1, __next_mem_pfn_range(&i, nid, p_start, p_end, p_nid); \ 174 i >= 0; __next_mem_pfn_range(&i, nid, p_start, p_end, p_nid)) 175#endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */ 176 177/** 178 * for_each_free_mem_range - iterate through free memblock areas 179 * @i: u64 used as loop variable 180 * @nid: node selector, %NUMA_NO_NODE for all nodes 181 * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL 182 * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL 183 * @p_nid: ptr to int for nid of the range, can be %NULL 184 * 185 * Walks over free (memory && !reserved) areas of memblock. Available as 186 * soon as memblock is initialized. 187 */ 188#define for_each_free_mem_range(i, nid, p_start, p_end, p_nid) \ 189 for_each_mem_range(i, &memblock.memory, &memblock.reserved, \ 190 nid, p_start, p_end, p_nid) 191 192/** 193 * for_each_free_mem_range_reverse - rev-iterate through free memblock areas 194 * @i: u64 used as loop variable 195 * @nid: node selector, %NUMA_NO_NODE for all nodes 196 * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL 197 * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL 198 * @p_nid: ptr to int for nid of the range, can be %NULL 199 * 200 * Walks over free (memory && !reserved) areas of memblock in reverse 201 * order. Available as soon as memblock is initialized. 202 */ 203#define for_each_free_mem_range_reverse(i, nid, p_start, p_end, p_nid) \ 204 for_each_mem_range_rev(i, &memblock.memory, &memblock.reserved, \ 205 nid, p_start, p_end, p_nid) 206 207static inline void memblock_set_region_flags(struct memblock_region *r, 208 unsigned long flags) 209{ 210 r->flags |= flags; 211} 212 213static inline void memblock_clear_region_flags(struct memblock_region *r, 214 unsigned long flags) 215{ 216 r->flags &= ~flags; 217} 218 219#ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP 220int memblock_set_node(phys_addr_t base, phys_addr_t size, 221 struct memblock_type *type, int nid); 222 223static inline void memblock_set_region_node(struct memblock_region *r, int nid) 224{ 225 r->nid = nid; 226} 227 228static inline int memblock_get_region_node(const struct memblock_region *r) 229{ 230 return r->nid; 231} 232#else 233static inline void memblock_set_region_node(struct memblock_region *r, int nid) 234{ 235} 236 237static inline int memblock_get_region_node(const struct memblock_region *r) 238{ 239 return 0; 240} 241#endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */ 242 243phys_addr_t memblock_alloc_nid(phys_addr_t size, phys_addr_t align, int nid); 244phys_addr_t memblock_alloc_try_nid(phys_addr_t size, phys_addr_t align, int nid); 245 246phys_addr_t memblock_alloc(phys_addr_t size, phys_addr_t align); 247 248#ifdef CONFIG_MOVABLE_NODE 249/* 250 * Set the allocation direction to bottom-up or top-down. 251 */ 252static inline void __init memblock_set_bottom_up(bool enable) 253{ 254 memblock.bottom_up = enable; 255} 256 257/* 258 * Check if the allocation direction is bottom-up or not. 259 * if this is true, that said, memblock will allocate memory 260 * in bottom-up direction. 261 */ 262static inline bool memblock_bottom_up(void) 263{ 264 return memblock.bottom_up; 265} 266#else 267static inline void __init memblock_set_bottom_up(bool enable) {} 268static inline bool memblock_bottom_up(void) { return false; } 269#endif 270 271/* Flags for memblock_alloc_base() amd __memblock_alloc_base() */ 272#define MEMBLOCK_ALLOC_ANYWHERE (~(phys_addr_t)0) 273#define MEMBLOCK_ALLOC_ACCESSIBLE 0 274 275phys_addr_t __init memblock_alloc_range(phys_addr_t size, phys_addr_t align, 276 phys_addr_t start, phys_addr_t end); 277phys_addr_t memblock_alloc_base(phys_addr_t size, phys_addr_t align, 278 phys_addr_t max_addr); 279phys_addr_t __memblock_alloc_base(phys_addr_t size, phys_addr_t align, 280 phys_addr_t max_addr); 281phys_addr_t memblock_phys_mem_size(void); 282phys_addr_t memblock_mem_size(unsigned long limit_pfn); 283phys_addr_t memblock_start_of_DRAM(void); 284phys_addr_t memblock_end_of_DRAM(void); 285void memblock_enforce_memory_limit(phys_addr_t memory_limit); 286int memblock_is_memory(phys_addr_t addr); 287int memblock_is_region_memory(phys_addr_t base, phys_addr_t size); 288int memblock_is_reserved(phys_addr_t addr); 289int memblock_is_region_reserved(phys_addr_t base, phys_addr_t size); 290 291extern void __memblock_dump_all(void); 292 293static inline void memblock_dump_all(void) 294{ 295 if (memblock_debug) 296 __memblock_dump_all(); 297} 298 299/** 300 * memblock_set_current_limit - Set the current allocation limit to allow 301 * limiting allocations to what is currently 302 * accessible during boot 303 * @limit: New limit value (physical address) 304 */ 305void memblock_set_current_limit(phys_addr_t limit); 306 307 308phys_addr_t memblock_get_current_limit(void); 309 310/* 311 * pfn conversion functions 312 * 313 * While the memory MEMBLOCKs should always be page aligned, the reserved 314 * MEMBLOCKs may not be. This accessor attempt to provide a very clear 315 * idea of what they return for such non aligned MEMBLOCKs. 316 */ 317 318/** 319 * memblock_region_memory_base_pfn - Return the lowest pfn intersecting with the memory region 320 * @reg: memblock_region structure 321 */ 322static inline unsigned long memblock_region_memory_base_pfn(const struct memblock_region *reg) 323{ 324 return PFN_UP(reg->base); 325} 326 327/** 328 * memblock_region_memory_end_pfn - Return the end_pfn this region 329 * @reg: memblock_region structure 330 */ 331static inline unsigned long memblock_region_memory_end_pfn(const struct memblock_region *reg) 332{ 333 return PFN_DOWN(reg->base + reg->size); 334} 335 336/** 337 * memblock_region_reserved_base_pfn - Return the lowest pfn intersecting with the reserved region 338 * @reg: memblock_region structure 339 */ 340static inline unsigned long memblock_region_reserved_base_pfn(const struct memblock_region *reg) 341{ 342 return PFN_DOWN(reg->base); 343} 344 345/** 346 * memblock_region_reserved_end_pfn - Return the end_pfn this region 347 * @reg: memblock_region structure 348 */ 349static inline unsigned long memblock_region_reserved_end_pfn(const struct memblock_region *reg) 350{ 351 return PFN_UP(reg->base + reg->size); 352} 353 354#define for_each_memblock(memblock_type, region) \ 355 for (region = memblock.memblock_type.regions; \ 356 region < (memblock.memblock_type.regions + memblock.memblock_type.cnt); \ 357 region++) 358 359 360#ifdef CONFIG_ARCH_DISCARD_MEMBLOCK 361#define __init_memblock __meminit 362#define __initdata_memblock __meminitdata 363#else 364#define __init_memblock 365#define __initdata_memblock 366#endif 367 368#ifdef CONFIG_MEMTEST 369extern void early_memtest(phys_addr_t start, phys_addr_t end); 370#else 371static inline void early_memtest(phys_addr_t start, phys_addr_t end) 372{ 373} 374#endif 375 376#else 377static inline phys_addr_t memblock_alloc(phys_addr_t size, phys_addr_t align) 378{ 379 return 0; 380} 381 382#endif /* CONFIG_HAVE_MEMBLOCK */ 383 384#endif /* __KERNEL__ */ 385 386#endif /* _LINUX_MEMBLOCK_H */ 387