init.c 13.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 *  linux/arch/arm/mm/init.c
 *
R
Russell King 已提交
4
 *  Copyright (C) 1995-2005 Russell King
L
Linus Torvalds 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/swap.h>
#include <linux/init.h>
#include <linux/bootmem.h>
#include <linux/mman.h>
#include <linux/nodemask.h>
#include <linux/initrd.h>

#include <asm/mach-types.h>
#include <asm/setup.h>
21
#include <asm/sizes.h>
L
Linus Torvalds 已提交
22 23 24 25 26
#include <asm/tlb.h>

#include <asm/mach/arch.h>
#include <asm/mach/map.h>

27 28
#include "mm.h"

29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
static unsigned long phys_initrd_start __initdata = 0;
static unsigned long phys_initrd_size __initdata = 0;

static void __init early_initrd(char **p)
{
	unsigned long start, size;

	start = memparse(*p, p);
	if (**p == ',') {
		size = memparse((*p) + 1, p);

		phys_initrd_start = start;
		phys_initrd_size = size;
	}
}
__early_param("initrd=", early_initrd);

static int __init parse_tag_initrd(const struct tag *tag)
{
	printk(KERN_WARNING "ATAG_INITRD is deprecated; "
		"please update your bootloader.\n");
	phys_initrd_start = __virt_to_phys(tag->u.initrd.start);
	phys_initrd_size = tag->u.initrd.size;
	return 0;
}

__tagtable(ATAG_INITRD, parse_tag_initrd);

static int __init parse_tag_initrd2(const struct tag *tag)
{
	phys_initrd_start = tag->u.initrd.start;
	phys_initrd_size = tag->u.initrd.size;
	return 0;
}

__tagtable(ATAG_INITRD2, parse_tag_initrd2);
L
Linus Torvalds 已提交
65 66

/*
67 68 69
 * This keeps memory configuration data used by a couple memory
 * initialization functions, as well as show_mem() for the skipping
 * of holes in the memory map.  It is populated by arm_add_memory().
L
Linus Torvalds 已提交
70
 */
71
struct meminfo meminfo;
72

L
Linus Torvalds 已提交
73 74 75
void show_mem(void)
{
	int free = 0, total = 0, reserved = 0;
76 77
	int shared = 0, cached = 0, slab = 0, node, i;
	struct meminfo * mi = &meminfo;
L
Linus Torvalds 已提交
78 79 80 81

	printk("Mem-info:\n");
	show_free_areas();
	for_each_online_node(node) {
82
		pg_data_t *n = NODE_DATA(node);
83
		struct page *map = pgdat_page_nr(n, 0) - n->node_start_pfn;
84

85
		for_each_nodebank (i,mi,node) {
86
			struct membank *bank = &mi->bank[i];
87 88 89
			unsigned int pfn1, pfn2;
			struct page *page, *end;

90 91
			pfn1 = bank_pfn_start(bank);
			pfn2 = bank_pfn_end(bank);
92

93 94
			page = map + pfn1;
			end  = map + pfn2;
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110

			do {
				total++;
				if (PageReserved(page))
					reserved++;
				else if (PageSwapCache(page))
					cached++;
				else if (PageSlab(page))
					slab++;
				else if (!page_count(page))
					free++;
				else
					shared += page_count(page) - 1;
				page++;
			} while (page < end);
		}
L
Linus Torvalds 已提交
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129
	}

	printk("%d pages of RAM\n", total);
	printk("%d free pages\n", free);
	printk("%d reserved pages\n", reserved);
	printk("%d slab pages\n", slab);
	printk("%d pages shared\n", shared);
	printk("%d pages swap cached\n", cached);
}

/*
 * FIXME: We really want to avoid allocating the bootmap bitmap
 * over the top of the initrd.  Hopefully, this is located towards
 * the start of a bank, so if we allocate the bootmap bitmap at
 * the end, we won't clash.
 */
static unsigned int __init
find_bootmap_pfn(int node, struct meminfo *mi, unsigned int bootmap_pages)
{
130
	unsigned int start_pfn, i, bootmap_pfn;
L
Linus Torvalds 已提交
131

R
Russell King 已提交
132
	start_pfn   = PAGE_ALIGN(__pa(&_end)) >> PAGE_SHIFT;
L
Linus Torvalds 已提交
133 134
	bootmap_pfn = 0;

135 136
	for_each_nodebank(i, mi, node) {
		struct membank *bank = &mi->bank[i];
L
Linus Torvalds 已提交
137 138
		unsigned int start, end;

139 140
		start = bank_pfn_start(bank);
		end   = bank_pfn_end(bank);
L
Linus Torvalds 已提交
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178

		if (end < start_pfn)
			continue;

		if (start < start_pfn)
			start = start_pfn;

		if (end <= start)
			continue;

		if (end - start >= bootmap_pages) {
			bootmap_pfn = start;
			break;
		}
	}

	if (bootmap_pfn == 0)
		BUG();

	return bootmap_pfn;
}

static int __init check_initrd(struct meminfo *mi)
{
	int initrd_node = -2;
#ifdef CONFIG_BLK_DEV_INITRD
	unsigned long end = phys_initrd_start + phys_initrd_size;

	/*
	 * Make sure that the initrd is within a valid area of
	 * memory.
	 */
	if (phys_initrd_size) {
		unsigned int i;

		initrd_node = -1;

		for (i = 0; i < mi->nr_banks; i++) {
179 180 181 182
			struct membank *bank = &mi->bank[i];
			if (bank_phys_start(bank) <= phys_initrd_start &&
			    end <= bank_phys_end(bank))
				initrd_node = bank->node;
L
Linus Torvalds 已提交
183 184 185 186
		}
	}

	if (initrd_node == -1) {
187
		printk(KERN_ERR "INITRD: 0x%08lx+0x%08lx extends beyond "
L
Linus Torvalds 已提交
188
		       "physical memory - disabling initrd\n",
189
		       phys_initrd_start, phys_initrd_size);
L
Linus Torvalds 已提交
190 191 192 193 194 195 196
		phys_initrd_start = phys_initrd_size = 0;
	}
#endif

	return initrd_node;
}

197 198
static inline void map_memory_bank(struct membank *bank)
{
199
#ifdef CONFIG_MMU
200 201
	struct map_desc map;

202 203 204
	map.pfn = bank_pfn_start(bank);
	map.virtual = __phys_to_virt(bank_phys_start(bank));
	map.length = bank_phys_size(bank);
205 206 207
	map.type = MT_MEMORY;

	create_mapping(&map);
208
#endif
209 210
}

211
static unsigned long __init bootmem_init_node(int node, struct meminfo *mi)
L
Linus Torvalds 已提交
212
{
R
Russell King 已提交
213 214 215 216
	unsigned long start_pfn, end_pfn, boot_pfn;
	unsigned int boot_pages;
	pg_data_t *pgdat;
	int i;
L
Linus Torvalds 已提交
217

R
Russell King 已提交
218 219
	start_pfn = -1UL;
	end_pfn = 0;
L
Linus Torvalds 已提交
220

R
Russell King 已提交
221 222 223 224
	/*
	 * Calculate the pfn range, and map the memory banks for this node.
	 */
	for_each_nodebank(i, mi, node) {
225
		struct membank *bank = &mi->bank[i];
R
Russell King 已提交
226
		unsigned long start, end;
L
Linus Torvalds 已提交
227

228 229
		start = bank_pfn_start(bank);
		end = bank_pfn_end(bank);
L
Linus Torvalds 已提交
230

R
Russell King 已提交
231 232 233 234 235
		if (start_pfn > start)
			start_pfn = start;
		if (end_pfn < end)
			end_pfn = end;

236
		map_memory_bank(bank);
R
Russell King 已提交
237
	}
L
Linus Torvalds 已提交
238 239

	/*
R
Russell King 已提交
240
	 * If there is no memory in this node, ignore it.
L
Linus Torvalds 已提交
241
	 */
R
Russell King 已提交
242 243
	if (end_pfn == 0)
		return end_pfn;
L
Linus Torvalds 已提交
244

R
Russell King 已提交
245 246 247 248 249
	/*
	 * Allocate the bootmem bitmap page.
	 */
	boot_pages = bootmem_bootmap_pages(end_pfn - start_pfn);
	boot_pfn = find_bootmap_pfn(node, mi, boot_pages);
L
Linus Torvalds 已提交
250

R
Russell King 已提交
251 252 253 254 255 256 257
	/*
	 * Initialise the bootmem allocator for this node, handing the
	 * memory banks over to bootmem.
	 */
	node_set_online(node);
	pgdat = NODE_DATA(node);
	init_bootmem_node(pgdat, boot_pfn, start_pfn, end_pfn);
L
Linus Torvalds 已提交
258

259 260 261
	for_each_nodebank(i, mi, node) {
		struct membank *bank = &mi->bank[i];
		free_bootmem_node(pgdat, bank_phys_start(bank), bank_phys_size(bank));
262
		memory_present(node, bank_pfn_start(bank), bank_pfn_end(bank));
263
	}
R
Russell King 已提交
264 265 266 267 268

	/*
	 * Reserve the bootmem bitmap for this node.
	 */
	reserve_bootmem_node(pgdat, boot_pfn << PAGE_SHIFT,
269
			     boot_pages << PAGE_SHIFT, BOOTMEM_DEFAULT);
L
Linus Torvalds 已提交
270

271 272
	return end_pfn;
}
273

274 275
static void __init bootmem_reserve_initrd(int node)
{
L
Linus Torvalds 已提交
276
#ifdef CONFIG_BLK_DEV_INITRD
277 278 279 280 281 282 283 284 285 286 287 288 289 290
	pg_data_t *pgdat = NODE_DATA(node);
	int res;

	res = reserve_bootmem_node(pgdat, phys_initrd_start,
			     phys_initrd_size, BOOTMEM_EXCLUSIVE);

	if (res == 0) {
		initrd_start = __phys_to_virt(phys_initrd_start);
		initrd_end = initrd_start + phys_initrd_size;
	} else {
		printk(KERN_ERR
			"INITRD: 0x%08lx+0x%08lx overlaps in-use "
			"memory region - disabling initrd\n",
			phys_initrd_start, phys_initrd_size);
L
Linus Torvalds 已提交
291 292
	}
#endif
293 294 295 296 297 298 299 300 301 302 303
}

static void __init bootmem_free_node(int node, struct meminfo *mi)
{
	unsigned long zone_size[MAX_NR_ZONES], zhole_size[MAX_NR_ZONES];
	unsigned long start_pfn, end_pfn;
	pg_data_t *pgdat = NODE_DATA(node);
	int i;

	start_pfn = pgdat->bdata->node_min_pfn;
	end_pfn = pgdat->bdata->node_low_pfn;
L
Linus Torvalds 已提交
304

R
Russell King 已提交
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
	/*
	 * initialise the zones within this node.
	 */
	memset(zone_size, 0, sizeof(zone_size));
	memset(zhole_size, 0, sizeof(zhole_size));

	/*
	 * The size of this node has already been determined.  If we need
	 * to do anything fancy with the allocation of this memory to the
	 * zones, now is the time to do it.
	 */
	zone_size[0] = end_pfn - start_pfn;

	/*
	 * For each bank in this node, calculate the size of the holes.
	 *  holes = node_size - sum(bank_sizes_in_node)
	 */
	zhole_size[0] = zone_size[0];
	for_each_nodebank(i, mi, node)
324
		zhole_size[0] -= bank_pfn_size(&mi->bank[i]);
R
Russell King 已提交
325 326 327 328 329 330 331

	/*
	 * Adjust the sizes according to any special requirements for
	 * this machine type.
	 */
	arch_adjust_zones(node, zone_size, zhole_size);

332
	free_area_init_node(node, zone_size, start_pfn, zhole_size);
L
Linus Torvalds 已提交
333 334
}

335
void __init bootmem_init(void)
L
Linus Torvalds 已提交
336
{
337
	struct meminfo *mi = &meminfo;
338
	unsigned long memend_pfn = 0;
339
	int node, initrd_node;
L
Linus Torvalds 已提交
340 341

	/*
R
Russell King 已提交
342
	 * Locate which node contains the ramdisk image, if any.
L
Linus Torvalds 已提交
343
	 */
R
Russell King 已提交
344
	initrd_node = check_initrd(mi);
L
Linus Torvalds 已提交
345

R
Russell King 已提交
346 347 348 349
	/*
	 * Run through each node initialising the bootmem allocator.
	 */
	for_each_node(node) {
350
		unsigned long end_pfn = bootmem_init_node(node, mi);
L
Linus Torvalds 已提交
351

352 353 354 355 356 357 358 359 360 361 362
		/*
		 * Reserve any special node zero regions.
		 */
		if (node == 0)
			reserve_node_zero(NODE_DATA(node));

		/*
		 * If the initrd is in this node, reserve its memory.
		 */
		if (node == initrd_node)
			bootmem_reserve_initrd(node);
L
Linus Torvalds 已提交
363 364

		/*
R
Russell King 已提交
365
		 * Remember the highest memory PFN.
L
Linus Torvalds 已提交
366
		 */
R
Russell King 已提交
367 368 369
		if (end_pfn > memend_pfn)
			memend_pfn = end_pfn;
	}
L
Linus Torvalds 已提交
370

371 372 373 374 375 376 377 378 379 380 381 382 383
	/*
	 * sparse_init() needs the bootmem allocator up and running.
	 */
	sparse_init();

	/*
	 * Now free memory in each node - free_area_init_node needs
	 * the sparse mem_map arrays initialized by sparse_init()
	 * for memmap_init_zone(), otherwise all PFNs are invalid.
	 */
	for_each_node(node)
		bootmem_free_node(node, mi);

R
Russell King 已提交
384
	high_memory = __va(memend_pfn << PAGE_SHIFT);
L
Linus Torvalds 已提交
385

R
Russell King 已提交
386 387 388 389 390 391 392 393 394 395
	/*
	 * This doesn't seem to be used by the Linux memory manager any
	 * more, but is used by ll_rw_block.  If we can get rid of it, we
	 * also get rid of some of the stuff above as well.
	 *
	 * Note: max_low_pfn and max_pfn reflect the number of _pages_ in
	 * the system, not the maximum PFN.
	 */
	max_pfn = max_low_pfn = memend_pfn - PHYS_PFN_OFFSET;
}
L
Linus Torvalds 已提交
396

N
Nicolas Pitre 已提交
397
static inline int free_area(unsigned long pfn, unsigned long end, char *s)
L
Linus Torvalds 已提交
398
{
N
Nicolas Pitre 已提交
399
	unsigned int pages = 0, size = (end - pfn) << (PAGE_SHIFT - 10);
L
Linus Torvalds 已提交
400

N
Nicolas Pitre 已提交
401 402
	for (; pfn < end; pfn++) {
		struct page *page = pfn_to_page(pfn);
L
Linus Torvalds 已提交
403
		ClearPageReserved(page);
404
		init_page_count(page);
N
Nicolas Pitre 已提交
405 406
		__free_page(page);
		pages++;
L
Linus Torvalds 已提交
407 408 409 410
	}

	if (size && s)
		printk(KERN_INFO "Freeing %s memory: %dK\n", s, size);
N
Nicolas Pitre 已提交
411 412

	return pages;
L
Linus Torvalds 已提交
413 414
}

415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
static inline void
free_memmap(int node, unsigned long start_pfn, unsigned long end_pfn)
{
	struct page *start_pg, *end_pg;
	unsigned long pg, pgend;

	/*
	 * Convert start_pfn/end_pfn to a struct page pointer.
	 */
	start_pg = pfn_to_page(start_pfn);
	end_pg = pfn_to_page(end_pfn);

	/*
	 * Convert to physical addresses, and
	 * round start upwards and end downwards.
	 */
	pg = PAGE_ALIGN(__pa(start_pg));
	pgend = __pa(end_pg) & PAGE_MASK;

	/*
	 * If there are free pages between these,
	 * free the section of the memmap array.
	 */
	if (pg < pgend)
		free_bootmem_node(NODE_DATA(node), pg, pgend - pg);
}

/*
 * The mem_map array can get very big.  Free the unused area of the memory map.
 */
static void __init free_unused_memmap_node(int node, struct meminfo *mi)
{
	unsigned long bank_start, prev_bank_end = 0;
	unsigned int i;

	/*
	 * [FIXME] This relies on each bank being in address order.  This
	 * may not be the case, especially if the user has provided the
	 * information on the command line.
	 */
R
Russell King 已提交
455
	for_each_nodebank(i, mi, node) {
456 457 458
		struct membank *bank = &mi->bank[i];

		bank_start = bank_pfn_start(bank);
459 460 461 462 463 464 465 466 467 468 469 470 471
		if (bank_start < prev_bank_end) {
			printk(KERN_ERR "MEM: unordered memory banks.  "
				"Not freeing memmap.\n");
			break;
		}

		/*
		 * If we had a previous bank, and there is a space
		 * between the current bank and the previous, free it.
		 */
		if (prev_bank_end && prev_bank_end != bank_start)
			free_memmap(node, prev_bank_end, bank_start);

472
		prev_bank_end = bank_pfn_end(bank);
473 474 475
	}
}

L
Linus Torvalds 已提交
476 477 478 479 480 481 482
/*
 * mem_init() marks the free areas in the mem_map and tells us how much
 * memory is free.  This is done after various parts of the system have
 * claimed their memory after the kernel image.
 */
void __init mem_init(void)
{
N
Nicolas Pitre 已提交
483
	unsigned int codesize, datasize, initsize;
L
Linus Torvalds 已提交
484 485 486 487 488 489 490 491 492 493
	int i, node;

#ifndef CONFIG_DISCONTIGMEM
	max_mapnr   = virt_to_page(high_memory) - mem_map;
#endif

	/* this will put all unused low memory onto the freelists */
	for_each_online_node(node) {
		pg_data_t *pgdat = NODE_DATA(node);

494 495
		free_unused_memmap_node(node, &meminfo);

L
Linus Torvalds 已提交
496 497 498 499 500 501
		if (pgdat->node_spanned_pages != 0)
			totalram_pages += free_all_bootmem_node(pgdat);
	}

#ifdef CONFIG_SA1111
	/* now that our DMA memory is actually so designated, we can free it */
N
Nicolas Pitre 已提交
502 503
	totalram_pages += free_area(PHYS_PFN_OFFSET,
				    __phys_to_pfn(__pa(swapper_pg_dir)), NULL);
L
Linus Torvalds 已提交
504 505 506 507 508 509 510 511 512
#endif

	/*
	 * Since our memory may not be contiguous, calculate the
	 * real number of pages we have in this system
	 */
	printk(KERN_INFO "Memory:");
	num_physpages = 0;
	for (i = 0; i < meminfo.nr_banks; i++) {
513 514
		num_physpages += bank_pfn_size(&meminfo.bank[i]);
		printk(" %ldMB", bank_phys_size(&meminfo.bank[i]) >> 20);
L
Linus Torvalds 已提交
515 516
	}
	printk(" = %luMB total\n", num_physpages >> (20 - PAGE_SHIFT));
N
Nicolas Pitre 已提交
517 518 519 520 521

	codesize = &_etext - &_text;
	datasize = &_end - &__data_start;
	initsize = &__init_end - &__init_begin;

L
Linus Torvalds 已提交
522 523 524
	printk(KERN_NOTICE "Memory: %luKB available (%dK code, "
		"%dK data, %dK init)\n",
		(unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
N
Nicolas Pitre 已提交
525
		codesize >> 10, datasize >> 10, initsize >> 10);
L
Linus Torvalds 已提交
526 527 528 529 530 531 532 533 534 535 536 537 538 539

	if (PAGE_SIZE >= 16384 && num_physpages <= 128) {
		extern int sysctl_overcommit_memory;
		/*
		 * On a machine this small we won't get
		 * anywhere without overcommit, so turn
		 * it on by default.
		 */
		sysctl_overcommit_memory = OVERCOMMIT_ALWAYS;
	}
}

void free_initmem(void)
{
N
Nicolas Pitre 已提交
540 541 542 543
	if (!machine_is_integrator() && !machine_is_cintegrator())
		totalram_pages += free_area(__phys_to_pfn(__pa(&__init_begin)),
					    __phys_to_pfn(__pa(&__init_end)),
					    "init");
L
Linus Torvalds 已提交
544 545 546 547 548 549 550 551 552
}

#ifdef CONFIG_BLK_DEV_INITRD

static int keep_initrd;

void free_initrd_mem(unsigned long start, unsigned long end)
{
	if (!keep_initrd)
N
Nicolas Pitre 已提交
553 554 555
		totalram_pages += free_area(__phys_to_pfn(__pa(start)),
					    __phys_to_pfn(__pa(end)),
					    "initrd");
L
Linus Torvalds 已提交
556 557 558 559 560 561 562 563 564 565
}

static int __init keepinitrd_setup(char *__unused)
{
	keep_initrd = 1;
	return 1;
}

__setup("keepinitrd", keepinitrd_setup);
#endif