2 * Procedures for maintaining information about logical memory blocks.
4 * Peter Bergner, IBM Corp. June 2001.
5 * Copyright (C) 2001 Peter Bergner.
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
13 #include <linux/kernel.h>
14 #include <linux/init.h>
15 #include <linux/bitops.h>
16 #include <linux/memblock.h>
18 #define MEMBLOCK_ALLOC_ANYWHERE 0
20 struct memblock memblock
;
22 static int memblock_debug
;
24 static int __init
early_memblock(char *p
)
26 if (p
&& strstr(p
, "debug"))
30 early_param("memblock", early_memblock
);
32 static void memblock_dump(struct memblock_type
*region
, char *name
)
34 unsigned long long base
, size
;
37 pr_info(" %s.cnt = 0x%lx\n", name
, region
->cnt
);
39 for (i
= 0; i
< region
->cnt
; i
++) {
40 base
= region
->regions
[i
].base
;
41 size
= region
->regions
[i
].size
;
43 pr_info(" %s[0x%x]\t0x%016llx - 0x%016llx, 0x%llx bytes\n",
44 name
, i
, base
, base
+ size
- 1, size
);
48 void memblock_dump_all(void)
53 pr_info("MEMBLOCK configuration:\n");
54 pr_info(" rmo_size = 0x%llx\n", (unsigned long long)memblock
.rmo_size
);
55 pr_info(" memory.size = 0x%llx\n", (unsigned long long)memblock
.memory
.size
);
57 memblock_dump(&memblock
.memory
, "memory");
58 memblock_dump(&memblock
.reserved
, "reserved");
61 static unsigned long memblock_addrs_overlap(u64 base1
, u64 size1
, u64 base2
,
64 return ((base1
< (base2
+ size2
)) && (base2
< (base1
+ size1
)));
67 static long memblock_addrs_adjacent(u64 base1
, u64 size1
, u64 base2
, u64 size2
)
69 if (base2
== base1
+ size1
)
71 else if (base1
== base2
+ size2
)
77 static long memblock_regions_adjacent(struct memblock_type
*type
,
78 unsigned long r1
, unsigned long r2
)
80 u64 base1
= type
->regions
[r1
].base
;
81 u64 size1
= type
->regions
[r1
].size
;
82 u64 base2
= type
->regions
[r2
].base
;
83 u64 size2
= type
->regions
[r2
].size
;
85 return memblock_addrs_adjacent(base1
, size1
, base2
, size2
);
88 static void memblock_remove_region(struct memblock_type
*type
, unsigned long r
)
92 for (i
= r
; i
< type
->cnt
- 1; i
++) {
93 type
->regions
[i
].base
= type
->regions
[i
+ 1].base
;
94 type
->regions
[i
].size
= type
->regions
[i
+ 1].size
;
99 /* Assumption: base addr of region 1 < base addr of region 2 */
100 static void memblock_coalesce_regions(struct memblock_type
*type
,
101 unsigned long r1
, unsigned long r2
)
103 type
->regions
[r1
].size
+= type
->regions
[r2
].size
;
104 memblock_remove_region(type
, r2
);
107 void __init
memblock_init(void)
109 /* Create a dummy zero size MEMBLOCK which will get coalesced away later.
110 * This simplifies the memblock_add() code below...
112 memblock
.memory
.regions
[0].base
= 0;
113 memblock
.memory
.regions
[0].size
= 0;
114 memblock
.memory
.cnt
= 1;
117 memblock
.reserved
.regions
[0].base
= 0;
118 memblock
.reserved
.regions
[0].size
= 0;
119 memblock
.reserved
.cnt
= 1;
122 void __init
memblock_analyze(void)
126 memblock
.memory
.size
= 0;
128 for (i
= 0; i
< memblock
.memory
.cnt
; i
++)
129 memblock
.memory
.size
+= memblock
.memory
.regions
[i
].size
;
132 static long memblock_add_region(struct memblock_type
*type
, u64 base
, u64 size
)
134 unsigned long coalesced
= 0;
137 if ((type
->cnt
== 1) && (type
->regions
[0].size
== 0)) {
138 type
->regions
[0].base
= base
;
139 type
->regions
[0].size
= size
;
143 /* First try and coalesce this MEMBLOCK with another. */
144 for (i
= 0; i
< type
->cnt
; i
++) {
145 u64 rgnbase
= type
->regions
[i
].base
;
146 u64 rgnsize
= type
->regions
[i
].size
;
148 if ((rgnbase
== base
) && (rgnsize
== size
))
149 /* Already have this region, so we're done */
152 adjacent
= memblock_addrs_adjacent(base
, size
, rgnbase
, rgnsize
);
154 type
->regions
[i
].base
-= size
;
155 type
->regions
[i
].size
+= size
;
158 } else if (adjacent
< 0) {
159 type
->regions
[i
].size
+= size
;
165 if ((i
< type
->cnt
- 1) && memblock_regions_adjacent(type
, i
, i
+1)) {
166 memblock_coalesce_regions(type
, i
, i
+1);
172 if (type
->cnt
>= MAX_MEMBLOCK_REGIONS
)
175 /* Couldn't coalesce the MEMBLOCK, so add it to the sorted table. */
176 for (i
= type
->cnt
- 1; i
>= 0; i
--) {
177 if (base
< type
->regions
[i
].base
) {
178 type
->regions
[i
+1].base
= type
->regions
[i
].base
;
179 type
->regions
[i
+1].size
= type
->regions
[i
].size
;
181 type
->regions
[i
+1].base
= base
;
182 type
->regions
[i
+1].size
= size
;
187 if (base
< type
->regions
[0].base
) {
188 type
->regions
[0].base
= base
;
189 type
->regions
[0].size
= size
;
196 long memblock_add(u64 base
, u64 size
)
198 /* On pSeries LPAR systems, the first MEMBLOCK is our RMO region. */
200 memblock
.rmo_size
= size
;
202 return memblock_add_region(&memblock
.memory
, base
, size
);
206 static long __memblock_remove(struct memblock_type
*type
, u64 base
, u64 size
)
208 u64 rgnbegin
, rgnend
;
209 u64 end
= base
+ size
;
212 rgnbegin
= rgnend
= 0; /* supress gcc warnings */
214 /* Find the region where (base, size) belongs to */
215 for (i
=0; i
< type
->cnt
; i
++) {
216 rgnbegin
= type
->regions
[i
].base
;
217 rgnend
= rgnbegin
+ type
->regions
[i
].size
;
219 if ((rgnbegin
<= base
) && (end
<= rgnend
))
223 /* Didn't find the region */
227 /* Check to see if we are removing entire region */
228 if ((rgnbegin
== base
) && (rgnend
== end
)) {
229 memblock_remove_region(type
, i
);
233 /* Check to see if region is matching at the front */
234 if (rgnbegin
== base
) {
235 type
->regions
[i
].base
= end
;
236 type
->regions
[i
].size
-= size
;
240 /* Check to see if the region is matching at the end */
242 type
->regions
[i
].size
-= size
;
247 * We need to split the entry - adjust the current one to the
248 * beginging of the hole and add the region after hole.
250 type
->regions
[i
].size
= base
- type
->regions
[i
].base
;
251 return memblock_add_region(type
, end
, rgnend
- end
);
254 long memblock_remove(u64 base
, u64 size
)
256 return __memblock_remove(&memblock
.memory
, base
, size
);
259 long __init
memblock_free(u64 base
, u64 size
)
261 return __memblock_remove(&memblock
.reserved
, base
, size
);
264 long __init
memblock_reserve(u64 base
, u64 size
)
266 struct memblock_type
*_rgn
= &memblock
.reserved
;
270 return memblock_add_region(_rgn
, base
, size
);
273 long memblock_overlaps_region(struct memblock_type
*type
, u64 base
, u64 size
)
277 for (i
= 0; i
< type
->cnt
; i
++) {
278 u64 rgnbase
= type
->regions
[i
].base
;
279 u64 rgnsize
= type
->regions
[i
].size
;
280 if (memblock_addrs_overlap(base
, size
, rgnbase
, rgnsize
))
284 return (i
< type
->cnt
) ? i
: -1;
287 static u64
memblock_align_down(u64 addr
, u64 size
)
289 return addr
& ~(size
- 1);
292 static u64
memblock_align_up(u64 addr
, u64 size
)
294 return (addr
+ (size
- 1)) & ~(size
- 1);
297 static u64 __init
memblock_alloc_nid_unreserved(u64 start
, u64 end
,
303 base
= memblock_align_down((end
- size
), align
);
304 while (start
<= base
) {
305 j
= memblock_overlaps_region(&memblock
.reserved
, base
, size
);
307 /* this area isn't reserved, take it */
308 if (memblock_add_region(&memblock
.reserved
, base
, size
) < 0)
312 res_base
= memblock
.reserved
.regions
[j
].base
;
315 base
= memblock_align_down(res_base
- size
, align
);
321 static u64 __init
memblock_alloc_nid_region(struct memblock_region
*mp
,
322 u64 (*nid_range
)(u64
, u64
, int *),
323 u64 size
, u64 align
, int nid
)
328 end
= start
+ mp
->size
;
330 start
= memblock_align_up(start
, align
);
331 while (start
< end
) {
335 this_end
= nid_range(start
, end
, &this_nid
);
336 if (this_nid
== nid
) {
337 u64 ret
= memblock_alloc_nid_unreserved(start
, this_end
,
348 u64 __init
memblock_alloc_nid(u64 size
, u64 align
, int nid
,
349 u64 (*nid_range
)(u64 start
, u64 end
, int *nid
))
351 struct memblock_type
*mem
= &memblock
.memory
;
356 size
= memblock_align_up(size
, align
);
358 for (i
= 0; i
< mem
->cnt
; i
++) {
359 u64 ret
= memblock_alloc_nid_region(&mem
->regions
[i
],
366 return memblock_alloc(size
, align
);
369 u64 __init
memblock_alloc(u64 size
, u64 align
)
371 return memblock_alloc_base(size
, align
, MEMBLOCK_ALLOC_ANYWHERE
);
374 u64 __init
memblock_alloc_base(u64 size
, u64 align
, u64 max_addr
)
378 alloc
= __memblock_alloc_base(size
, align
, max_addr
);
381 panic("ERROR: Failed to allocate 0x%llx bytes below 0x%llx.\n",
382 (unsigned long long) size
, (unsigned long long) max_addr
);
387 u64 __init
__memblock_alloc_base(u64 size
, u64 align
, u64 max_addr
)
395 size
= memblock_align_up(size
, align
);
397 /* On some platforms, make sure we allocate lowmem */
398 /* Note that MEMBLOCK_REAL_LIMIT may be MEMBLOCK_ALLOC_ANYWHERE */
399 if (max_addr
== MEMBLOCK_ALLOC_ANYWHERE
)
400 max_addr
= MEMBLOCK_REAL_LIMIT
;
402 for (i
= memblock
.memory
.cnt
- 1; i
>= 0; i
--) {
403 u64 memblockbase
= memblock
.memory
.regions
[i
].base
;
404 u64 memblocksize
= memblock
.memory
.regions
[i
].size
;
406 if (memblocksize
< size
)
408 if (max_addr
== MEMBLOCK_ALLOC_ANYWHERE
)
409 base
= memblock_align_down(memblockbase
+ memblocksize
- size
, align
);
410 else if (memblockbase
< max_addr
) {
411 base
= min(memblockbase
+ memblocksize
, max_addr
);
412 base
= memblock_align_down(base
- size
, align
);
416 while (base
&& memblockbase
<= base
) {
417 j
= memblock_overlaps_region(&memblock
.reserved
, base
, size
);
419 /* this area isn't reserved, take it */
420 if (memblock_add_region(&memblock
.reserved
, base
, size
) < 0)
424 res_base
= memblock
.reserved
.regions
[j
].base
;
427 base
= memblock_align_down(res_base
- size
, align
);
433 /* You must call memblock_analyze() before this. */
434 u64 __init
memblock_phys_mem_size(void)
436 return memblock
.memory
.size
;
439 u64
memblock_end_of_DRAM(void)
441 int idx
= memblock
.memory
.cnt
- 1;
443 return (memblock
.memory
.regions
[idx
].base
+ memblock
.memory
.regions
[idx
].size
);
446 /* You must call memblock_analyze() after this. */
447 void __init
memblock_enforce_memory_limit(u64 memory_limit
)
451 struct memblock_region
*p
;
456 /* Truncate the memblock regions to satisfy the memory limit. */
457 limit
= memory_limit
;
458 for (i
= 0; i
< memblock
.memory
.cnt
; i
++) {
459 if (limit
> memblock
.memory
.regions
[i
].size
) {
460 limit
-= memblock
.memory
.regions
[i
].size
;
464 memblock
.memory
.regions
[i
].size
= limit
;
465 memblock
.memory
.cnt
= i
+ 1;
469 if (memblock
.memory
.regions
[0].size
< memblock
.rmo_size
)
470 memblock
.rmo_size
= memblock
.memory
.regions
[0].size
;
472 memory_limit
= memblock_end_of_DRAM();
474 /* And truncate any reserves above the limit also. */
475 for (i
= 0; i
< memblock
.reserved
.cnt
; i
++) {
476 p
= &memblock
.reserved
.regions
[i
];
478 if (p
->base
> memory_limit
)
480 else if ((p
->base
+ p
->size
) > memory_limit
)
481 p
->size
= memory_limit
- p
->base
;
484 memblock_remove_region(&memblock
.reserved
, i
);
490 static int memblock_search(struct memblock_type
*type
, u64 addr
)
492 unsigned int left
= 0, right
= type
->cnt
;
495 unsigned int mid
= (right
+ left
) / 2;
497 if (addr
< type
->regions
[mid
].base
)
499 else if (addr
>= (type
->regions
[mid
].base
+
500 type
->regions
[mid
].size
))
504 } while (left
< right
);
508 int __init
memblock_is_reserved(u64 addr
)
510 return memblock_search(&memblock
.reserved
, addr
) != -1;
513 int memblock_is_memory(u64 addr
)
515 return memblock_search(&memblock
.memory
, addr
) != -1;
518 int memblock_is_region_memory(u64 base
, u64 size
)
520 int idx
= memblock_search(&memblock
.reserved
, base
);
524 return memblock
.reserved
.regions
[idx
].base
<= base
&&
525 (memblock
.reserved
.regions
[idx
].base
+
526 memblock
.reserved
.regions
[idx
].size
) >= (base
+ size
);
529 int memblock_is_region_reserved(u64 base
, u64 size
)
531 return memblock_overlaps_region(&memblock
.reserved
, base
, size
) >= 0;
535 * Given a <base, len>, find which memory regions belong to this range.
536 * Adjust the request and return a contiguous chunk.
538 int memblock_find(struct memblock_region
*res
)
544 rend
= rstart
+ res
->size
- 1;
546 for (i
= 0; i
< memblock
.memory
.cnt
; i
++) {
547 u64 start
= memblock
.memory
.regions
[i
].base
;
548 u64 end
= start
+ memblock
.memory
.regions
[i
].size
- 1;
553 if ((end
>= rstart
) && (start
< rend
)) {
554 /* adjust the request */
560 res
->size
= rend
- rstart
+ 1;
This page took 0.04297 seconds and 6 git commands to generate.