Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * linux/arch/arm/mm/init.c |
| 3 | * |
| 4 | * Copyright (C) 1995-2002 Russell King |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License version 2 as |
| 8 | * published by the Free Software Foundation. |
| 9 | */ |
| 10 | #include <linux/config.h> |
| 11 | #include <linux/kernel.h> |
| 12 | #include <linux/errno.h> |
| 13 | #include <linux/ptrace.h> |
| 14 | #include <linux/swap.h> |
| 15 | #include <linux/init.h> |
| 16 | #include <linux/bootmem.h> |
| 17 | #include <linux/mman.h> |
| 18 | #include <linux/nodemask.h> |
| 19 | #include <linux/initrd.h> |
| 20 | |
| 21 | #include <asm/mach-types.h> |
| 22 | #include <asm/hardware.h> |
| 23 | #include <asm/setup.h> |
| 24 | #include <asm/tlb.h> |
| 25 | |
| 26 | #include <asm/mach/arch.h> |
| 27 | #include <asm/mach/map.h> |
| 28 | |
| 29 | #define TABLE_SIZE (2 * PTRS_PER_PTE * sizeof(pte_t)) |
| 30 | |
| 31 | DEFINE_PER_CPU(struct mmu_gather, mmu_gathers); |
| 32 | |
| 33 | extern pgd_t swapper_pg_dir[PTRS_PER_PGD]; |
| 34 | extern void _stext, _text, _etext, __data_start, _end, __init_begin, __init_end; |
| 35 | extern unsigned long phys_initrd_start; |
| 36 | extern unsigned long phys_initrd_size; |
| 37 | |
| 38 | /* |
| 39 | * The sole use of this is to pass memory configuration |
| 40 | * data from paging_init to mem_init. |
| 41 | */ |
| 42 | static struct meminfo meminfo __initdata = { 0, }; |
| 43 | |
| 44 | /* |
| 45 | * empty_zero_page is a special page that is used for |
| 46 | * zero-initialized data and COW. |
| 47 | */ |
| 48 | struct page *empty_zero_page; |
| 49 | |
| 50 | void show_mem(void) |
| 51 | { |
| 52 | int free = 0, total = 0, reserved = 0; |
| 53 | int shared = 0, cached = 0, slab = 0, node; |
| 54 | |
| 55 | printk("Mem-info:\n"); |
| 56 | show_free_areas(); |
| 57 | printk("Free swap: %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10)); |
| 58 | |
| 59 | for_each_online_node(node) { |
| 60 | struct page *page, *end; |
| 61 | |
| 62 | page = NODE_MEM_MAP(node); |
| 63 | end = page + NODE_DATA(node)->node_spanned_pages; |
| 64 | |
| 65 | do { |
| 66 | total++; |
| 67 | if (PageReserved(page)) |
| 68 | reserved++; |
| 69 | else if (PageSwapCache(page)) |
| 70 | cached++; |
| 71 | else if (PageSlab(page)) |
| 72 | slab++; |
| 73 | else if (!page_count(page)) |
| 74 | free++; |
| 75 | else |
| 76 | shared += page_count(page) - 1; |
| 77 | page++; |
| 78 | } while (page < end); |
| 79 | } |
| 80 | |
| 81 | printk("%d pages of RAM\n", total); |
| 82 | printk("%d free pages\n", free); |
| 83 | printk("%d reserved pages\n", reserved); |
| 84 | printk("%d slab pages\n", slab); |
| 85 | printk("%d pages shared\n", shared); |
| 86 | printk("%d pages swap cached\n", cached); |
| 87 | } |
| 88 | |
| 89 | struct node_info { |
| 90 | unsigned int start; |
| 91 | unsigned int end; |
| 92 | int bootmap_pages; |
| 93 | }; |
| 94 | |
| 95 | #define O_PFN_DOWN(x) ((x) >> PAGE_SHIFT) |
| 96 | #define V_PFN_DOWN(x) O_PFN_DOWN(__pa(x)) |
| 97 | |
| 98 | #define O_PFN_UP(x) (PAGE_ALIGN(x) >> PAGE_SHIFT) |
| 99 | #define V_PFN_UP(x) O_PFN_UP(__pa(x)) |
| 100 | |
| 101 | #define PFN_SIZE(x) ((x) >> PAGE_SHIFT) |
| 102 | #define PFN_RANGE(s,e) PFN_SIZE(PAGE_ALIGN((unsigned long)(e)) - \ |
| 103 | (((unsigned long)(s)) & PAGE_MASK)) |
| 104 | |
| 105 | /* |
| 106 | * FIXME: We really want to avoid allocating the bootmap bitmap |
| 107 | * over the top of the initrd. Hopefully, this is located towards |
| 108 | * the start of a bank, so if we allocate the bootmap bitmap at |
| 109 | * the end, we won't clash. |
| 110 | */ |
| 111 | static unsigned int __init |
| 112 | find_bootmap_pfn(int node, struct meminfo *mi, unsigned int bootmap_pages) |
| 113 | { |
| 114 | unsigned int start_pfn, bank, bootmap_pfn; |
| 115 | |
| 116 | start_pfn = V_PFN_UP(&_end); |
| 117 | bootmap_pfn = 0; |
| 118 | |
| 119 | for (bank = 0; bank < mi->nr_banks; bank ++) { |
| 120 | unsigned int start, end; |
| 121 | |
| 122 | if (mi->bank[bank].node != node) |
| 123 | continue; |
| 124 | |
| 125 | start = O_PFN_UP(mi->bank[bank].start); |
| 126 | end = O_PFN_DOWN(mi->bank[bank].size + |
| 127 | mi->bank[bank].start); |
| 128 | |
| 129 | if (end < start_pfn) |
| 130 | continue; |
| 131 | |
| 132 | if (start < start_pfn) |
| 133 | start = start_pfn; |
| 134 | |
| 135 | if (end <= start) |
| 136 | continue; |
| 137 | |
| 138 | if (end - start >= bootmap_pages) { |
| 139 | bootmap_pfn = start; |
| 140 | break; |
| 141 | } |
| 142 | } |
| 143 | |
| 144 | if (bootmap_pfn == 0) |
| 145 | BUG(); |
| 146 | |
| 147 | return bootmap_pfn; |
| 148 | } |
| 149 | |
| 150 | /* |
| 151 | * Scan the memory info structure and pull out: |
| 152 | * - the end of memory |
| 153 | * - the number of nodes |
| 154 | * - the pfn range of each node |
| 155 | * - the number of bootmem bitmap pages |
| 156 | */ |
| 157 | static unsigned int __init |
| 158 | find_memend_and_nodes(struct meminfo *mi, struct node_info *np) |
| 159 | { |
| 160 | unsigned int i, bootmem_pages = 0, memend_pfn = 0; |
| 161 | |
| 162 | for (i = 0; i < MAX_NUMNODES; i++) { |
| 163 | np[i].start = -1U; |
| 164 | np[i].end = 0; |
| 165 | np[i].bootmap_pages = 0; |
| 166 | } |
| 167 | |
| 168 | for (i = 0; i < mi->nr_banks; i++) { |
| 169 | unsigned long start, end; |
| 170 | int node; |
| 171 | |
| 172 | if (mi->bank[i].size == 0) { |
| 173 | /* |
| 174 | * Mark this bank with an invalid node number |
| 175 | */ |
| 176 | mi->bank[i].node = -1; |
| 177 | continue; |
| 178 | } |
| 179 | |
| 180 | node = mi->bank[i].node; |
| 181 | |
| 182 | /* |
| 183 | * Make sure we haven't exceeded the maximum number of nodes |
| 184 | * that we have in this configuration. If we have, we're in |
| 185 | * trouble. (maybe we ought to limit, instead of bugging?) |
| 186 | */ |
| 187 | if (node >= MAX_NUMNODES) |
| 188 | BUG(); |
| 189 | node_set_online(node); |
| 190 | |
| 191 | /* |
| 192 | * Get the start and end pfns for this bank |
| 193 | */ |
| 194 | start = O_PFN_UP(mi->bank[i].start); |
| 195 | end = O_PFN_DOWN(mi->bank[i].start + mi->bank[i].size); |
| 196 | |
| 197 | if (np[node].start > start) |
| 198 | np[node].start = start; |
| 199 | |
| 200 | if (np[node].end < end) |
| 201 | np[node].end = end; |
| 202 | |
| 203 | if (memend_pfn < end) |
| 204 | memend_pfn = end; |
| 205 | } |
| 206 | |
| 207 | /* |
| 208 | * Calculate the number of pages we require to |
| 209 | * store the bootmem bitmaps. |
| 210 | */ |
| 211 | for_each_online_node(i) { |
| 212 | if (np[i].end == 0) |
| 213 | continue; |
| 214 | |
| 215 | np[i].bootmap_pages = bootmem_bootmap_pages(np[i].end - |
| 216 | np[i].start); |
| 217 | bootmem_pages += np[i].bootmap_pages; |
| 218 | } |
| 219 | |
| 220 | high_memory = __va(memend_pfn << PAGE_SHIFT); |
| 221 | |
| 222 | /* |
| 223 | * This doesn't seem to be used by the Linux memory |
| 224 | * manager any more. If we can get rid of it, we |
| 225 | * also get rid of some of the stuff above as well. |
akpm@osdl.org | d42ce81 | 2005-04-16 15:23:57 -0700 | [diff] [blame] | 226 | * |
| 227 | * Note: max_low_pfn and max_pfn reflect the number |
| 228 | * of _pages_ in the system, not the maximum PFN. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 229 | */ |
| 230 | max_low_pfn = memend_pfn - O_PFN_DOWN(PHYS_OFFSET); |
| 231 | max_pfn = memend_pfn - O_PFN_DOWN(PHYS_OFFSET); |
| 232 | |
| 233 | return bootmem_pages; |
| 234 | } |
| 235 | |
| 236 | static int __init check_initrd(struct meminfo *mi) |
| 237 | { |
| 238 | int initrd_node = -2; |
| 239 | #ifdef CONFIG_BLK_DEV_INITRD |
| 240 | unsigned long end = phys_initrd_start + phys_initrd_size; |
| 241 | |
| 242 | /* |
| 243 | * Make sure that the initrd is within a valid area of |
| 244 | * memory. |
| 245 | */ |
| 246 | if (phys_initrd_size) { |
| 247 | unsigned int i; |
| 248 | |
| 249 | initrd_node = -1; |
| 250 | |
| 251 | for (i = 0; i < mi->nr_banks; i++) { |
| 252 | unsigned long bank_end; |
| 253 | |
| 254 | bank_end = mi->bank[i].start + mi->bank[i].size; |
| 255 | |
| 256 | if (mi->bank[i].start <= phys_initrd_start && |
| 257 | end <= bank_end) |
| 258 | initrd_node = mi->bank[i].node; |
| 259 | } |
| 260 | } |
| 261 | |
| 262 | if (initrd_node == -1) { |
| 263 | printk(KERN_ERR "initrd (0x%08lx - 0x%08lx) extends beyond " |
| 264 | "physical memory - disabling initrd\n", |
| 265 | phys_initrd_start, end); |
| 266 | phys_initrd_start = phys_initrd_size = 0; |
| 267 | } |
| 268 | #endif |
| 269 | |
| 270 | return initrd_node; |
| 271 | } |
| 272 | |
| 273 | /* |
| 274 | * Reserve the various regions of node 0 |
| 275 | */ |
| 276 | static __init void reserve_node_zero(unsigned int bootmap_pfn, unsigned int bootmap_pages) |
| 277 | { |
| 278 | pg_data_t *pgdat = NODE_DATA(0); |
| 279 | unsigned long res_size = 0; |
| 280 | |
| 281 | /* |
| 282 | * Register the kernel text and data with bootmem. |
| 283 | * Note that this can only be in node 0. |
| 284 | */ |
| 285 | #ifdef CONFIG_XIP_KERNEL |
| 286 | reserve_bootmem_node(pgdat, __pa(&__data_start), &_end - &__data_start); |
| 287 | #else |
| 288 | reserve_bootmem_node(pgdat, __pa(&_stext), &_end - &_stext); |
| 289 | #endif |
| 290 | |
| 291 | /* |
| 292 | * Reserve the page tables. These are already in use, |
| 293 | * and can only be in node 0. |
| 294 | */ |
| 295 | reserve_bootmem_node(pgdat, __pa(swapper_pg_dir), |
| 296 | PTRS_PER_PGD * sizeof(pgd_t)); |
| 297 | |
| 298 | /* |
| 299 | * And don't forget to reserve the allocator bitmap, |
| 300 | * which will be freed later. |
| 301 | */ |
| 302 | reserve_bootmem_node(pgdat, bootmap_pfn << PAGE_SHIFT, |
| 303 | bootmap_pages << PAGE_SHIFT); |
| 304 | |
| 305 | /* |
| 306 | * Hmm... This should go elsewhere, but we really really need to |
| 307 | * stop things allocating the low memory; ideally we need a better |
| 308 | * implementation of GFP_DMA which does not assume that DMA-able |
| 309 | * memory starts at zero. |
| 310 | */ |
| 311 | if (machine_is_integrator() || machine_is_cintegrator()) |
| 312 | res_size = __pa(swapper_pg_dir) - PHYS_OFFSET; |
| 313 | |
| 314 | /* |
| 315 | * These should likewise go elsewhere. They pre-reserve the |
| 316 | * screen memory region at the start of main system memory. |
| 317 | */ |
| 318 | if (machine_is_edb7211()) |
| 319 | res_size = 0x00020000; |
| 320 | if (machine_is_p720t()) |
| 321 | res_size = 0x00014000; |
| 322 | |
| 323 | #ifdef CONFIG_SA1111 |
| 324 | /* |
| 325 | * Because of the SA1111 DMA bug, we want to preserve our |
| 326 | * precious DMA-able memory... |
| 327 | */ |
| 328 | res_size = __pa(swapper_pg_dir) - PHYS_OFFSET; |
| 329 | #endif |
| 330 | if (res_size) |
| 331 | reserve_bootmem_node(pgdat, PHYS_OFFSET, res_size); |
| 332 | } |
| 333 | |
| 334 | /* |
| 335 | * Register all available RAM in this node with the bootmem allocator. |
| 336 | */ |
| 337 | static inline void free_bootmem_node_bank(int node, struct meminfo *mi) |
| 338 | { |
| 339 | pg_data_t *pgdat = NODE_DATA(node); |
| 340 | int bank; |
| 341 | |
| 342 | for (bank = 0; bank < mi->nr_banks; bank++) |
| 343 | if (mi->bank[bank].node == node) |
| 344 | free_bootmem_node(pgdat, mi->bank[bank].start, |
| 345 | mi->bank[bank].size); |
| 346 | } |
| 347 | |
| 348 | /* |
| 349 | * Initialise the bootmem allocator for all nodes. This is called |
| 350 | * early during the architecture specific initialisation. |
| 351 | */ |
| 352 | static void __init bootmem_init(struct meminfo *mi) |
| 353 | { |
| 354 | struct node_info node_info[MAX_NUMNODES], *np = node_info; |
| 355 | unsigned int bootmap_pages, bootmap_pfn, map_pg; |
| 356 | int node, initrd_node; |
| 357 | |
| 358 | bootmap_pages = find_memend_and_nodes(mi, np); |
| 359 | bootmap_pfn = find_bootmap_pfn(0, mi, bootmap_pages); |
| 360 | initrd_node = check_initrd(mi); |
| 361 | |
| 362 | map_pg = bootmap_pfn; |
| 363 | |
| 364 | /* |
| 365 | * Initialise the bootmem nodes. |
| 366 | * |
| 367 | * What we really want to do is: |
| 368 | * |
| 369 | * unmap_all_regions_except_kernel(); |
| 370 | * for_each_node_in_reverse_order(node) { |
| 371 | * map_node(node); |
| 372 | * allocate_bootmem_map(node); |
| 373 | * init_bootmem_node(node); |
| 374 | * free_bootmem_node(node); |
| 375 | * } |
| 376 | * |
| 377 | * but this is a 2.5-type change. For now, we just set |
| 378 | * the nodes up in reverse order. |
| 379 | * |
| 380 | * (we could also do with rolling bootmem_init and paging_init |
| 381 | * into one generic "memory_init" type function). |
| 382 | */ |
| 383 | np += num_online_nodes() - 1; |
| 384 | for (node = num_online_nodes() - 1; node >= 0; node--, np--) { |
| 385 | /* |
| 386 | * If there are no pages in this node, ignore it. |
| 387 | * Note that node 0 must always have some pages. |
| 388 | */ |
| 389 | if (np->end == 0 || !node_online(node)) { |
| 390 | if (node == 0) |
| 391 | BUG(); |
| 392 | continue; |
| 393 | } |
| 394 | |
| 395 | /* |
| 396 | * Initialise the bootmem allocator. |
| 397 | */ |
| 398 | init_bootmem_node(NODE_DATA(node), map_pg, np->start, np->end); |
| 399 | free_bootmem_node_bank(node, mi); |
| 400 | map_pg += np->bootmap_pages; |
| 401 | |
| 402 | /* |
| 403 | * If this is node 0, we need to reserve some areas ASAP - |
| 404 | * we may use bootmem on node 0 to setup the other nodes. |
| 405 | */ |
| 406 | if (node == 0) |
| 407 | reserve_node_zero(bootmap_pfn, bootmap_pages); |
| 408 | } |
| 409 | |
| 410 | |
| 411 | #ifdef CONFIG_BLK_DEV_INITRD |
| 412 | if (phys_initrd_size && initrd_node >= 0) { |
| 413 | reserve_bootmem_node(NODE_DATA(initrd_node), phys_initrd_start, |
| 414 | phys_initrd_size); |
| 415 | initrd_start = __phys_to_virt(phys_initrd_start); |
| 416 | initrd_end = initrd_start + phys_initrd_size; |
| 417 | } |
| 418 | #endif |
| 419 | |
| 420 | BUG_ON(map_pg != bootmap_pfn + bootmap_pages); |
| 421 | } |
| 422 | |
| 423 | /* |
| 424 | * paging_init() sets up the page tables, initialises the zone memory |
| 425 | * maps, and sets up the zero page, bad page and bad page tables. |
| 426 | */ |
| 427 | void __init paging_init(struct meminfo *mi, struct machine_desc *mdesc) |
| 428 | { |
| 429 | void *zero_page; |
| 430 | int node; |
| 431 | |
| 432 | bootmem_init(mi); |
| 433 | |
| 434 | memcpy(&meminfo, mi, sizeof(meminfo)); |
| 435 | |
| 436 | /* |
| 437 | * allocate the zero page. Note that we count on this going ok. |
| 438 | */ |
| 439 | zero_page = alloc_bootmem_low_pages(PAGE_SIZE); |
| 440 | |
| 441 | /* |
| 442 | * initialise the page tables. |
| 443 | */ |
| 444 | memtable_init(mi); |
| 445 | if (mdesc->map_io) |
| 446 | mdesc->map_io(); |
| 447 | flush_tlb_all(); |
| 448 | |
| 449 | /* |
| 450 | * initialise the zones within each node |
| 451 | */ |
| 452 | for_each_online_node(node) { |
| 453 | unsigned long zone_size[MAX_NR_ZONES]; |
| 454 | unsigned long zhole_size[MAX_NR_ZONES]; |
| 455 | struct bootmem_data *bdata; |
| 456 | pg_data_t *pgdat; |
| 457 | int i; |
| 458 | |
| 459 | /* |
| 460 | * Initialise the zone size information. |
| 461 | */ |
| 462 | for (i = 0; i < MAX_NR_ZONES; i++) { |
| 463 | zone_size[i] = 0; |
| 464 | zhole_size[i] = 0; |
| 465 | } |
| 466 | |
| 467 | pgdat = NODE_DATA(node); |
| 468 | bdata = pgdat->bdata; |
| 469 | |
| 470 | /* |
| 471 | * The size of this node has already been determined. |
| 472 | * If we need to do anything fancy with the allocation |
| 473 | * of this memory to the zones, now is the time to do |
| 474 | * it. |
| 475 | */ |
| 476 | zone_size[0] = bdata->node_low_pfn - |
| 477 | (bdata->node_boot_start >> PAGE_SHIFT); |
| 478 | |
| 479 | /* |
| 480 | * If this zone has zero size, skip it. |
| 481 | */ |
| 482 | if (!zone_size[0]) |
| 483 | continue; |
| 484 | |
| 485 | /* |
| 486 | * For each bank in this node, calculate the size of the |
| 487 | * holes. holes = node_size - sum(bank_sizes_in_node) |
| 488 | */ |
| 489 | zhole_size[0] = zone_size[0]; |
| 490 | for (i = 0; i < mi->nr_banks; i++) { |
| 491 | if (mi->bank[i].node != node) |
| 492 | continue; |
| 493 | |
| 494 | zhole_size[0] -= mi->bank[i].size >> PAGE_SHIFT; |
| 495 | } |
| 496 | |
| 497 | /* |
| 498 | * Adjust the sizes according to any special |
| 499 | * requirements for this machine type. |
| 500 | */ |
| 501 | arch_adjust_zones(node, zone_size, zhole_size); |
| 502 | |
| 503 | free_area_init_node(node, pgdat, zone_size, |
| 504 | bdata->node_boot_start >> PAGE_SHIFT, zhole_size); |
| 505 | } |
| 506 | |
| 507 | /* |
| 508 | * finish off the bad pages once |
| 509 | * the mem_map is initialised |
| 510 | */ |
| 511 | memzero(zero_page, PAGE_SIZE); |
| 512 | empty_zero_page = virt_to_page(zero_page); |
| 513 | flush_dcache_page(empty_zero_page); |
| 514 | } |
| 515 | |
| 516 | static inline void free_area(unsigned long addr, unsigned long end, char *s) |
| 517 | { |
| 518 | unsigned int size = (end - addr) >> 10; |
| 519 | |
| 520 | for (; addr < end; addr += PAGE_SIZE) { |
| 521 | struct page *page = virt_to_page(addr); |
| 522 | ClearPageReserved(page); |
| 523 | set_page_count(page, 1); |
| 524 | free_page(addr); |
| 525 | totalram_pages++; |
| 526 | } |
| 527 | |
| 528 | if (size && s) |
| 529 | printk(KERN_INFO "Freeing %s memory: %dK\n", s, size); |
| 530 | } |
| 531 | |
| 532 | /* |
| 533 | * mem_init() marks the free areas in the mem_map and tells us how much |
| 534 | * memory is free. This is done after various parts of the system have |
| 535 | * claimed their memory after the kernel image. |
| 536 | */ |
| 537 | void __init mem_init(void) |
| 538 | { |
| 539 | unsigned int codepages, datapages, initpages; |
| 540 | int i, node; |
| 541 | |
| 542 | codepages = &_etext - &_text; |
| 543 | datapages = &_end - &__data_start; |
| 544 | initpages = &__init_end - &__init_begin; |
| 545 | |
| 546 | #ifndef CONFIG_DISCONTIGMEM |
| 547 | max_mapnr = virt_to_page(high_memory) - mem_map; |
| 548 | #endif |
| 549 | |
| 550 | /* |
| 551 | * We may have non-contiguous memory. |
| 552 | */ |
| 553 | if (meminfo.nr_banks != 1) |
| 554 | create_memmap_holes(&meminfo); |
| 555 | |
| 556 | /* this will put all unused low memory onto the freelists */ |
| 557 | for_each_online_node(node) { |
| 558 | pg_data_t *pgdat = NODE_DATA(node); |
| 559 | |
| 560 | if (pgdat->node_spanned_pages != 0) |
| 561 | totalram_pages += free_all_bootmem_node(pgdat); |
| 562 | } |
| 563 | |
| 564 | #ifdef CONFIG_SA1111 |
| 565 | /* now that our DMA memory is actually so designated, we can free it */ |
| 566 | free_area(PAGE_OFFSET, (unsigned long)swapper_pg_dir, NULL); |
| 567 | #endif |
| 568 | |
| 569 | /* |
| 570 | * Since our memory may not be contiguous, calculate the |
| 571 | * real number of pages we have in this system |
| 572 | */ |
| 573 | printk(KERN_INFO "Memory:"); |
| 574 | |
| 575 | num_physpages = 0; |
| 576 | for (i = 0; i < meminfo.nr_banks; i++) { |
| 577 | num_physpages += meminfo.bank[i].size >> PAGE_SHIFT; |
| 578 | printk(" %ldMB", meminfo.bank[i].size >> 20); |
| 579 | } |
| 580 | |
| 581 | printk(" = %luMB total\n", num_physpages >> (20 - PAGE_SHIFT)); |
| 582 | printk(KERN_NOTICE "Memory: %luKB available (%dK code, " |
| 583 | "%dK data, %dK init)\n", |
| 584 | (unsigned long) nr_free_pages() << (PAGE_SHIFT-10), |
| 585 | codepages >> 10, datapages >> 10, initpages >> 10); |
| 586 | |
| 587 | if (PAGE_SIZE >= 16384 && num_physpages <= 128) { |
| 588 | extern int sysctl_overcommit_memory; |
| 589 | /* |
| 590 | * On a machine this small we won't get |
| 591 | * anywhere without overcommit, so turn |
| 592 | * it on by default. |
| 593 | */ |
| 594 | sysctl_overcommit_memory = OVERCOMMIT_ALWAYS; |
| 595 | } |
| 596 | } |
| 597 | |
| 598 | void free_initmem(void) |
| 599 | { |
| 600 | if (!machine_is_integrator() && !machine_is_cintegrator()) { |
| 601 | free_area((unsigned long)(&__init_begin), |
| 602 | (unsigned long)(&__init_end), |
| 603 | "init"); |
| 604 | } |
| 605 | } |
| 606 | |
| 607 | #ifdef CONFIG_BLK_DEV_INITRD |
| 608 | |
| 609 | static int keep_initrd; |
| 610 | |
| 611 | void free_initrd_mem(unsigned long start, unsigned long end) |
| 612 | { |
| 613 | if (!keep_initrd) |
| 614 | free_area(start, end, "initrd"); |
| 615 | } |
| 616 | |
| 617 | static int __init keepinitrd_setup(char *__unused) |
| 618 | { |
| 619 | keep_initrd = 1; |
| 620 | return 1; |
| 621 | } |
| 622 | |
| 623 | __setup("keepinitrd", keepinitrd_setup); |
| 624 | #endif |