memblock.c 13.5 KB
Newer Older
Y
Yinghai Lu 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * Procedures for maintaining information about logical memory blocks.
 *
 * Peter Bergner, IBM Corp.	June 2001.
 * Copyright (C) 2001 Peter Bergner.
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/bitops.h>
16
#include <linux/poison.h>
Y
Yinghai Lu 已提交
17 18 19 20 21
#include <linux/memblock.h>

struct memblock memblock;

static int memblock_debug;
22 23
static struct memblock_region memblock_memory_init_regions[INIT_MEMBLOCK_REGIONS + 1];
static struct memblock_region memblock_reserved_init_regions[INIT_MEMBLOCK_REGIONS + 1];
Y
Yinghai Lu 已提交
24 25 26 27 28 29 30 31 32

static int __init early_memblock(char *p)
{
	if (p && strstr(p, "debug"))
		memblock_debug = 1;
	return 0;
}
early_param("memblock", early_memblock);

33
static void memblock_dump(struct memblock_type *region, char *name)
Y
Yinghai Lu 已提交
34 35 36 37 38 39 40
{
	unsigned long long base, size;
	int i;

	pr_info(" %s.cnt  = 0x%lx\n", name, region->cnt);

	for (i = 0; i < region->cnt; i++) {
41 42
		base = region->regions[i].base;
		size = region->regions[i].size;
Y
Yinghai Lu 已提交
43 44 45 46 47 48 49 50 51 52 53 54

		pr_info(" %s[0x%x]\t0x%016llx - 0x%016llx, 0x%llx bytes\n",
		    name, i, base, base + size - 1, size);
	}
}

void memblock_dump_all(void)
{
	if (!memblock_debug)
		return;

	pr_info("MEMBLOCK configuration:\n");
55
	pr_info(" memory size = 0x%llx\n", (unsigned long long)memblock.memory_size);
Y
Yinghai Lu 已提交
56 57 58 59 60

	memblock_dump(&memblock.memory, "memory");
	memblock_dump(&memblock.reserved, "reserved");
}

61 62
static unsigned long memblock_addrs_overlap(phys_addr_t base1, phys_addr_t size1,
				       phys_addr_t base2, phys_addr_t size2)
Y
Yinghai Lu 已提交
63 64 65 66
{
	return ((base1 < (base2 + size2)) && (base2 < (base1 + size1)));
}

67 68
static long memblock_addrs_adjacent(phys_addr_t base1, phys_addr_t size1,
			       phys_addr_t base2, phys_addr_t size2)
Y
Yinghai Lu 已提交
69 70 71 72 73 74 75 76 77
{
	if (base2 == base1 + size1)
		return 1;
	else if (base1 == base2 + size2)
		return -1;

	return 0;
}

78
static long memblock_regions_adjacent(struct memblock_type *type,
79
				 unsigned long r1, unsigned long r2)
Y
Yinghai Lu 已提交
80
{
81 82 83 84
	phys_addr_t base1 = type->regions[r1].base;
	phys_addr_t size1 = type->regions[r1].size;
	phys_addr_t base2 = type->regions[r2].base;
	phys_addr_t size2 = type->regions[r2].size;
Y
Yinghai Lu 已提交
85 86 87 88

	return memblock_addrs_adjacent(base1, size1, base2, size2);
}

89
static void memblock_remove_region(struct memblock_type *type, unsigned long r)
Y
Yinghai Lu 已提交
90 91 92
{
	unsigned long i;

93 94 95
	for (i = r; i < type->cnt - 1; i++) {
		type->regions[i].base = type->regions[i + 1].base;
		type->regions[i].size = type->regions[i + 1].size;
Y
Yinghai Lu 已提交
96
	}
97
	type->cnt--;
Y
Yinghai Lu 已提交
98 99 100
}

/* Assumption: base addr of region 1 < base addr of region 2 */
101
static void memblock_coalesce_regions(struct memblock_type *type,
Y
Yinghai Lu 已提交
102 103
		unsigned long r1, unsigned long r2)
{
104 105
	type->regions[r1].size += type->regions[r2].size;
	memblock_remove_region(type, r2);
Y
Yinghai Lu 已提交
106 107 108 109
}

void __init memblock_init(void)
{
110 111 112 113 114 115
	/* Hookup the initial arrays */
	memblock.memory.regions	= memblock_memory_init_regions;
	memblock.memory.max		= INIT_MEMBLOCK_REGIONS;
	memblock.reserved.regions	= memblock_reserved_init_regions;
	memblock.reserved.max	= INIT_MEMBLOCK_REGIONS;

116 117 118 119
	/* Write a marker in the unused last array entry */
	memblock.memory.regions[INIT_MEMBLOCK_REGIONS].base = (phys_addr_t)RED_INACTIVE;
	memblock.reserved.regions[INIT_MEMBLOCK_REGIONS].base = (phys_addr_t)RED_INACTIVE;

Y
Yinghai Lu 已提交
120 121 122
	/* Create a dummy zero size MEMBLOCK which will get coalesced away later.
	 * This simplifies the memblock_add() code below...
	 */
123 124
	memblock.memory.regions[0].base = 0;
	memblock.memory.regions[0].size = 0;
Y
Yinghai Lu 已提交
125 126 127
	memblock.memory.cnt = 1;

	/* Ditto. */
128 129
	memblock.reserved.regions[0].base = 0;
	memblock.reserved.regions[0].size = 0;
Y
Yinghai Lu 已提交
130
	memblock.reserved.cnt = 1;
131 132

	memblock.current_limit = MEMBLOCK_ALLOC_ANYWHERE;
Y
Yinghai Lu 已提交
133 134 135 136 137 138
}

void __init memblock_analyze(void)
{
	int i;

139 140 141 142 143 144
	/* Check marker in the unused last array entry */
	WARN_ON(memblock_memory_init_regions[INIT_MEMBLOCK_REGIONS].base
		!= (phys_addr_t)RED_INACTIVE);
	WARN_ON(memblock_reserved_init_regions[INIT_MEMBLOCK_REGIONS].base
		!= (phys_addr_t)RED_INACTIVE);

145
	memblock.memory_size = 0;
Y
Yinghai Lu 已提交
146 147

	for (i = 0; i < memblock.memory.cnt; i++)
148
		memblock.memory_size += memblock.memory.regions[i].size;
Y
Yinghai Lu 已提交
149 150
}

151
static long memblock_add_region(struct memblock_type *type, phys_addr_t base, phys_addr_t size)
Y
Yinghai Lu 已提交
152 153 154 155
{
	unsigned long coalesced = 0;
	long adjacent, i;

156 157 158
	if ((type->cnt == 1) && (type->regions[0].size == 0)) {
		type->regions[0].base = base;
		type->regions[0].size = size;
Y
Yinghai Lu 已提交
159 160 161 162
		return 0;
	}

	/* First try and coalesce this MEMBLOCK with another. */
163
	for (i = 0; i < type->cnt; i++) {
164 165
		phys_addr_t rgnbase = type->regions[i].base;
		phys_addr_t rgnsize = type->regions[i].size;
Y
Yinghai Lu 已提交
166 167 168 169 170 171 172

		if ((rgnbase == base) && (rgnsize == size))
			/* Already have this region, so we're done */
			return 0;

		adjacent = memblock_addrs_adjacent(base, size, rgnbase, rgnsize);
		if (adjacent > 0) {
173 174
			type->regions[i].base -= size;
			type->regions[i].size += size;
Y
Yinghai Lu 已提交
175 176 177
			coalesced++;
			break;
		} else if (adjacent < 0) {
178
			type->regions[i].size += size;
Y
Yinghai Lu 已提交
179 180 181 182 183
			coalesced++;
			break;
		}
	}

184 185
	if ((i < type->cnt - 1) && memblock_regions_adjacent(type, i, i+1)) {
		memblock_coalesce_regions(type, i, i+1);
Y
Yinghai Lu 已提交
186 187 188 189 190
		coalesced++;
	}

	if (coalesced)
		return coalesced;
191
	if (type->cnt >= type->max)
Y
Yinghai Lu 已提交
192 193 194
		return -1;

	/* Couldn't coalesce the MEMBLOCK, so add it to the sorted table. */
195 196 197 198
	for (i = type->cnt - 1; i >= 0; i--) {
		if (base < type->regions[i].base) {
			type->regions[i+1].base = type->regions[i].base;
			type->regions[i+1].size = type->regions[i].size;
Y
Yinghai Lu 已提交
199
		} else {
200 201
			type->regions[i+1].base = base;
			type->regions[i+1].size = size;
Y
Yinghai Lu 已提交
202 203 204 205
			break;
		}
	}

206 207 208
	if (base < type->regions[0].base) {
		type->regions[0].base = base;
		type->regions[0].size = size;
Y
Yinghai Lu 已提交
209
	}
210
	type->cnt++;
Y
Yinghai Lu 已提交
211 212 213 214

	return 0;
}

215
long memblock_add(phys_addr_t base, phys_addr_t size)
Y
Yinghai Lu 已提交
216
{
217
	return memblock_add_region(&memblock.memory, base, size);
Y
Yinghai Lu 已提交
218 219 220

}

221
static long __memblock_remove(struct memblock_type *type, phys_addr_t base, phys_addr_t size)
Y
Yinghai Lu 已提交
222
{
223 224
	phys_addr_t rgnbegin, rgnend;
	phys_addr_t end = base + size;
Y
Yinghai Lu 已提交
225 226 227 228 229
	int i;

	rgnbegin = rgnend = 0; /* supress gcc warnings */

	/* Find the region where (base, size) belongs to */
230 231 232
	for (i=0; i < type->cnt; i++) {
		rgnbegin = type->regions[i].base;
		rgnend = rgnbegin + type->regions[i].size;
Y
Yinghai Lu 已提交
233 234 235 236 237 238

		if ((rgnbegin <= base) && (end <= rgnend))
			break;
	}

	/* Didn't find the region */
239
	if (i == type->cnt)
Y
Yinghai Lu 已提交
240 241 242 243
		return -1;

	/* Check to see if we are removing entire region */
	if ((rgnbegin == base) && (rgnend == end)) {
244
		memblock_remove_region(type, i);
Y
Yinghai Lu 已提交
245 246 247 248 249
		return 0;
	}

	/* Check to see if region is matching at the front */
	if (rgnbegin == base) {
250 251
		type->regions[i].base = end;
		type->regions[i].size -= size;
Y
Yinghai Lu 已提交
252 253 254 255 256
		return 0;
	}

	/* Check to see if the region is matching at the end */
	if (rgnend == end) {
257
		type->regions[i].size -= size;
Y
Yinghai Lu 已提交
258 259 260 261 262 263 264
		return 0;
	}

	/*
	 * We need to split the entry -  adjust the current one to the
	 * beginging of the hole and add the region after hole.
	 */
265 266
	type->regions[i].size = base - type->regions[i].base;
	return memblock_add_region(type, end, rgnend - end);
Y
Yinghai Lu 已提交
267 268
}

269
long memblock_remove(phys_addr_t base, phys_addr_t size)
Y
Yinghai Lu 已提交
270 271 272 273
{
	return __memblock_remove(&memblock.memory, base, size);
}

274
long __init memblock_free(phys_addr_t base, phys_addr_t size)
Y
Yinghai Lu 已提交
275 276 277 278
{
	return __memblock_remove(&memblock.reserved, base, size);
}

279
long __init memblock_reserve(phys_addr_t base, phys_addr_t size)
Y
Yinghai Lu 已提交
280
{
281
	struct memblock_type *_rgn = &memblock.reserved;
Y
Yinghai Lu 已提交
282 283 284 285 286 287

	BUG_ON(0 == size);

	return memblock_add_region(_rgn, base, size);
}

288
long memblock_overlaps_region(struct memblock_type *type, phys_addr_t base, phys_addr_t size)
Y
Yinghai Lu 已提交
289 290 291
{
	unsigned long i;

292
	for (i = 0; i < type->cnt; i++) {
293 294
		phys_addr_t rgnbase = type->regions[i].base;
		phys_addr_t rgnsize = type->regions[i].size;
Y
Yinghai Lu 已提交
295 296 297 298
		if (memblock_addrs_overlap(base, size, rgnbase, rgnsize))
			break;
	}

299
	return (i < type->cnt) ? i : -1;
Y
Yinghai Lu 已提交
300 301
}

302
static phys_addr_t memblock_align_down(phys_addr_t addr, phys_addr_t size)
Y
Yinghai Lu 已提交
303 304 305 306
{
	return addr & ~(size - 1);
}

307
static phys_addr_t memblock_align_up(phys_addr_t addr, phys_addr_t size)
Y
Yinghai Lu 已提交
308 309 310 311
{
	return (addr + (size - 1)) & ~(size - 1);
}

312 313
static phys_addr_t __init memblock_find_region(phys_addr_t start, phys_addr_t end,
					  phys_addr_t size, phys_addr_t align)
Y
Yinghai Lu 已提交
314
{
315
	phys_addr_t base, res_base;
Y
Yinghai Lu 已提交
316 317 318 319 320
	long j;

	base = memblock_align_down((end - size), align);
	while (start <= base) {
		j = memblock_overlaps_region(&memblock.reserved, base, size);
321
		if (j < 0)
Y
Yinghai Lu 已提交
322
			return base;
323
		res_base = memblock.reserved.regions[j].base;
Y
Yinghai Lu 已提交
324 325 326 327 328
		if (res_base < size)
			break;
		base = memblock_align_down(res_base - size, align);
	}

329
	return ~(phys_addr_t)0;
Y
Yinghai Lu 已提交
330 331
}

332
phys_addr_t __weak __init memblock_nid_range(phys_addr_t start, phys_addr_t end, int *nid)
333 334 335 336 337 338
{
	*nid = 0;

	return end;
}

339 340 341
static phys_addr_t __init memblock_alloc_nid_region(struct memblock_region *mp,
					       phys_addr_t size,
					       phys_addr_t align, int nid)
Y
Yinghai Lu 已提交
342
{
343
	phys_addr_t start, end;
Y
Yinghai Lu 已提交
344 345 346 347 348 349

	start = mp->base;
	end = start + mp->size;

	start = memblock_align_up(start, align);
	while (start < end) {
350
		phys_addr_t this_end;
Y
Yinghai Lu 已提交
351 352
		int this_nid;

353
		this_end = memblock_nid_range(start, end, &this_nid);
Y
Yinghai Lu 已提交
354
		if (this_nid == nid) {
355 356 357
			phys_addr_t ret = memblock_find_region(start, this_end, size, align);
			if (ret != ~(phys_addr_t)0 &&
			    memblock_add_region(&memblock.reserved, ret, size) >= 0)
Y
Yinghai Lu 已提交
358 359 360 361 362
				return ret;
		}
		start = this_end;
	}

363
	return ~(phys_addr_t)0;
Y
Yinghai Lu 已提交
364 365
}

366
phys_addr_t __init memblock_alloc_nid(phys_addr_t size, phys_addr_t align, int nid)
Y
Yinghai Lu 已提交
367
{
368
	struct memblock_type *mem = &memblock.memory;
Y
Yinghai Lu 已提交
369 370 371 372
	int i;

	BUG_ON(0 == size);

373 374 375 376
	/* We do a bottom-up search for a region with the right
	 * nid since that's easier considering how memblock_nid_range()
	 * works
	 */
Y
Yinghai Lu 已提交
377 378 379
	size = memblock_align_up(size, align);

	for (i = 0; i < mem->cnt; i++) {
380
		phys_addr_t ret = memblock_alloc_nid_region(&mem->regions[i],
Y
Yinghai Lu 已提交
381
					       size, align, nid);
382
		if (ret != ~(phys_addr_t)0)
Y
Yinghai Lu 已提交
383 384 385 386 387 388
			return ret;
	}

	return memblock_alloc(size, align);
}

389
phys_addr_t __init memblock_alloc(phys_addr_t size, phys_addr_t align)
Y
Yinghai Lu 已提交
390
{
391
	return memblock_alloc_base(size, align, MEMBLOCK_ALLOC_ACCESSIBLE);
Y
Yinghai Lu 已提交
392 393
}

394
phys_addr_t __init memblock_alloc_base(phys_addr_t size, phys_addr_t align, phys_addr_t max_addr)
Y
Yinghai Lu 已提交
395
{
396
	phys_addr_t alloc;
Y
Yinghai Lu 已提交
397 398 399 400 401 402 403 404 405 406

	alloc = __memblock_alloc_base(size, align, max_addr);

	if (alloc == 0)
		panic("ERROR: Failed to allocate 0x%llx bytes below 0x%llx.\n",
		      (unsigned long long) size, (unsigned long long) max_addr);

	return alloc;
}

407
phys_addr_t __init __memblock_alloc_base(phys_addr_t size, phys_addr_t align, phys_addr_t max_addr)
Y
Yinghai Lu 已提交
408
{
409
	long i;
410 411
	phys_addr_t base = 0;
	phys_addr_t res_base;
Y
Yinghai Lu 已提交
412 413 414 415 416

	BUG_ON(0 == size);

	size = memblock_align_up(size, align);

417
	/* Pump up max_addr */
418 419
	if (max_addr == MEMBLOCK_ALLOC_ACCESSIBLE)
		max_addr = memblock.current_limit;
420 421 422 423 424

	/* We do a top-down search, this tends to limit memory
	 * fragmentation by keeping early boot allocs near the
	 * top of memory
	 */
Y
Yinghai Lu 已提交
425
	for (i = memblock.memory.cnt - 1; i >= 0; i--) {
426 427
		phys_addr_t memblockbase = memblock.memory.regions[i].base;
		phys_addr_t memblocksize = memblock.memory.regions[i].size;
Y
Yinghai Lu 已提交
428 429 430

		if (memblocksize < size)
			continue;
431
		base = min(memblockbase + memblocksize, max_addr);
432 433 434
		res_base = memblock_find_region(memblockbase, base, size, align);
		if (res_base != ~(phys_addr_t)0 &&
		    memblock_add_region(&memblock.reserved, res_base, size) >= 0)
435
			return res_base;
Y
Yinghai Lu 已提交
436 437 438 439 440
	}
	return 0;
}

/* You must call memblock_analyze() before this. */
441
phys_addr_t __init memblock_phys_mem_size(void)
Y
Yinghai Lu 已提交
442
{
443
	return memblock.memory_size;
Y
Yinghai Lu 已提交
444 445
}

446
phys_addr_t memblock_end_of_DRAM(void)
Y
Yinghai Lu 已提交
447 448 449
{
	int idx = memblock.memory.cnt - 1;

450
	return (memblock.memory.regions[idx].base + memblock.memory.regions[idx].size);
Y
Yinghai Lu 已提交
451 452 453
}

/* You must call memblock_analyze() after this. */
454
void __init memblock_enforce_memory_limit(phys_addr_t memory_limit)
Y
Yinghai Lu 已提交
455 456
{
	unsigned long i;
457
	phys_addr_t limit;
458
	struct memblock_region *p;
Y
Yinghai Lu 已提交
459 460 461 462 463 464 465

	if (!memory_limit)
		return;

	/* Truncate the memblock regions to satisfy the memory limit. */
	limit = memory_limit;
	for (i = 0; i < memblock.memory.cnt; i++) {
466 467
		if (limit > memblock.memory.regions[i].size) {
			limit -= memblock.memory.regions[i].size;
Y
Yinghai Lu 已提交
468 469 470
			continue;
		}

471
		memblock.memory.regions[i].size = limit;
Y
Yinghai Lu 已提交
472 473 474 475 476 477 478 479
		memblock.memory.cnt = i + 1;
		break;
	}

	memory_limit = memblock_end_of_DRAM();

	/* And truncate any reserves above the limit also. */
	for (i = 0; i < memblock.reserved.cnt; i++) {
480
		p = &memblock.reserved.regions[i];
Y
Yinghai Lu 已提交
481 482 483 484 485 486 487 488 489 490 491 492 493

		if (p->base > memory_limit)
			p->size = 0;
		else if ((p->base + p->size) > memory_limit)
			p->size = memory_limit - p->base;

		if (p->size == 0) {
			memblock_remove_region(&memblock.reserved, i);
			i--;
		}
	}
}

494
static int memblock_search(struct memblock_type *type, phys_addr_t addr)
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
{
	unsigned int left = 0, right = type->cnt;

	do {
		unsigned int mid = (right + left) / 2;

		if (addr < type->regions[mid].base)
			right = mid;
		else if (addr >= (type->regions[mid].base +
				  type->regions[mid].size))
			left = mid + 1;
		else
			return mid;
	} while (left < right);
	return -1;
}

512
int __init memblock_is_reserved(phys_addr_t addr)
Y
Yinghai Lu 已提交
513
{
514 515
	return memblock_search(&memblock.reserved, addr) != -1;
}
Y
Yinghai Lu 已提交
516

517
int memblock_is_memory(phys_addr_t addr)
518 519 520 521
{
	return memblock_search(&memblock.memory, addr) != -1;
}

522
int memblock_is_region_memory(phys_addr_t base, phys_addr_t size)
523 524 525 526 527 528 529 530
{
	int idx = memblock_search(&memblock.reserved, base);

	if (idx == -1)
		return 0;
	return memblock.reserved.regions[idx].base <= base &&
		(memblock.reserved.regions[idx].base +
		 memblock.reserved.regions[idx].size) >= (base + size);
Y
Yinghai Lu 已提交
531 532
}

533
int memblock_is_region_reserved(phys_addr_t base, phys_addr_t size)
Y
Yinghai Lu 已提交
534
{
535
	return memblock_overlaps_region(&memblock.reserved, base, size) >= 0;
Y
Yinghai Lu 已提交
536 537
}

538

539
void __init memblock_set_current_limit(phys_addr_t limit)
540 541 542 543
{
	memblock.current_limit = limit;
}