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 enum { 25 MEMBLOCK_NONE = 0x0, /* No special request */ 26 MEMBLOCK_HOTPLUG = 0x1, /* hotpluggable region */ 27 MEMBLOCK_MIRROR = 0x2, /* mirrored region */ 28 MEMBLOCK_NOMAP = 0x4, /* don't add to kernel direct mapping */ 29 }; 30 31 struct memblock_region { 32 phys_addr_t base; 33 phys_addr_t size; 34 unsigned long flags; 35 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP 36 int nid; 37 #endif 38 }; 39 40 struct memblock_type { 41 unsigned long cnt; /* number of regions */ 42 unsigned long max; /* size of the allocated array */ 43 phys_addr_t total_size; /* size of all regions */ 44 struct memblock_region *regions; 45 char *name; 46 }; 47 48 struct memblock { 49 bool bottom_up; /* is bottom up direction? */ 50 phys_addr_t current_limit; 51 struct memblock_type memory; 52 struct memblock_type reserved; 53 #ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP 54 struct memblock_type physmem; 55 #endif 56 }; 57 58 extern struct memblock memblock; 59 extern int memblock_debug; 60 #ifdef CONFIG_MOVABLE_NODE 61 /* If movable_node boot option specified */ 62 extern bool movable_node_enabled; 63 #endif /* CONFIG_MOVABLE_NODE */ 64 65 #ifdef CONFIG_ARCH_DISCARD_MEMBLOCK 66 #define __init_memblock __meminit 67 #define __initdata_memblock __meminitdata 68 #else 69 #define __init_memblock 70 #define __initdata_memblock 71 #endif 72 73 #define memblock_dbg(fmt, ...) \ 74 if (memblock_debug) printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__) 75 76 phys_addr_t memblock_find_in_range_node(phys_addr_t size, phys_addr_t align, 77 phys_addr_t start, phys_addr_t end, 78 int nid, ulong flags); 79 phys_addr_t memblock_find_in_range(phys_addr_t start, phys_addr_t end, 80 phys_addr_t size, phys_addr_t align); 81 phys_addr_t get_allocated_memblock_reserved_regions_info(phys_addr_t *addr); 82 phys_addr_t get_allocated_memblock_memory_regions_info(phys_addr_t *addr); 83 void memblock_allow_resize(void); 84 int memblock_add_node(phys_addr_t base, phys_addr_t size, int nid); 85 int memblock_add(phys_addr_t base, phys_addr_t size); 86 int memblock_remove(phys_addr_t base, phys_addr_t size); 87 int memblock_free(phys_addr_t base, phys_addr_t size); 88 int memblock_reserve(phys_addr_t base, phys_addr_t size); 89 void memblock_trim_memory(phys_addr_t align); 90 bool memblock_overlaps_region(struct memblock_type *type, 91 phys_addr_t base, phys_addr_t size); 92 int memblock_mark_hotplug(phys_addr_t base, phys_addr_t size); 93 int memblock_clear_hotplug(phys_addr_t base, phys_addr_t size); 94 int memblock_mark_mirror(phys_addr_t base, phys_addr_t size); 95 int memblock_mark_nomap(phys_addr_t base, phys_addr_t size); 96 int memblock_clear_nomap(phys_addr_t base, phys_addr_t size); 97 ulong choose_memblock_flags(void); 98 99 /* Low level functions */ 100 int memblock_add_range(struct memblock_type *type, 101 phys_addr_t base, phys_addr_t size, 102 int nid, unsigned long flags); 103 104 void __next_mem_range(u64 *idx, int nid, ulong flags, 105 struct memblock_type *type_a, 106 struct memblock_type *type_b, phys_addr_t *out_start, 107 phys_addr_t *out_end, int *out_nid); 108 109 void __next_mem_range_rev(u64 *idx, int nid, ulong flags, 110 struct memblock_type *type_a, 111 struct memblock_type *type_b, phys_addr_t *out_start, 112 phys_addr_t *out_end, int *out_nid); 113 114 void __next_reserved_mem_region(u64 *idx, phys_addr_t *out_start, 115 phys_addr_t *out_end); 116 117 /** 118 * for_each_mem_range - iterate through memblock areas from type_a and not 119 * included in type_b. Or just type_a if type_b is NULL. 120 * @i: u64 used as loop variable 121 * @type_a: ptr to memblock_type to iterate 122 * @type_b: ptr to memblock_type which excludes from the iteration 123 * @nid: node selector, %NUMA_NO_NODE for all nodes 124 * @flags: pick from blocks based on memory attributes 125 * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL 126 * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL 127 * @p_nid: ptr to int for nid of the range, can be %NULL 128 */ 129 #define for_each_mem_range(i, type_a, type_b, nid, flags, \ 130 p_start, p_end, p_nid) \ 131 for (i = 0, __next_mem_range(&i, nid, flags, type_a, type_b, \ 132 p_start, p_end, p_nid); \ 133 i != (u64)ULLONG_MAX; \ 134 __next_mem_range(&i, nid, flags, type_a, type_b, \ 135 p_start, p_end, p_nid)) 136 137 /** 138 * for_each_mem_range_rev - reverse iterate through memblock areas from 139 * type_a and not included in type_b. Or just type_a if type_b is NULL. 140 * @i: u64 used as loop variable 141 * @type_a: ptr to memblock_type to iterate 142 * @type_b: ptr to memblock_type which excludes from the iteration 143 * @nid: node selector, %NUMA_NO_NODE for all nodes 144 * @flags: pick from blocks based on memory attributes 145 * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL 146 * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL 147 * @p_nid: ptr to int for nid of the range, can be %NULL 148 */ 149 #define for_each_mem_range_rev(i, type_a, type_b, nid, flags, \ 150 p_start, p_end, p_nid) \ 151 for (i = (u64)ULLONG_MAX, \ 152 __next_mem_range_rev(&i, nid, flags, type_a, type_b,\ 153 p_start, p_end, p_nid); \ 154 i != (u64)ULLONG_MAX; \ 155 __next_mem_range_rev(&i, nid, flags, type_a, type_b, \ 156 p_start, p_end, p_nid)) 157 158 /** 159 * for_each_reserved_mem_region - iterate over all reserved memblock areas 160 * @i: u64 used as loop variable 161 * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL 162 * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL 163 * 164 * Walks over reserved areas of memblock. Available as soon as memblock 165 * is initialized. 166 */ 167 #define for_each_reserved_mem_region(i, p_start, p_end) \ 168 for (i = 0UL, __next_reserved_mem_region(&i, p_start, p_end); \ 169 i != (u64)ULLONG_MAX; \ 170 __next_reserved_mem_region(&i, p_start, p_end)) 171 172 #ifdef CONFIG_MOVABLE_NODE 173 static inline bool memblock_is_hotpluggable(struct memblock_region *m) 174 { 175 return m->flags & MEMBLOCK_HOTPLUG; 176 } 177 178 static inline bool __init_memblock movable_node_is_enabled(void) 179 { 180 return movable_node_enabled; 181 } 182 #else 183 static inline bool memblock_is_hotpluggable(struct memblock_region *m) 184 { 185 return false; 186 } 187 static inline bool movable_node_is_enabled(void) 188 { 189 return false; 190 } 191 #endif 192 193 static inline bool memblock_is_mirror(struct memblock_region *m) 194 { 195 return m->flags & MEMBLOCK_MIRROR; 196 } 197 198 static inline bool memblock_is_nomap(struct memblock_region *m) 199 { 200 return m->flags & MEMBLOCK_NOMAP; 201 } 202 203 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP 204 int memblock_search_pfn_nid(unsigned long pfn, unsigned long *start_pfn, 205 unsigned long *end_pfn); 206 void __next_mem_pfn_range(int *idx, int nid, unsigned long *out_start_pfn, 207 unsigned long *out_end_pfn, int *out_nid); 208 unsigned long memblock_next_valid_pfn(unsigned long pfn, unsigned long max_pfn); 209 210 /** 211 * for_each_mem_pfn_range - early memory pfn range iterator 212 * @i: an integer used as loop variable 213 * @nid: node selector, %MAX_NUMNODES for all nodes 214 * @p_start: ptr to ulong for start pfn of the range, can be %NULL 215 * @p_end: ptr to ulong for end pfn of the range, can be %NULL 216 * @p_nid: ptr to int for nid of the range, can be %NULL 217 * 218 * Walks over configured memory ranges. 219 */ 220 #define for_each_mem_pfn_range(i, nid, p_start, p_end, p_nid) \ 221 for (i = -1, __next_mem_pfn_range(&i, nid, p_start, p_end, p_nid); \ 222 i >= 0; __next_mem_pfn_range(&i, nid, p_start, p_end, p_nid)) 223 #endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */ 224 225 /** 226 * for_each_free_mem_range - iterate through free memblock areas 227 * @i: u64 used as loop variable 228 * @nid: node selector, %NUMA_NO_NODE for all nodes 229 * @flags: pick from blocks based on memory attributes 230 * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL 231 * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL 232 * @p_nid: ptr to int for nid of the range, can be %NULL 233 * 234 * Walks over free (memory && !reserved) areas of memblock. Available as 235 * soon as memblock is initialized. 236 */ 237 #define for_each_free_mem_range(i, nid, flags, p_start, p_end, p_nid) \ 238 for_each_mem_range(i, &memblock.memory, &memblock.reserved, \ 239 nid, flags, p_start, p_end, p_nid) 240 241 /** 242 * for_each_free_mem_range_reverse - rev-iterate through free memblock areas 243 * @i: u64 used as loop variable 244 * @nid: node selector, %NUMA_NO_NODE for all nodes 245 * @flags: pick from blocks based on memory attributes 246 * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL 247 * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL 248 * @p_nid: ptr to int for nid of the range, can be %NULL 249 * 250 * Walks over free (memory && !reserved) areas of memblock in reverse 251 * order. Available as soon as memblock is initialized. 252 */ 253 #define for_each_free_mem_range_reverse(i, nid, flags, p_start, p_end, \ 254 p_nid) \ 255 for_each_mem_range_rev(i, &memblock.memory, &memblock.reserved, \ 256 nid, flags, p_start, p_end, p_nid) 257 258 static inline void memblock_set_region_flags(struct memblock_region *r, 259 unsigned long flags) 260 { 261 r->flags |= flags; 262 } 263 264 static inline void memblock_clear_region_flags(struct memblock_region *r, 265 unsigned long flags) 266 { 267 r->flags &= ~flags; 268 } 269 270 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP 271 int memblock_set_node(phys_addr_t base, phys_addr_t size, 272 struct memblock_type *type, int nid); 273 274 static inline void memblock_set_region_node(struct memblock_region *r, int nid) 275 { 276 r->nid = nid; 277 } 278 279 static inline int memblock_get_region_node(const struct memblock_region *r) 280 { 281 return r->nid; 282 } 283 #else 284 static inline void memblock_set_region_node(struct memblock_region *r, int nid) 285 { 286 } 287 288 static inline int memblock_get_region_node(const struct memblock_region *r) 289 { 290 return 0; 291 } 292 #endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */ 293 294 phys_addr_t memblock_alloc_nid(phys_addr_t size, phys_addr_t align, int nid); 295 phys_addr_t memblock_alloc_try_nid(phys_addr_t size, phys_addr_t align, int nid); 296 297 phys_addr_t memblock_alloc(phys_addr_t size, phys_addr_t align); 298 299 #ifdef CONFIG_MOVABLE_NODE 300 /* 301 * Set the allocation direction to bottom-up or top-down. 302 */ 303 static inline void __init memblock_set_bottom_up(bool enable) 304 { 305 memblock.bottom_up = enable; 306 } 307 308 /* 309 * Check if the allocation direction is bottom-up or not. 310 * if this is true, that said, memblock will allocate memory 311 * in bottom-up direction. 312 */ 313 static inline bool memblock_bottom_up(void) 314 { 315 return memblock.bottom_up; 316 } 317 #else 318 static inline void __init memblock_set_bottom_up(bool enable) {} 319 static inline bool memblock_bottom_up(void) { return false; } 320 #endif 321 322 /* Flags for memblock_alloc_base() amd __memblock_alloc_base() */ 323 #define MEMBLOCK_ALLOC_ANYWHERE (~(phys_addr_t)0) 324 #define MEMBLOCK_ALLOC_ACCESSIBLE 0 325 326 phys_addr_t __init memblock_alloc_range(phys_addr_t size, phys_addr_t align, 327 phys_addr_t start, phys_addr_t end, 328 ulong flags); 329 phys_addr_t memblock_alloc_base(phys_addr_t size, phys_addr_t align, 330 phys_addr_t max_addr); 331 phys_addr_t __memblock_alloc_base(phys_addr_t size, phys_addr_t align, 332 phys_addr_t max_addr); 333 phys_addr_t memblock_phys_mem_size(void); 334 phys_addr_t memblock_reserved_size(void); 335 phys_addr_t memblock_mem_size(unsigned long limit_pfn); 336 phys_addr_t memblock_start_of_DRAM(void); 337 phys_addr_t memblock_end_of_DRAM(void); 338 void memblock_enforce_memory_limit(phys_addr_t memory_limit); 339 void memblock_cap_memory_range(phys_addr_t base, phys_addr_t size); 340 void memblock_mem_limit_remove_map(phys_addr_t limit); 341 bool memblock_is_memory(phys_addr_t addr); 342 int memblock_is_map_memory(phys_addr_t addr); 343 int memblock_is_region_memory(phys_addr_t base, phys_addr_t size); 344 bool memblock_is_reserved(phys_addr_t addr); 345 bool memblock_is_region_reserved(phys_addr_t base, phys_addr_t size); 346 347 extern void __memblock_dump_all(void); 348 349 static inline void memblock_dump_all(void) 350 { 351 if (memblock_debug) 352 __memblock_dump_all(); 353 } 354 355 /** 356 * memblock_set_current_limit - Set the current allocation limit to allow 357 * limiting allocations to what is currently 358 * accessible during boot 359 * @limit: New limit value (physical address) 360 */ 361 void memblock_set_current_limit(phys_addr_t limit); 362 363 364 phys_addr_t memblock_get_current_limit(void); 365 366 /* 367 * pfn conversion functions 368 * 369 * While the memory MEMBLOCKs should always be page aligned, the reserved 370 * MEMBLOCKs may not be. This accessor attempt to provide a very clear 371 * idea of what they return for such non aligned MEMBLOCKs. 372 */ 373 374 /** 375 * memblock_region_memory_base_pfn - Return the lowest pfn intersecting with the memory region 376 * @reg: memblock_region structure 377 */ 378 static inline unsigned long memblock_region_memory_base_pfn(const struct memblock_region *reg) 379 { 380 return PFN_UP(reg->base); 381 } 382 383 /** 384 * memblock_region_memory_end_pfn - Return the end_pfn this region 385 * @reg: memblock_region structure 386 */ 387 static inline unsigned long memblock_region_memory_end_pfn(const struct memblock_region *reg) 388 { 389 return PFN_DOWN(reg->base + reg->size); 390 } 391 392 /** 393 * memblock_region_reserved_base_pfn - Return the lowest pfn intersecting with the reserved region 394 * @reg: memblock_region structure 395 */ 396 static inline unsigned long memblock_region_reserved_base_pfn(const struct memblock_region *reg) 397 { 398 return PFN_DOWN(reg->base); 399 } 400 401 /** 402 * memblock_region_reserved_end_pfn - Return the end_pfn this region 403 * @reg: memblock_region structure 404 */ 405 static inline unsigned long memblock_region_reserved_end_pfn(const struct memblock_region *reg) 406 { 407 return PFN_UP(reg->base + reg->size); 408 } 409 410 #define for_each_memblock(memblock_type, region) \ 411 for (region = memblock.memblock_type.regions; \ 412 region < (memblock.memblock_type.regions + memblock.memblock_type.cnt); \ 413 region++) 414 415 #define for_each_memblock_type(memblock_type, rgn) \ 416 for (idx = 0, rgn = &memblock_type->regions[0]; \ 417 idx < memblock_type->cnt; \ 418 idx++, rgn = &memblock_type->regions[idx]) 419 420 #ifdef CONFIG_MEMTEST 421 extern void early_memtest(phys_addr_t start, phys_addr_t end); 422 #else 423 static inline void early_memtest(phys_addr_t start, phys_addr_t end) 424 { 425 } 426 #endif 427 428 extern unsigned long memblock_reserved_memory_within(phys_addr_t start_addr, 429 phys_addr_t end_addr); 430 #else 431 static inline phys_addr_t memblock_alloc(phys_addr_t size, phys_addr_t align) 432 { 433 return 0; 434 } 435 436 static inline unsigned long memblock_reserved_memory_within(phys_addr_t start_addr, 437 phys_addr_t end_addr) 438 { 439 return 0; 440 } 441 442 #endif /* CONFIG_HAVE_MEMBLOCK */ 443 444 #endif /* __KERNEL__ */ 445 446 #endif /* _LINUX_MEMBLOCK_H */ 447