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 26 struct 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 35 struct 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 42 struct 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 52 extern struct memblock memblock; 53 extern int memblock_debug; 54 #ifdef CONFIG_MOVABLE_NODE 55 /* If movable_node boot option specified */ 56 extern 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 62 phys_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); 65 phys_addr_t memblock_find_in_range(phys_addr_t start, phys_addr_t end, 66 phys_addr_t size, phys_addr_t align); 67 phys_addr_t get_allocated_memblock_reserved_regions_info(phys_addr_t *addr); 68 phys_addr_t get_allocated_memblock_memory_regions_info(phys_addr_t *addr); 69 void memblock_allow_resize(void); 70 int memblock_add_node(phys_addr_t base, phys_addr_t size, int nid); 71 int memblock_add(phys_addr_t base, phys_addr_t size); 72 int memblock_remove(phys_addr_t base, phys_addr_t size); 73 int memblock_free(phys_addr_t base, phys_addr_t size); 74 int memblock_reserve(phys_addr_t base, phys_addr_t size); 75 void memblock_trim_memory(phys_addr_t align); 76 int memblock_mark_hotplug(phys_addr_t base, phys_addr_t size); 77 int memblock_clear_hotplug(phys_addr_t base, phys_addr_t size); 78 79 /* Low level functions */ 80 int memblock_add_range(struct memblock_type *type, 81 phys_addr_t base, phys_addr_t size, 82 int nid, unsigned long flags); 83 84 int memblock_remove_range(struct memblock_type *type, 85 phys_addr_t base, 86 phys_addr_t size); 87 88 void __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 92 void __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 136 static inline bool memblock_is_hotpluggable(struct memblock_region *m) 137 { 138 return m->flags & MEMBLOCK_HOTPLUG; 139 } 140 141 static inline bool movable_node_is_enabled(void) 142 { 143 return movable_node_enabled; 144 } 145 #else 146 static inline bool memblock_is_hotpluggable(struct memblock_region *m) 147 { 148 return false; 149 } 150 static inline bool movable_node_is_enabled(void) 151 { 152 return false; 153 } 154 #endif 155 156 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP 157 int memblock_search_pfn_nid(unsigned long pfn, unsigned long *start_pfn, 158 unsigned long *end_pfn); 159 void __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 207 static inline void memblock_set_region_flags(struct memblock_region *r, 208 unsigned long flags) 209 { 210 r->flags |= flags; 211 } 212 213 static 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 220 int memblock_set_node(phys_addr_t base, phys_addr_t size, 221 struct memblock_type *type, int nid); 222 223 static inline void memblock_set_region_node(struct memblock_region *r, int nid) 224 { 225 r->nid = nid; 226 } 227 228 static inline int memblock_get_region_node(const struct memblock_region *r) 229 { 230 return r->nid; 231 } 232 #else 233 static inline void memblock_set_region_node(struct memblock_region *r, int nid) 234 { 235 } 236 237 static inline int memblock_get_region_node(const struct memblock_region *r) 238 { 239 return 0; 240 } 241 #endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */ 242 243 phys_addr_t memblock_alloc_nid(phys_addr_t size, phys_addr_t align, int nid); 244 phys_addr_t memblock_alloc_try_nid(phys_addr_t size, phys_addr_t align, int nid); 245 246 phys_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 */ 252 static 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 */ 262 static inline bool memblock_bottom_up(void) 263 { 264 return memblock.bottom_up; 265 } 266 #else 267 static inline void __init memblock_set_bottom_up(bool enable) {} 268 static 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 275 phys_addr_t __init memblock_alloc_range(phys_addr_t size, phys_addr_t align, 276 phys_addr_t start, phys_addr_t end); 277 phys_addr_t memblock_alloc_base(phys_addr_t size, phys_addr_t align, 278 phys_addr_t max_addr); 279 phys_addr_t __memblock_alloc_base(phys_addr_t size, phys_addr_t align, 280 phys_addr_t max_addr); 281 phys_addr_t memblock_phys_mem_size(void); 282 phys_addr_t memblock_mem_size(unsigned long limit_pfn); 283 phys_addr_t memblock_start_of_DRAM(void); 284 phys_addr_t memblock_end_of_DRAM(void); 285 void memblock_enforce_memory_limit(phys_addr_t memory_limit); 286 int memblock_is_memory(phys_addr_t addr); 287 int memblock_is_region_memory(phys_addr_t base, phys_addr_t size); 288 int memblock_is_reserved(phys_addr_t addr); 289 int memblock_is_region_reserved(phys_addr_t base, phys_addr_t size); 290 291 extern void __memblock_dump_all(void); 292 293 static 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 */ 305 void memblock_set_current_limit(phys_addr_t limit); 306 307 308 phys_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 */ 322 static 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 */ 331 static 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 */ 340 static 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 */ 349 static 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 #else 369 static inline phys_addr_t memblock_alloc(phys_addr_t size, phys_addr_t align) 370 { 371 return 0; 372 } 373 374 #endif /* CONFIG_HAVE_MEMBLOCK */ 375 376 #endif /* __KERNEL__ */ 377 378 #endif /* _LINUX_MEMBLOCK_H */ 379