Eric Lee / linux-smarc-t335x-v3.2

Commit a581c2a4697ee264699b364399b73477af408e00

Authored by Heiko Carstens 2006-07-01 19:36:30 +0800

Committed by Linus Torvalds 2006-07-02 00:56:03 +0800

Exists in master and in 4 other branches

[PATCH] add __[start|end]_rodata sections to asm-generic/sections.h

Add __start_rodata and __end_rodata to sections.h to avoid extern
declarations.  Needed by s390 code (see following patch).

[akpm@osdl.org: update architectures]
Cc: Arjan van de Ven <arjan@infradead.org>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Andi Kleen <ak@muc.de>
Acked-by: Kyle McMartin <kyle@mcmartin.ca>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

Showing 4 changed files with 10 additions and 11 deletions Inline Diff

arch/i386/mm/init.c
arch/parisc/mm/init.c
arch/x86_64/mm/init.c
include/asm-generic/sections.h

arch/i386/mm/init.c

Diff comments View file @ a581c2a

 /*
  *  linux/arch/i386/mm/init.c
  *
  *  Copyright (C) 1995  Linus Torvalds
  *
  *  Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
  */
 #include <linux/module.h>
 #include <linux/signal.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/string.h>
 #include <linux/types.h>
 #include <linux/ptrace.h>
 #include <linux/mman.h>
 #include <linux/mm.h>
 #include <linux/hugetlb.h>
 #include <linux/swap.h>
 #include <linux/smp.h>
 #include <linux/init.h>
 #include <linux/highmem.h>
 #include <linux/pagemap.h>
 #include <linux/poison.h>
 #include <linux/bootmem.h>
 #include <linux/slab.h>
 #include <linux/proc_fs.h>
 #include <linux/efi.h>
 #include <linux/memory_hotplug.h>
 #include <linux/initrd.h>
 #include <linux/cpumask.h>
 #include <asm/processor.h>
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
 #include <asm/dma.h>
 #include <asm/fixmap.h>
 #include <asm/e820.h>
 #include <asm/apic.h>
 #include <asm/tlb.h>
 #include <asm/tlbflush.h>
 #include <asm/sections.h>
 unsigned int __VMALLOC_RESERVE = 128 << 20;
 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
 unsigned long highstart_pfn, highend_pfn;
 static int noinline do_test_wp_bit(void);
 /*
  * Creates a middle page table and puts a pointer to it in the
  * given global directory entry. This only returns the gd entry
  * in non-PAE compilation mode, since the middle layer is folded.
  */
 static pmd_t * __init one_md_table_init(pgd_t *pgd)
 {
 	pud_t *pud;
 	pmd_t *pmd_table;
 #ifdef CONFIG_X86_PAE
 	pmd_table = (pmd_t *) alloc_bootmem_low_pages(PAGE_SIZE);
 	set_pgd(pgd, __pgd(__pa(pmd_table) | _PAGE_PRESENT));
 	pud = pud_offset(pgd, 0);
 	if (pmd_table != pmd_offset(pud, 0))
 		BUG();
 #else
 	pud = pud_offset(pgd, 0);
 	pmd_table = pmd_offset(pud, 0);
 #endif
 	return pmd_table;
 }
 /*
  * Create a page table and place a pointer to it in a middle page
  * directory entry.
  */
 static pte_t * __init one_page_table_init(pmd_t *pmd)
 {
 	if (pmd_none(*pmd)) {
 		pte_t *page_table = (pte_t *) alloc_bootmem_low_pages(PAGE_SIZE);
 		set_pmd(pmd, __pmd(__pa(page_table) | _PAGE_TABLE));
 		if (page_table != pte_offset_kernel(pmd, 0))
 			BUG();
 		return page_table;
 	}
 	return pte_offset_kernel(pmd, 0);
 }
 /*
  * This function initializes a certain range of kernel virtual memory
  * with new bootmem page tables, everywhere page tables are missing in
  * the given range.
  */
 /*
  * NOTE: The pagetables are allocated contiguous on the physical space
  * so we can cache the place of the first one and move around without
  * checking the pgd every time.
  */
 static void __init page_table_range_init (unsigned long start, unsigned long end, pgd_t *pgd_base)
 {
 	pgd_t *pgd;
 	pud_t *pud;
 	pmd_t *pmd;
 	int pgd_idx, pmd_idx;
 	unsigned long vaddr;
 	vaddr = start;
 	pgd_idx = pgd_index(vaddr);
 	pmd_idx = pmd_index(vaddr);
 	pgd = pgd_base + pgd_idx;
 	for ( ; (pgd_idx < PTRS_PER_PGD) && (vaddr != end); pgd++, pgd_idx++) {
 		if (pgd_none(*pgd))
 			one_md_table_init(pgd);
 		pud = pud_offset(pgd, vaddr);
 		pmd = pmd_offset(pud, vaddr);
 		for (; (pmd_idx < PTRS_PER_PMD) && (vaddr != end); pmd++, pmd_idx++) {
 			if (pmd_none(*pmd))
 				one_page_table_init(pmd);
 			vaddr += PMD_SIZE;
 		}
 		pmd_idx = 0;
 	}
 }
 static inline int is_kernel_text(unsigned long addr)
 {
 	if (addr >= PAGE_OFFSET && addr <= (unsigned long)__init_end)
 		return 1;
 	return 0;
 }
 /*
  * This maps the physical memory to kernel virtual address space, a total
  * of max_low_pfn pages, by creating page tables starting from address
  * PAGE_OFFSET.
  */
 static void __init kernel_physical_mapping_init(pgd_t *pgd_base)
 {
 	unsigned long pfn;
 	pgd_t *pgd;
 	pmd_t *pmd;
 	pte_t *pte;
 	int pgd_idx, pmd_idx, pte_ofs;
 	pgd_idx = pgd_index(PAGE_OFFSET);
 	pgd = pgd_base + pgd_idx;
 	pfn = 0;
 	for (; pgd_idx < PTRS_PER_PGD; pgd++, pgd_idx++) {
 		pmd = one_md_table_init(pgd);
 		if (pfn >= max_low_pfn)
 			continue;
 		for (pmd_idx = 0; pmd_idx < PTRS_PER_PMD && pfn < max_low_pfn; pmd++, pmd_idx++) {
 			unsigned int address = pfn * PAGE_SIZE + PAGE_OFFSET;
 			/* Map with big pages if possible, otherwise create normal page tables. */
 			if (cpu_has_pse) {
 				unsigned int address2 = (pfn + PTRS_PER_PTE - 1) * PAGE_SIZE + PAGE_OFFSET + PAGE_SIZE-1;
 				if (is_kernel_text(address) || is_kernel_text(address2))
 					set_pmd(pmd, pfn_pmd(pfn, PAGE_KERNEL_LARGE_EXEC));
 				else
 					set_pmd(pmd, pfn_pmd(pfn, PAGE_KERNEL_LARGE));
 				pfn += PTRS_PER_PTE;
 			} else {
 				pte = one_page_table_init(pmd);
 				for (pte_ofs = 0; pte_ofs < PTRS_PER_PTE && pfn < max_low_pfn; pte++, pfn++, pte_ofs++) {
 						if (is_kernel_text(address))
 							set_pte(pte, pfn_pte(pfn, PAGE_KERNEL_EXEC));
 						else
 							set_pte(pte, pfn_pte(pfn, PAGE_KERNEL));
 				}
 			}
 		}
 	}
 }
 static inline int page_kills_ppro(unsigned long pagenr)
 {
 	if (pagenr >= 0x70000 && pagenr <= 0x7003F)
 		return 1;
 	return 0;
 }
 extern int is_available_memory(efi_memory_desc_t *);
 int page_is_ram(unsigned long pagenr)
 {
 	int i;
 	unsigned long addr, end;
 	if (efi_enabled) {
 		efi_memory_desc_t *md;
 		void *p;
 		for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
 			md = p;
 			if (!is_available_memory(md))
 				continue;
 			addr = (md->phys_addr+PAGE_SIZE-1) >> PAGE_SHIFT;
 			end = (md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT)) >> PAGE_SHIFT;
 			if ((pagenr >= addr) && (pagenr < end))
 				return 1;
 		}
 		return 0;
 	}
 	for (i = 0; i < e820.nr_map; i++) {
 		if (e820.map[i].type != E820_RAM)	/* not usable memory */
 			continue;
 		/*
 		 *	!!!FIXME!!! Some BIOSen report areas as RAM that
 		 *	are not. Notably the 640->1Mb area. We need a sanity
 		 *	check here.
 		 */
 		addr = (e820.map[i].addr+PAGE_SIZE-1) >> PAGE_SHIFT;
 		end = (e820.map[i].addr+e820.map[i].size) >> PAGE_SHIFT;
 		if  ((pagenr >= addr) && (pagenr < end))
 			return 1;
 	}
 	return 0;
 }
 #ifdef CONFIG_HIGHMEM
 pte_t *kmap_pte;
 pgprot_t kmap_prot;
 #define kmap_get_fixmap_pte(vaddr)					\
 	pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr), vaddr), (vaddr)), (vaddr))
 static void __init kmap_init(void)
 {
 	unsigned long kmap_vstart;
 	/* cache the first kmap pte */
 	kmap_vstart = __fix_to_virt(FIX_KMAP_BEGIN);
 	kmap_pte = kmap_get_fixmap_pte(kmap_vstart);
 	kmap_prot = PAGE_KERNEL;
 }
 static void __init permanent_kmaps_init(pgd_t *pgd_base)
 {
 	pgd_t *pgd;
 	pud_t *pud;
 	pmd_t *pmd;
 	pte_t *pte;
 	unsigned long vaddr;
 	vaddr = PKMAP_BASE;
 	page_table_range_init(vaddr, vaddr + PAGE_SIZE*LAST_PKMAP, pgd_base);
 	pgd = swapper_pg_dir + pgd_index(vaddr);
 	pud = pud_offset(pgd, vaddr);
 	pmd = pmd_offset(pud, vaddr);
 	pte = pte_offset_kernel(pmd, vaddr);
 	pkmap_page_table = pte;
 }
 static void __meminit free_new_highpage(struct page *page)
 {
 	init_page_count(page);
 	__free_page(page);
 	totalhigh_pages++;
 }
 void __init add_one_highpage_init(struct page *page, int pfn, int bad_ppro)
 {
 	if (page_is_ram(pfn) && !(bad_ppro && page_kills_ppro(pfn))) {
 		ClearPageReserved(page);
 		free_new_highpage(page);
 	} else
 		SetPageReserved(page);
 }
 static int add_one_highpage_hotplug(struct page *page, unsigned long pfn)
 {
 	free_new_highpage(page);
 	totalram_pages++;
 #ifdef CONFIG_FLATMEM
 	max_mapnr = max(pfn, max_mapnr);
 #endif
 	num_physpages++;
 	return 0;
 }
 /*
  * Not currently handling the NUMA case.
  * Assuming single node and all memory that
  * has been added dynamically that would be
  * onlined here is in HIGHMEM
  */
 void online_page(struct page *page)
 {
 	ClearPageReserved(page);
 	add_one_highpage_hotplug(page, page_to_pfn(page));
 }
 #ifdef CONFIG_NUMA
 extern void set_highmem_pages_init(int);
 #else
 static void __init set_highmem_pages_init(int bad_ppro)
 {
 	int pfn;
 	for (pfn = highstart_pfn; pfn < highend_pfn; pfn++)
 		add_one_highpage_init(pfn_to_page(pfn), pfn, bad_ppro);
 	totalram_pages += totalhigh_pages;
 }
 #endif /* CONFIG_FLATMEM */
 #else
 #define kmap_init() do { } while (0)
 #define permanent_kmaps_init(pgd_base) do { } while (0)
 #define set_highmem_pages_init(bad_ppro) do { } while (0)
 #endif /* CONFIG_HIGHMEM */
 unsigned long long __PAGE_KERNEL = _PAGE_KERNEL;
 EXPORT_SYMBOL(__PAGE_KERNEL);
 unsigned long long __PAGE_KERNEL_EXEC = _PAGE_KERNEL_EXEC;
 #ifdef CONFIG_NUMA
 extern void __init remap_numa_kva(void);
 #else
 #define remap_numa_kva() do {} while (0)
 #endif
 static void __init pagetable_init (void)
 {
 	unsigned long vaddr;
 	pgd_t *pgd_base = swapper_pg_dir;
 #ifdef CONFIG_X86_PAE
 	int i;
 	/* Init entries of the first-level page table to the zero page */
 	for (i = 0; i < PTRS_PER_PGD; i++)
 		set_pgd(pgd_base + i, __pgd(__pa(empty_zero_page) | _PAGE_PRESENT));
 #endif
 	/* Enable PSE if available */
 	if (cpu_has_pse) {
 		set_in_cr4(X86_CR4_PSE);
 	}
 	/* Enable PGE if available */
 	if (cpu_has_pge) {
 		set_in_cr4(X86_CR4_PGE);
 		__PAGE_KERNEL |= _PAGE_GLOBAL;
 		__PAGE_KERNEL_EXEC |= _PAGE_GLOBAL;
 	}
 	kernel_physical_mapping_init(pgd_base);
 	remap_numa_kva();
 	/*
 	 * Fixed mappings, only the page table structure has to be
 	 * created - mappings will be set by set_fixmap():
 	 */
 	vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
 	page_table_range_init(vaddr, 0, pgd_base);
 	permanent_kmaps_init(pgd_base);
 #ifdef CONFIG_X86_PAE
 	/*
 	 * Add low memory identity-mappings - SMP needs it when
 	 * starting up on an AP from real-mode. In the non-PAE
 	 * case we already have these mappings through head.S.
 	 * All user-space mappings are explicitly cleared after
 	 * SMP startup.
 	 */
 	set_pgd(&pgd_base[0], pgd_base[USER_PTRS_PER_PGD]);
 #endif
 }
 #if defined(CONFIG_SOFTWARE_SUSPEND) || defined(CONFIG_ACPI_SLEEP)
 /*
  * Swap suspend & friends need this for resume because things like the intel-agp
  * driver might have split up a kernel 4MB mapping.
  */
 char __nosavedata swsusp_pg_dir[PAGE_SIZE]
 	__attribute__ ((aligned (PAGE_SIZE)));
 static inline void save_pg_dir(void)
 {
 	memcpy(swsusp_pg_dir, swapper_pg_dir, PAGE_SIZE);
 }
 #else
 static inline void save_pg_dir(void)
 {
 }
 #endif
 void zap_low_mappings (void)
 {
 	int i;
 	save_pg_dir();
 	/*
 	 * Zap initial low-memory mappings.
 	 *
 	 * Note that "pgd_clear()" doesn't do it for
 	 * us, because pgd_clear() is a no-op on i386.
 	 */
 	for (i = 0; i < USER_PTRS_PER_PGD; i++)
 #ifdef CONFIG_X86_PAE
 		set_pgd(swapper_pg_dir+i, __pgd(1 + __pa(empty_zero_page)));
 #else
 		set_pgd(swapper_pg_dir+i, __pgd(0));
 #endif
 	flush_tlb_all();
 }
 static int disable_nx __initdata = 0;
 u64 __supported_pte_mask __read_mostly = ~_PAGE_NX;
 /*
  * noexec = on|off
  *
  * Control non executable mappings.
  *
  * on      Enable
  * off     Disable
  */
 void __init noexec_setup(const char *str)
 {
 	if (!strncmp(str, "on",2) && cpu_has_nx) {
 		__supported_pte_mask |= _PAGE_NX;
 		disable_nx = 0;
 	} else if (!strncmp(str,"off",3)) {
 		disable_nx = 1;
 		__supported_pte_mask &= ~_PAGE_NX;
 	}
 }
 int nx_enabled = 0;
 #ifdef CONFIG_X86_PAE
 static void __init set_nx(void)
 {
 	unsigned int v[4], l, h;
 	if (cpu_has_pae && (cpuid_eax(0x80000000) > 0x80000001)) {
 		cpuid(0x80000001, &v[0], &v[1], &v[2], &v[3]);
 		if ((v[3] & (1 << 20)) && !disable_nx) {
 			rdmsr(MSR_EFER, l, h);
 			l |= EFER_NX;
 			wrmsr(MSR_EFER, l, h);
 			nx_enabled = 1;
 			__supported_pte_mask |= _PAGE_NX;
 		}
 	}
 }
 /*
  * Enables/disables executability of a given kernel page and
  * returns the previous setting.
  */
 int __init set_kernel_exec(unsigned long vaddr, int enable)
 {
 	pte_t *pte;
 	int ret = 1;
 	if (!nx_enabled)
 		goto out;
 	pte = lookup_address(vaddr);
 	BUG_ON(!pte);
 	if (!pte_exec_kernel(*pte))
 		ret = 0;
 	if (enable)
 		pte->pte_high &= ~(1 << (_PAGE_BIT_NX - 32));
 	else
 		pte->pte_high |= 1 << (_PAGE_BIT_NX - 32);
 	__flush_tlb_all();
 out:
 	return ret;
 }
 #endif
 /*
  * paging_init() sets up the page tables - note that the first 8MB are
  * already mapped by head.S.
  *
  * This routines also unmaps the page at virtual kernel address 0, so
  * that we can trap those pesky NULL-reference errors in the kernel.
  */
 void __init paging_init(void)
 {
 #ifdef CONFIG_X86_PAE
 	set_nx();
 	if (nx_enabled)
 		printk("NX (Execute Disable) protection: active\n");
 #endif
 	pagetable_init();
 	load_cr3(swapper_pg_dir);
 #ifdef CONFIG_X86_PAE
 	/*
 	 * We will bail out later - printk doesn't work right now so
 	 * the user would just see a hanging kernel.
 	 */
 	if (cpu_has_pae)
 		set_in_cr4(X86_CR4_PAE);
 #endif
 	__flush_tlb_all();
 	kmap_init();
 }
 /*
  * Test if the WP bit works in supervisor mode. It isn't supported on 386's
  * and also on some strange 486's (NexGen etc.). All 586+'s are OK. This
  * used to involve black magic jumps to work around some nasty CPU bugs,
  * but fortunately the switch to using exceptions got rid of all that.
  */
 static void __init test_wp_bit(void)
 {
 	printk("Checking if this processor honours the WP bit even in supervisor mode... ");
 	/* Any page-aligned address will do, the test is non-destructive */
 	__set_fixmap(FIX_WP_TEST, __pa(&swapper_pg_dir), PAGE_READONLY);
 	boot_cpu_data.wp_works_ok = do_test_wp_bit();
 	clear_fixmap(FIX_WP_TEST);
 	if (!boot_cpu_data.wp_works_ok) {
 		printk("No.\n");
 #ifdef CONFIG_X86_WP_WORKS_OK
 		panic("This kernel doesn't support CPU's with broken WP. Recompile it for a 386!");
 #endif
 	} else {
 		printk("Ok.\n");
 	}
 }
 static void __init set_max_mapnr_init(void)
 {
 #ifdef CONFIG_HIGHMEM
 	num_physpages = highend_pfn;
 #else
 	num_physpages = max_low_pfn;
 #endif
 #ifdef CONFIG_FLATMEM
 	max_mapnr = num_physpages;
 #endif
 }
 static struct kcore_list kcore_mem, kcore_vmalloc;
 void __init mem_init(void)
 {
 	extern int ppro_with_ram_bug(void);
 	int codesize, reservedpages, datasize, initsize;
 	int tmp;
 	int bad_ppro;
 #ifdef CONFIG_FLATMEM
 	if (!mem_map)
 		BUG();
 #endif
 	bad_ppro = ppro_with_ram_bug();
 #ifdef CONFIG_HIGHMEM
 	/* check that fixmap and pkmap do not overlap */
 	if (PKMAP_BASE+LAST_PKMAP*PAGE_SIZE >= FIXADDR_START) {
 		printk(KERN_ERR "fixmap and kmap areas overlap - this will crash\n");
 		printk(KERN_ERR "pkstart: %lxh pkend: %lxh fixstart %lxh\n",
 				PKMAP_BASE, PKMAP_BASE+LAST_PKMAP*PAGE_SIZE, FIXADDR_START);
 		BUG();
 	}
 #endif
 	set_max_mapnr_init();
 #ifdef CONFIG_HIGHMEM
 	high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;
 #else
 	high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1;
 #endif
 	/* this will put all low memory onto the freelists */
 	totalram_pages += free_all_bootmem();
 	reservedpages = 0;
 	for (tmp = 0; tmp < max_low_pfn; tmp++)
 		/*
 		 * Only count reserved RAM pages
 		 */
 		if (page_is_ram(tmp) && PageReserved(pfn_to_page(tmp)))
 			reservedpages++;
 	set_highmem_pages_init(bad_ppro);
 	codesize =  (unsigned long) &_etext - (unsigned long) &_text;
 	datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
 	initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
 	kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT);
 	kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
 		   VMALLOC_END-VMALLOC_START);
 	printk(KERN_INFO "Memory: %luk/%luk available (%dk kernel code, %dk reserved, %dk data, %dk init, %ldk highmem)\n",
 		(unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
 		num_physpages << (PAGE_SHIFT-10),
 		codesize >> 10,
 		reservedpages << (PAGE_SHIFT-10),
 		datasize >> 10,
 		initsize >> 10,
 		(unsigned long) (totalhigh_pages << (PAGE_SHIFT-10))
 	       );
 #ifdef CONFIG_X86_PAE
 	if (!cpu_has_pae)
 		panic("cannot execute a PAE-enabled kernel on a PAE-less CPU!");
 #endif
 	if (boot_cpu_data.wp_works_ok < 0)
 		test_wp_bit();
 	/*
 	 * Subtle. SMP is doing it's boot stuff late (because it has to
 	 * fork idle threads) - but it also needs low mappings for the
 	 * protected-mode entry to work. We zap these entries only after
 	 * the WP-bit has been tested.
 	 */
 #ifndef CONFIG_SMP
 	zap_low_mappings();
 #endif
 }
 /*
  * this is for the non-NUMA, single node SMP system case.
  * Specifically, in the case of x86, we will always add
  * memory to the highmem for now.
  */
 #ifdef CONFIG_MEMORY_HOTPLUG
 #ifndef CONFIG_NEED_MULTIPLE_NODES
 int arch_add_memory(int nid, u64 start, u64 size)
 {
 	struct pglist_data *pgdata = &contig_page_data;
 	struct zone *zone = pgdata->node_zones + MAX_NR_ZONES-1;
 	unsigned long start_pfn = start >> PAGE_SHIFT;
 	unsigned long nr_pages = size >> PAGE_SHIFT;
 	return __add_pages(zone, start_pfn, nr_pages);
 }
 int remove_memory(u64 start, u64 size)
 {
 	return -EINVAL;
 }
 #endif
 #endif
 kmem_cache_t *pgd_cache;
 kmem_cache_t *pmd_cache;
 void __init pgtable_cache_init(void)
 {
 	if (PTRS_PER_PMD > 1) {
 		pmd_cache = kmem_cache_create("pmd",
 					PTRS_PER_PMD*sizeof(pmd_t),
 					PTRS_PER_PMD*sizeof(pmd_t),
 					0,
 					pmd_ctor,
 					NULL);
 		if (!pmd_cache)
 			panic("pgtable_cache_init(): cannot create pmd cache");
 	}
 	pgd_cache = kmem_cache_create("pgd",
 				PTRS_PER_PGD*sizeof(pgd_t),
 				PTRS_PER_PGD*sizeof(pgd_t),
 				0,
 				pgd_ctor,
 				PTRS_PER_PMD == 1 ? pgd_dtor : NULL);
 	if (!pgd_cache)
 		panic("pgtable_cache_init(): Cannot create pgd cache");
 }
 /*
  * This function cannot be __init, since exceptions don't work in that
  * section.  Put this after the callers, so that it cannot be inlined.
  */
 static int noinline do_test_wp_bit(void)
 {
 	char tmp_reg;
 	int flag;
 	__asm__ __volatile__(
 		"	movb %0,%1	\n"
 		"1:	movb %1,%0	\n"
 		"	xorl %2,%2	\n"
 		"2:			\n"
 		".section __ex_table,\"a\"\n"
 		"	.align 4	\n"
 		"	.long 1b,2b	\n"
 		".previous		\n"
 		:"=m" (*(char *)fix_to_virt(FIX_WP_TEST)),
 		 "=q" (tmp_reg),
 		 "=r" (flag)
 		:"2" (1)
 		:"memory");
 	return flag;
 }
 #ifdef CONFIG_DEBUG_RODATA
-extern char __start_rodata, __end_rodata;
 void mark_rodata_ro(void)
 {
-	unsigned long addr = (unsigned long)&__start_rodata;
+	unsigned long addr = (unsigned long)__start_rodata;
-	for (; addr < (unsigned long)&__end_rodata; addr += PAGE_SIZE)
+	for (; addr < (unsigned long)__end_rodata; addr += PAGE_SIZE)
 		change_page_attr(virt_to_page(addr), 1, PAGE_KERNEL_RO);
-	printk ("Write protecting the kernel read-only data: %luk\n",
+	printk("Write protecting the kernel read-only data: %uk\n",
-			(unsigned long)(&__end_rodata - &__start_rodata) >> 10);
+			(__end_rodata - __start_rodata) >> 10);
 	/*
 	 * change_page_attr() requires a global_flush_tlb() call after it.
 	 * We do this after the printk so that if something went wrong in the
 	 * change, the printk gets out at least to give a better debug hint
 	 * of who is the culprit.
 	 */
 	global_flush_tlb();
 }
 #endif
 void free_init_pages(char *what, unsigned long begin, unsigned long end)
 {
 	unsigned long addr;
 	for (addr = begin; addr < end; addr += PAGE_SIZE) {
 		ClearPageReserved(virt_to_page(addr));
 		init_page_count(virt_to_page(addr));
 		memset((void *)addr, POISON_FREE_INITMEM, PAGE_SIZE);
 		free_page(addr);
 		totalram_pages++;
 	}
 	printk(KERN_INFO "Freeing %s: %ldk freed\n", what, (end - begin) >> 10);
 }
 void free_initmem(void)
 {
 	free_init_pages("unused kernel memory",
 			(unsigned long)(&__init_begin),
 			(unsigned long)(&__init_end));
 }
 #ifdef CONFIG_BLK_DEV_INITRD
 void free_initrd_mem(unsigned long start, unsigned long end)
 {
 	free_init_pages("initrd memory", start, end);
 }
 #endif

arch/parisc/mm/init.c

Diff comments View file @ a581c2a

 /*
  *  linux/arch/parisc/mm/init.c
  *
  *  Copyright (C) 1995	Linus Torvalds
  *  Copyright 1999 SuSE GmbH
  *    changed by Philipp Rumpf
  *  Copyright 1999 Philipp Rumpf (prumpf@tux.org)
  *  Copyright 2004 Randolph Chung (tausq@debian.org)
  *  Copyright 2006 Helge Deller (deller@gmx.de)
  *
  */
 #include <linux/module.h>
 #include <linux/mm.h>
 #include <linux/bootmem.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/pci.h>		/* for hppa_dma_ops and pcxl_dma_ops */
 #include <linux/initrd.h>
 #include <linux/swap.h>
 #include <linux/unistd.h>
 #include <linux/nodemask.h>	/* for node_online_map */
 #include <linux/pagemap.h>	/* for release_pages and page_cache_release */
 #include <asm/pgalloc.h>
 #include <asm/tlb.h>
 #include <asm/pdc_chassis.h>
 #include <asm/mmzone.h>
+#include <asm/sections.h>
 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
 extern char _text;	/* start of kernel code, defined by linker */
 extern int  data_start;
 extern char _end;	/* end of BSS, defined by linker */
 extern char __init_begin, __init_end;
 #ifdef CONFIG_DISCONTIGMEM
 struct node_map_data node_data[MAX_NUMNODES] __read_mostly;
 bootmem_data_t bmem_data[MAX_NUMNODES] __read_mostly;
 unsigned char pfnnid_map[PFNNID_MAP_MAX] __read_mostly;
 #endif
 static struct resource data_resource = {
 	.name	= "Kernel data",
 	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM,
 };
 static struct resource code_resource = {
 	.name	= "Kernel code",
 	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM,
 };
 static struct resource pdcdata_resource = {
 	.name	= "PDC data (Page Zero)",
 	.start	= 0,
 	.end	= 0x9ff,
 	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM,
 };
 static struct resource sysram_resources[MAX_PHYSMEM_RANGES] __read_mostly;
 /* The following array is initialized from the firmware specific
  * information retrieved in kernel/inventory.c.
  */
 physmem_range_t pmem_ranges[MAX_PHYSMEM_RANGES] __read_mostly;
 int npmem_ranges __read_mostly;
 #ifdef __LP64__
 #define MAX_MEM         (~0UL)
 #else /* !__LP64__ */
 #define MAX_MEM         (3584U*1024U*1024U)
 #endif /* !__LP64__ */
 static unsigned long mem_limit __read_mostly = MAX_MEM;
 static void __init mem_limit_func(void)
 {
 	char *cp, *end;
 	unsigned long limit;
 	extern char saved_command_line[];
 	/* We need this before __setup() functions are called */
 	limit = MAX_MEM;
 	for (cp = saved_command_line; *cp; ) {
 		if (memcmp(cp, "mem=", 4) == 0) {
 			cp += 4;
 			limit = memparse(cp, &end);
 			if (end != cp)
 				break;
 			cp = end;
 		} else {
 			while (*cp != ' ' && *cp)
 				++cp;
 			while (*cp == ' ')
 				++cp;
 		}
 	}
 	if (limit < mem_limit)
 		mem_limit = limit;
 }
 #define MAX_GAP (0x40000000UL >> PAGE_SHIFT)
 static void __init setup_bootmem(void)
 {
 	unsigned long bootmap_size;
 	unsigned long mem_max;
 	unsigned long bootmap_pages;
 	unsigned long bootmap_start_pfn;
 	unsigned long bootmap_pfn;
 #ifndef CONFIG_DISCONTIGMEM
 	physmem_range_t pmem_holes[MAX_PHYSMEM_RANGES - 1];
 	int npmem_holes;
 #endif
 	int i, sysram_resource_count;
 	disable_sr_hashing(); /* Turn off space register hashing */
 	/*
 	 * Sort the ranges. Since the number of ranges is typically
 	 * small, and performance is not an issue here, just do
 	 * a simple insertion sort.
 	 */
 	for (i = 1; i < npmem_ranges; i++) {
 		int j;
 		for (j = i; j > 0; j--) {
 			unsigned long tmp;
 			if (pmem_ranges[j-1].start_pfn <
 			    pmem_ranges[j].start_pfn) {
 				break;
 			}
 			tmp = pmem_ranges[j-1].start_pfn;
 			pmem_ranges[j-1].start_pfn = pmem_ranges[j].start_pfn;
 			pmem_ranges[j].start_pfn = tmp;
 			tmp = pmem_ranges[j-1].pages;
 			pmem_ranges[j-1].pages = pmem_ranges[j].pages;
 			pmem_ranges[j].pages = tmp;
 		}
 	}
 #ifndef CONFIG_DISCONTIGMEM
 	/*
 	 * Throw out ranges that are too far apart (controlled by
 	 * MAX_GAP).
 	 */
 	for (i = 1; i < npmem_ranges; i++) {
 		if (pmem_ranges[i].start_pfn -
 			(pmem_ranges[i-1].start_pfn +
 			 pmem_ranges[i-1].pages) > MAX_GAP) {
 			npmem_ranges = i;
 			printk("Large gap in memory detected (%ld pages). "
 			       "Consider turning on CONFIG_DISCONTIGMEM\n",
 			       pmem_ranges[i].start_pfn -
 			       (pmem_ranges[i-1].start_pfn +
 			        pmem_ranges[i-1].pages));
 			break;
 		}
 	}
 #endif
 	if (npmem_ranges > 1) {
 		/* Print the memory ranges */
 		printk(KERN_INFO "Memory Ranges:\n");
 		for (i = 0; i < npmem_ranges; i++) {
 			unsigned long start;
 			unsigned long size;
 			size = (pmem_ranges[i].pages << PAGE_SHIFT);
 			start = (pmem_ranges[i].start_pfn << PAGE_SHIFT);
 			printk(KERN_INFO "%2d) Start 0x%016lx End 0x%016lx Size %6ld MB\n",
 				i,start, start + (size - 1), size >> 20);
 		}
 	}
 	sysram_resource_count = npmem_ranges;
 	for (i = 0; i < sysram_resource_count; i++) {
 		struct resource *res = &sysram_resources[i];
 		res->name = "System RAM";
 		res->start = pmem_ranges[i].start_pfn << PAGE_SHIFT;
 		res->end = res->start + (pmem_ranges[i].pages << PAGE_SHIFT)-1;
 		res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
 		request_resource(&iomem_resource, res);
 	}
 	/*
 	 * For 32 bit kernels we limit the amount of memory we can
 	 * support, in order to preserve enough kernel address space
 	 * for other purposes. For 64 bit kernels we don't normally
 	 * limit the memory, but this mechanism can be used to
 	 * artificially limit the amount of memory (and it is written
 	 * to work with multiple memory ranges).
 	 */
 	mem_limit_func();       /* check for "mem=" argument */
 	mem_max = 0;
 	num_physpages = 0;
 	for (i = 0; i < npmem_ranges; i++) {
 		unsigned long rsize;
 		rsize = pmem_ranges[i].pages << PAGE_SHIFT;
 		if ((mem_max + rsize) > mem_limit) {
 			printk(KERN_WARNING "Memory truncated to %ld MB\n", mem_limit >> 20);
 			if (mem_max == mem_limit)
 				npmem_ranges = i;
 			else {
 				pmem_ranges[i].pages =   (mem_limit >> PAGE_SHIFT)
 						       - (mem_max >> PAGE_SHIFT);
 				npmem_ranges = i + 1;
 				mem_max = mem_limit;
 			}
 	        num_physpages += pmem_ranges[i].pages;
 			break;
 		}
 	    num_physpages += pmem_ranges[i].pages;
 		mem_max += rsize;
 	}
 	printk(KERN_INFO "Total Memory: %ld MB\n",mem_max >> 20);
 #ifndef CONFIG_DISCONTIGMEM
 	/* Merge the ranges, keeping track of the holes */
 	{
 		unsigned long end_pfn;
 		unsigned long hole_pages;
 		npmem_holes = 0;
 		end_pfn = pmem_ranges[0].start_pfn + pmem_ranges[0].pages;
 		for (i = 1; i < npmem_ranges; i++) {
 			hole_pages = pmem_ranges[i].start_pfn - end_pfn;
 			if (hole_pages) {
 				pmem_holes[npmem_holes].start_pfn = end_pfn;
 				pmem_holes[npmem_holes++].pages = hole_pages;
 				end_pfn += hole_pages;
 			}
 			end_pfn += pmem_ranges[i].pages;
 		}
 		pmem_ranges[0].pages = end_pfn - pmem_ranges[0].start_pfn;
 		npmem_ranges = 1;
 	}
 #endif
 	bootmap_pages = 0;
 	for (i = 0; i < npmem_ranges; i++)
 		bootmap_pages += bootmem_bootmap_pages(pmem_ranges[i].pages);
 	bootmap_start_pfn = PAGE_ALIGN(__pa((unsigned long) &_end)) >> PAGE_SHIFT;
 #ifdef CONFIG_DISCONTIGMEM
 	for (i = 0; i < MAX_PHYSMEM_RANGES; i++) {
 		memset(NODE_DATA(i), 0, sizeof(pg_data_t));
 		NODE_DATA(i)->bdata = &bmem_data[i];
 	}
 	memset(pfnnid_map, 0xff, sizeof(pfnnid_map));
 	for (i = 0; i < npmem_ranges; i++)
 		node_set_online(i);
 #endif
 	/*
 	 * Initialize and free the full range of memory in each range.
 	 * Note that the only writing these routines do are to the bootmap,
 	 * and we've made sure to locate the bootmap properly so that they
 	 * won't be writing over anything important.
 	 */
 	bootmap_pfn = bootmap_start_pfn;
 	max_pfn = 0;
 	for (i = 0; i < npmem_ranges; i++) {
 		unsigned long start_pfn;
 		unsigned long npages;
 		start_pfn = pmem_ranges[i].start_pfn;
 		npages = pmem_ranges[i].pages;
 		bootmap_size = init_bootmem_node(NODE_DATA(i),
 						bootmap_pfn,
 						start_pfn,
 						(start_pfn + npages) );
 		free_bootmem_node(NODE_DATA(i),
 				  (start_pfn << PAGE_SHIFT),
 				  (npages << PAGE_SHIFT) );
 		bootmap_pfn += (bootmap_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
 		if ((start_pfn + npages) > max_pfn)
 			max_pfn = start_pfn + npages;
 	}
 	/* IOMMU is always used to access "high mem" on those boxes
 	 * that can support enough mem that a PCI device couldn't
 	 * directly DMA to any physical addresses.
 	 * ISA DMA support will need to revisit this.
 	 */
 	max_low_pfn = max_pfn;
 	if ((bootmap_pfn - bootmap_start_pfn) != bootmap_pages) {
 		printk(KERN_WARNING "WARNING! bootmap sizing is messed up!\n");
 		BUG();
 	}
 	/* reserve PAGE0 pdc memory, kernel text/data/bss & bootmap */
 #define PDC_CONSOLE_IO_IODC_SIZE 32768
 	reserve_bootmem_node(NODE_DATA(0), 0UL,
 			(unsigned long)(PAGE0->mem_free + PDC_CONSOLE_IO_IODC_SIZE));
 	reserve_bootmem_node(NODE_DATA(0),__pa((unsigned long)&_text),
 			(unsigned long)(&_end - &_text));
 	reserve_bootmem_node(NODE_DATA(0), (bootmap_start_pfn << PAGE_SHIFT),
 			((bootmap_pfn - bootmap_start_pfn) << PAGE_SHIFT));
 #ifndef CONFIG_DISCONTIGMEM
 	/* reserve the holes */
 	for (i = 0; i < npmem_holes; i++) {
 		reserve_bootmem_node(NODE_DATA(0),
 				(pmem_holes[i].start_pfn << PAGE_SHIFT),
 				(pmem_holes[i].pages << PAGE_SHIFT));
 	}
 #endif
 #ifdef CONFIG_BLK_DEV_INITRD
 	if (initrd_start) {
 		printk(KERN_INFO "initrd: %08lx-%08lx\n", initrd_start, initrd_end);
 		if (__pa(initrd_start) < mem_max) {
 			unsigned long initrd_reserve;
 			if (__pa(initrd_end) > mem_max) {
 				initrd_reserve = mem_max - __pa(initrd_start);
 			} else {
 				initrd_reserve = initrd_end - initrd_start;
 			}
 			initrd_below_start_ok = 1;
 			printk(KERN_INFO "initrd: reserving %08lx-%08lx (mem_max %08lx)\n", __pa(initrd_start), __pa(initrd_start) + initrd_reserve, mem_max);
 			reserve_bootmem_node(NODE_DATA(0),__pa(initrd_start), initrd_reserve);
 		}
 	}
 #endif
 	data_resource.start =  virt_to_phys(&data_start);
 	data_resource.end = virt_to_phys(&_end)-1;
 	code_resource.start = virt_to_phys(&_text);
 	code_resource.end = virt_to_phys(&data_start)-1;
 	/* We don't know which region the kernel will be in, so try
 	 * all of them.
 	 */
 	for (i = 0; i < sysram_resource_count; i++) {
 		struct resource *res = &sysram_resources[i];
 		request_resource(res, &code_resource);
 		request_resource(res, &data_resource);
 	}
 	request_resource(&sysram_resources[0], &pdcdata_resource);
 }
 void free_initmem(void)
 {
 	unsigned long addr, init_begin, init_end;
 	printk(KERN_INFO "Freeing unused kernel memory: ");
 #ifdef CONFIG_DEBUG_KERNEL
 	/* Attempt to catch anyone trying to execute code here
 	 * by filling the page with BRK insns.
 	 *
 	 * If we disable interrupts for all CPUs, then IPI stops working.
 	 * Kinda breaks the global cache flushing.
 	 */
 	local_irq_disable();
 	memset(&__init_begin, 0x00,
 		(unsigned long)&__init_end - (unsigned long)&__init_begin);
 	flush_data_cache();
 	asm volatile("sync" : : );
 	flush_icache_range((unsigned long)&__init_begin, (unsigned long)&__init_end);
 	asm volatile("sync" : : );
 	local_irq_enable();
 #endif
 	/* align __init_begin and __init_end to page size,
 	   ignoring linker script where we might have tried to save RAM */
 	init_begin = PAGE_ALIGN((unsigned long)(&__init_begin));
 	init_end   = PAGE_ALIGN((unsigned long)(&__init_end));
 	for (addr = init_begin; addr < init_end; addr += PAGE_SIZE) {
 		ClearPageReserved(virt_to_page(addr));
 		init_page_count(virt_to_page(addr));
 		free_page(addr);
 		num_physpages++;
 		totalram_pages++;
 	}
 	/* set up a new led state on systems shipped LED State panel */
 	pdc_chassis_send_status(PDC_CHASSIS_DIRECT_BCOMPLETE);
 	printk("%luk freed\n", (init_end - init_begin) >> 10);
 }
 #ifdef CONFIG_DEBUG_RODATA
 void mark_rodata_ro(void)
 {
-	extern char __start_rodata, __end_rodata;
 	/* rodata memory was already mapped with KERNEL_RO access rights by
            pagetable_init() and map_pages(). No need to do additional stuff here */
 	printk (KERN_INFO "Write protecting the kernel read-only data: %luk\n",
-		(unsigned long)(&__end_rodata - &__start_rodata) >> 10);
+		(unsigned long)(__end_rodata - __start_rodata) >> 10);
 }
 #endif
 /*
  * Just an arbitrary offset to serve as a "hole" between mapping areas
  * (between top of physical memory and a potential pcxl dma mapping
  * area, and below the vmalloc mapping area).
  *
  * The current 32K value just means that there will be a 32K "hole"
  * between mapping areas. That means that  any out-of-bounds memory
  * accesses will hopefully be caught. The vmalloc() routines leaves
  * a hole of 4kB between each vmalloced area for the same reason.
  */
  /* Leave room for gateway page expansion */
 #if KERNEL_MAP_START < GATEWAY_PAGE_SIZE
 #error KERNEL_MAP_START is in gateway reserved region
 #endif
 #define MAP_START (KERNEL_MAP_START)
 #define VM_MAP_OFFSET  (32*1024)
 #define SET_MAP_OFFSET(x) ((void *)(((unsigned long)(x) + VM_MAP_OFFSET) \
 				     & ~(VM_MAP_OFFSET-1)))
 void *vmalloc_start __read_mostly;
 EXPORT_SYMBOL(vmalloc_start);
 #ifdef CONFIG_PA11
 unsigned long pcxl_dma_start __read_mostly;
 #endif
 void __init mem_init(void)
 {
 	high_memory = __va((max_pfn << PAGE_SHIFT));
 #ifndef CONFIG_DISCONTIGMEM
 	max_mapnr = page_to_pfn(virt_to_page(high_memory - 1)) + 1;
 	totalram_pages += free_all_bootmem();
 #else
 	{
 		int i;
 		for (i = 0; i < npmem_ranges; i++)
 			totalram_pages += free_all_bootmem_node(NODE_DATA(i));
 	}
 #endif
 	printk(KERN_INFO "Memory: %luk available\n", num_physpages << (PAGE_SHIFT-10));
 #ifdef CONFIG_PA11
 	if (hppa_dma_ops == &pcxl_dma_ops) {
 		pcxl_dma_start = (unsigned long)SET_MAP_OFFSET(MAP_START);
 		vmalloc_start = SET_MAP_OFFSET(pcxl_dma_start + PCXL_DMA_MAP_SIZE);
 	} else {
 		pcxl_dma_start = 0;
 		vmalloc_start = SET_MAP_OFFSET(MAP_START);
 	}
 #else
 	vmalloc_start = SET_MAP_OFFSET(MAP_START);
 #endif
 }
 unsigned long *empty_zero_page __read_mostly;
 void show_mem(void)
 {
 	int i,free = 0,total = 0,reserved = 0;
 	int shared = 0, cached = 0;
 	printk(KERN_INFO "Mem-info:\n");
 	show_free_areas();
 	printk(KERN_INFO "Free swap:	 %6ldkB\n",
 				nr_swap_pages<<(PAGE_SHIFT-10));
 #ifndef CONFIG_DISCONTIGMEM
 	i = max_mapnr;
 	while (i-- > 0) {
 		total++;
 		if (PageReserved(mem_map+i))
 			reserved++;
 		else if (PageSwapCache(mem_map+i))
 			cached++;
 		else if (!page_count(&mem_map[i]))
 			free++;
 		else
 			shared += page_count(&mem_map[i]) - 1;
 	}
 #else
 	for (i = 0; i < npmem_ranges; i++) {
 		int j;
 		for (j = node_start_pfn(i); j < node_end_pfn(i); j++) {
 			struct page *p;
 			unsigned long flags;
 			pgdat_resize_lock(NODE_DATA(i), &flags);
 			p = nid_page_nr(i, j) - node_start_pfn(i);
 			total++;
 			if (PageReserved(p))
 				reserved++;
 			else if (PageSwapCache(p))
 				cached++;
 			else if (!page_count(p))
 				free++;
 			else
 				shared += page_count(p) - 1;
 			pgdat_resize_unlock(NODE_DATA(i), &flags);
         	}
 	}
 #endif
 	printk(KERN_INFO "%d pages of RAM\n", total);
 	printk(KERN_INFO "%d reserved pages\n", reserved);
 	printk(KERN_INFO "%d pages shared\n", shared);
 	printk(KERN_INFO "%d pages swap cached\n", cached);
 #ifdef CONFIG_DISCONTIGMEM
 	{
 		struct zonelist *zl;
 		int i, j, k;
 		for (i = 0; i < npmem_ranges; i++) {
 			for (j = 0; j < MAX_NR_ZONES; j++) {
 				zl = NODE_DATA(i)->node_zonelists + j;
 				printk("Zone list for zone %d on node %d: ", j, i);
 				for (k = 0; zl->zones[k] != NULL; k++)
 					printk("[%d/%s] ", zl->zones[k]->zone_pgdat->node_id, zl->zones[k]->name);
 				printk("\n");
 			}
 		}
 	}
 #endif
 }
 static void __init map_pages(unsigned long start_vaddr, unsigned long start_paddr, unsigned long size, pgprot_t pgprot)
 {
 	pgd_t *pg_dir;
 	pmd_t *pmd;
 	pte_t *pg_table;
 	unsigned long end_paddr;
 	unsigned long start_pmd;
 	unsigned long start_pte;
 	unsigned long tmp1;
 	unsigned long tmp2;
 	unsigned long address;
 	unsigned long ro_start;
 	unsigned long ro_end;
 	unsigned long fv_addr;
 	unsigned long gw_addr;
 	extern const unsigned long fault_vector_20;
 	extern void * const linux_gateway_page;
 	ro_start = __pa((unsigned long)&_text);
 	ro_end   = __pa((unsigned long)&data_start);
 	fv_addr  = __pa((unsigned long)&fault_vector_20) & PAGE_MASK;
 	gw_addr  = __pa((unsigned long)&linux_gateway_page) & PAGE_MASK;
 	end_paddr = start_paddr + size;
 	pg_dir = pgd_offset_k(start_vaddr);
 #if PTRS_PER_PMD == 1
 	start_pmd = 0;
 #else
 	start_pmd = ((start_vaddr >> PMD_SHIFT) & (PTRS_PER_PMD - 1));
 #endif
 	start_pte = ((start_vaddr >> PAGE_SHIFT) & (PTRS_PER_PTE - 1));
 	address = start_paddr;
 	while (address < end_paddr) {
 #if PTRS_PER_PMD == 1
 		pmd = (pmd_t *)__pa(pg_dir);
 #else
 		pmd = (pmd_t *)pgd_address(*pg_dir);
 		/*
 		 * pmd is physical at this point
 		 */
 		if (!pmd) {
 			pmd = (pmd_t *) alloc_bootmem_low_pages_node(NODE_DATA(0),PAGE_SIZE << PMD_ORDER);
 			pmd = (pmd_t *) __pa(pmd);
 		}
 		pgd_populate(NULL, pg_dir, __va(pmd));
 #endif
 		pg_dir++;
 		/* now change pmd to kernel virtual addresses */
 		pmd = (pmd_t *)__va(pmd) + start_pmd;
 		for (tmp1 = start_pmd; tmp1 < PTRS_PER_PMD; tmp1++,pmd++) {
 			/*
 			 * pg_table is physical at this point
 			 */
 			pg_table = (pte_t *)pmd_address(*pmd);
 			if (!pg_table) {
 				pg_table = (pte_t *)
 					alloc_bootmem_low_pages_node(NODE_DATA(0),PAGE_SIZE);
 				pg_table = (pte_t *) __pa(pg_table);
 			}
 			pmd_populate_kernel(NULL, pmd, __va(pg_table));
 			/* now change pg_table to kernel virtual addresses */
 			pg_table = (pte_t *) __va(pg_table) + start_pte;
 			for (tmp2 = start_pte; tmp2 < PTRS_PER_PTE; tmp2++,pg_table++) {
 				pte_t pte;
 				/*
 				 * Map the fault vector writable so we can
 				 * write the HPMC checksum.
 				 */
 #if defined(CONFIG_PARISC_PAGE_SIZE_4KB)
 				if (address >= ro_start && address < ro_end
 							&& address != fv_addr
 							&& address != gw_addr)
 				    pte = __mk_pte(address, PAGE_KERNEL_RO);
 				else
 #endif
 				    pte = __mk_pte(address, pgprot);
 				if (address >= end_paddr)
 					pte_val(pte) = 0;
 				set_pte(pg_table, pte);
 				address += PAGE_SIZE;
 			}
 			start_pte = 0;
 			if (address >= end_paddr)
 			    break;
 		}
 		start_pmd = 0;
 	}
 }
 /*
  * pagetable_init() sets up the page tables
  *
  * Note that gateway_init() places the Linux gateway page at page 0.
  * Since gateway pages cannot be dereferenced this has the desirable
  * side effect of trapping those pesky NULL-reference errors in the
  * kernel.
  */
 static void __init pagetable_init(void)
 {
 	int range;
 	/* Map each physical memory range to its kernel vaddr */
 	for (range = 0; range < npmem_ranges; range++) {
 		unsigned long start_paddr;
 		unsigned long end_paddr;
 		unsigned long size;
 		start_paddr = pmem_ranges[range].start_pfn << PAGE_SHIFT;
 		end_paddr = start_paddr + (pmem_ranges[range].pages << PAGE_SHIFT);
 		size = pmem_ranges[range].pages << PAGE_SHIFT;
 		map_pages((unsigned long)__va(start_paddr), start_paddr,
 			size, PAGE_KERNEL);
 	}
 #ifdef CONFIG_BLK_DEV_INITRD
 	if (initrd_end && initrd_end > mem_limit) {
 		printk(KERN_INFO "initrd: mapping %08lx-%08lx\n", initrd_start, initrd_end);
 		map_pages(initrd_start, __pa(initrd_start),
 			initrd_end - initrd_start, PAGE_KERNEL);
 	}
 #endif
 	empty_zero_page = alloc_bootmem_pages(PAGE_SIZE);
 	memset(empty_zero_page, 0, PAGE_SIZE);
 }
 static void __init gateway_init(void)
 {
 	unsigned long linux_gateway_page_addr;
 	/* FIXME: This is 'const' in order to trick the compiler
 	   into not treating it as DP-relative data. */
 	extern void * const linux_gateway_page;
 	linux_gateway_page_addr = LINUX_GATEWAY_ADDR & PAGE_MASK;
 	/*
 	 * Setup Linux Gateway page.
 	 *
 	 * The Linux gateway page will reside in kernel space (on virtual
 	 * page 0), so it doesn't need to be aliased into user space.
 	 */
 	map_pages(linux_gateway_page_addr, __pa(&linux_gateway_page),
 		PAGE_SIZE, PAGE_GATEWAY);
 }
 #ifdef CONFIG_HPUX
 void
 map_hpux_gateway_page(struct task_struct *tsk, struct mm_struct *mm)
 {
 	pgd_t *pg_dir;
 	pmd_t *pmd;
 	pte_t *pg_table;
 	unsigned long start_pmd;
 	unsigned long start_pte;
 	unsigned long address;
 	unsigned long hpux_gw_page_addr;
 	/* FIXME: This is 'const' in order to trick the compiler
 	   into not treating it as DP-relative data. */
 	extern void * const hpux_gateway_page;
 	hpux_gw_page_addr = HPUX_GATEWAY_ADDR & PAGE_MASK;
 	/*
 	 * Setup HP-UX Gateway page.
 	 *
 	 * The HP-UX gateway page resides in the user address space,
 	 * so it needs to be aliased into each process.
 	 */
 	pg_dir = pgd_offset(mm,hpux_gw_page_addr);
 #if PTRS_PER_PMD == 1
 	start_pmd = 0;
 #else
 	start_pmd = ((hpux_gw_page_addr >> PMD_SHIFT) & (PTRS_PER_PMD - 1));
 #endif
 	start_pte = ((hpux_gw_page_addr >> PAGE_SHIFT) & (PTRS_PER_PTE - 1));
 	address = __pa(&hpux_gateway_page);
 #if PTRS_PER_PMD == 1
 	pmd = (pmd_t *)__pa(pg_dir);
 #else
 	pmd = (pmd_t *) pgd_address(*pg_dir);
 	/*
 	 * pmd is physical at this point
 	 */
 	if (!pmd) {
 		pmd = (pmd_t *) get_zeroed_page(GFP_KERNEL);
 		pmd = (pmd_t *) __pa(pmd);
 	}
 	__pgd_val_set(*pg_dir, PxD_FLAG_PRESENT | PxD_FLAG_VALID | (unsigned long) pmd);
 #endif
 	/* now change pmd to kernel virtual addresses */
 	pmd = (pmd_t *)__va(pmd) + start_pmd;
 	/*
 	 * pg_table is physical at this point
 	 */
 	pg_table = (pte_t *) pmd_address(*pmd);
 	if (!pg_table)
 		pg_table = (pte_t *) __pa(get_zeroed_page(GFP_KERNEL));
 	__pmd_val_set(*pmd, PxD_FLAG_PRESENT | PxD_FLAG_VALID | (unsigned long) pg_table);
 	/* now change pg_table to kernel virtual addresses */
 	pg_table = (pte_t *) __va(pg_table) + start_pte;
 	set_pte(pg_table, __mk_pte(address, PAGE_GATEWAY));
 }
 EXPORT_SYMBOL(map_hpux_gateway_page);
 #endif
 void __init paging_init(void)
 {
 	int i;
 	setup_bootmem();
 	pagetable_init();
 	gateway_init();
 	flush_cache_all_local(); /* start with known state */
 	flush_tlb_all_local(NULL);
 	for (i = 0; i < npmem_ranges; i++) {
 		unsigned long zones_size[MAX_NR_ZONES] = { 0, 0, 0 };
 		/* We have an IOMMU, so all memory can go into a single
 		   ZONE_DMA zone. */
 		zones_size[ZONE_DMA] = pmem_ranges[i].pages;
 #ifdef CONFIG_DISCONTIGMEM
 		/* Need to initialize the pfnnid_map before we can initialize
 		   the zone */
 		{
 		    int j;
 		    for (j = (pmem_ranges[i].start_pfn >> PFNNID_SHIFT);
 			 j <= ((pmem_ranges[i].start_pfn + pmem_ranges[i].pages) >> PFNNID_SHIFT);
 			 j++) {
 			pfnnid_map[j] = i;
 		    }
 		}
 #endif
 		free_area_init_node(i, NODE_DATA(i), zones_size,
 				pmem_ranges[i].start_pfn, NULL);
 	}
 }
 #ifdef CONFIG_PA20
 /*
  * Currently, all PA20 chips have 18 bit protection id's, which is the
  * limiting factor (space ids are 32 bits).
  */
 #define NR_SPACE_IDS 262144
 #else
 /*
  * Currently we have a one-to-one relationship between space id's and
  * protection id's. Older parisc chips (PCXS, PCXT, PCXL, PCXL2) only
  * support 15 bit protection id's, so that is the limiting factor.
  * PCXT' has 18 bit protection id's, but only 16 bit spaceids, so it's
  * probably not worth the effort for a special case here.
  */
 #define NR_SPACE_IDS 32768
 #endif  /* !CONFIG_PA20 */
 #define RECYCLE_THRESHOLD (NR_SPACE_IDS / 2)
 #define SID_ARRAY_SIZE  (NR_SPACE_IDS / (8 * sizeof(long)))
 static unsigned long space_id[SID_ARRAY_SIZE] = { 1 }; /* disallow space 0 */
 static unsigned long dirty_space_id[SID_ARRAY_SIZE];
 static unsigned long space_id_index;
 static unsigned long free_space_ids = NR_SPACE_IDS - 1;
 static unsigned long dirty_space_ids = 0;
 static DEFINE_SPINLOCK(sid_lock);
 unsigned long alloc_sid(void)
 {
 	unsigned long index;
 	spin_lock(&sid_lock);
 	if (free_space_ids == 0) {
 		if (dirty_space_ids != 0) {
 			spin_unlock(&sid_lock);
 			flush_tlb_all(); /* flush_tlb_all() calls recycle_sids() */
 			spin_lock(&sid_lock);
 		}
 		BUG_ON(free_space_ids == 0);
 	}
 	free_space_ids--;
 	index = find_next_zero_bit(space_id, NR_SPACE_IDS, space_id_index);
 	space_id[index >> SHIFT_PER_LONG] |= (1L << (index & (BITS_PER_LONG - 1)));
 	space_id_index = index;
 	spin_unlock(&sid_lock);
 	return index << SPACEID_SHIFT;
 }
 void free_sid(unsigned long spaceid)
 {
 	unsigned long index = spaceid >> SPACEID_SHIFT;
 	unsigned long *dirty_space_offset;
 	dirty_space_offset = dirty_space_id + (index >> SHIFT_PER_LONG);
 	index &= (BITS_PER_LONG - 1);
 	spin_lock(&sid_lock);
 	BUG_ON(*dirty_space_offset & (1L << index)); /* attempt to free space id twice */
 	*dirty_space_offset |= (1L << index);
 	dirty_space_ids++;
 	spin_unlock(&sid_lock);
 }
 #ifdef CONFIG_SMP
 static void get_dirty_sids(unsigned long *ndirtyptr,unsigned long *dirty_array)
 {
 	int i;
 	/* NOTE: sid_lock must be held upon entry */
 	*ndirtyptr = dirty_space_ids;
 	if (dirty_space_ids != 0) {
 	    for (i = 0; i < SID_ARRAY_SIZE; i++) {
 		dirty_array[i] = dirty_space_id[i];
 		dirty_space_id[i] = 0;
 	    }
 	    dirty_space_ids = 0;
 	}
 	return;
 }
 static void recycle_sids(unsigned long ndirty,unsigned long *dirty_array)
 {
 	int i;
 	/* NOTE: sid_lock must be held upon entry */
 	if (ndirty != 0) {
 		for (i = 0; i < SID_ARRAY_SIZE; i++) {
 			space_id[i] ^= dirty_array[i];
 		}
 		free_space_ids += ndirty;
 		space_id_index = 0;
 	}
 }
 #else /* CONFIG_SMP */
 static void recycle_sids(void)
 {
 	int i;
 	/* NOTE: sid_lock must be held upon entry */
 	if (dirty_space_ids != 0) {
 		for (i = 0; i < SID_ARRAY_SIZE; i++) {
 			space_id[i] ^= dirty_space_id[i];
 			dirty_space_id[i] = 0;
 		}
 		free_space_ids += dirty_space_ids;
 		dirty_space_ids = 0;
 		space_id_index = 0;
 	}
 }
 #endif
 /*
  * flush_tlb_all() calls recycle_sids(), since whenever the entire tlb is
  * purged, we can safely reuse the space ids that were released but
  * not flushed from the tlb.
  */
 #ifdef CONFIG_SMP
 static unsigned long recycle_ndirty;
 static unsigned long recycle_dirty_array[SID_ARRAY_SIZE];
 static unsigned int recycle_inuse;
 void flush_tlb_all(void)
 {
 	int do_recycle;
 	do_recycle = 0;
 	spin_lock(&sid_lock);
 	if (dirty_space_ids > RECYCLE_THRESHOLD) {
 	    BUG_ON(recycle_inuse);  /* FIXME: Use a semaphore/wait queue here */
 	    get_dirty_sids(&recycle_ndirty,recycle_dirty_array);
 	    recycle_inuse++;
 	    do_recycle++;
 	}
 	spin_unlock(&sid_lock);
 	on_each_cpu(flush_tlb_all_local, NULL, 1, 1);
 	if (do_recycle) {
 	    spin_lock(&sid_lock);
 	    recycle_sids(recycle_ndirty,recycle_dirty_array);
 	    recycle_inuse = 0;
 	    spin_unlock(&sid_lock);
 	}
 }
 #else
 void flush_tlb_all(void)
 {
 	spin_lock(&sid_lock);
 	flush_tlb_all_local(NULL);
 	recycle_sids();
 	spin_unlock(&sid_lock);
 }
 #endif
 #ifdef CONFIG_BLK_DEV_INITRD
 void free_initrd_mem(unsigned long start, unsigned long end)
 {
 	if (start >= end)
 		return;
 	printk(KERN_INFO "Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
 	for (; start < end; start += PAGE_SIZE) {
 		ClearPageReserved(virt_to_page(start));
 		init_page_count(virt_to_page(start));
 		free_page(start);
 		num_physpages++;
 		totalram_pages++;
 	}
 }
 #endif

arch/x86_64/mm/init.c

Diff comments View file @ a581c2a

 /*
  *  linux/arch/x86_64/mm/init.c
  *
  *  Copyright (C) 1995  Linus Torvalds
  *  Copyright (C) 2000  Pavel Machek <pavel@suse.cz>
  *  Copyright (C) 2002,2003 Andi Kleen <ak@suse.de>
  */
 #include <linux/signal.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/string.h>
 #include <linux/types.h>
 #include <linux/ptrace.h>
 #include <linux/mman.h>
 #include <linux/mm.h>
 #include <linux/swap.h>
 #include <linux/smp.h>
 #include <linux/init.h>
 #include <linux/pagemap.h>
 #include <linux/bootmem.h>
 #include <linux/proc_fs.h>
 #include <linux/pci.h>
 #include <linux/poison.h>
 #include <linux/dma-mapping.h>
 #include <linux/module.h>
 #include <linux/memory_hotplug.h>
 #include <asm/processor.h>
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
 #include <asm/dma.h>
 #include <asm/fixmap.h>
 #include <asm/e820.h>
 #include <asm/apic.h>
 #include <asm/tlb.h>
 #include <asm/mmu_context.h>
 #include <asm/proto.h>
 #include <asm/smp.h>
 #include <asm/sections.h>
 #ifndef Dprintk
 #define Dprintk(x...)
 #endif
 struct dma_mapping_ops* dma_ops;
 EXPORT_SYMBOL(dma_ops);
 static unsigned long dma_reserve __initdata;
 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
 /*
  * NOTE: pagetable_init alloc all the fixmap pagetables contiguous on the
  * physical space so we can cache the place of the first one and move
  * around without checking the pgd every time.
  */
 void show_mem(void)
 {
 	long i, total = 0, reserved = 0;
 	long shared = 0, cached = 0;
 	pg_data_t *pgdat;
 	struct page *page;
 	printk(KERN_INFO "Mem-info:\n");
 	show_free_areas();
 	printk(KERN_INFO "Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
 	for_each_online_pgdat(pgdat) {
                for (i = 0; i < pgdat->node_spanned_pages; ++i) {
 			page = pfn_to_page(pgdat->node_start_pfn + i);
 			total++;
 			if (PageReserved(page))
 				reserved++;
 			else if (PageSwapCache(page))
 				cached++;
 			else if (page_count(page))
 				shared += page_count(page) - 1;
                }
 	}
 	printk(KERN_INFO "%lu pages of RAM\n", total);
 	printk(KERN_INFO "%lu reserved pages\n",reserved);
 	printk(KERN_INFO "%lu pages shared\n",shared);
 	printk(KERN_INFO "%lu pages swap cached\n",cached);
 }
 int after_bootmem;
 static __init void *spp_getpage(void)
 {
 	void *ptr;
 	if (after_bootmem)
 		ptr = (void *) get_zeroed_page(GFP_ATOMIC);
 	else
 		ptr = alloc_bootmem_pages(PAGE_SIZE);
 	if (!ptr || ((unsigned long)ptr & ~PAGE_MASK))
 		panic("set_pte_phys: cannot allocate page data %s\n", after_bootmem?"after bootmem":"");
 	Dprintk("spp_getpage %p\n", ptr);
 	return ptr;
 }
 static __init void set_pte_phys(unsigned long vaddr,
 			 unsigned long phys, pgprot_t prot)
 {
 	pgd_t *pgd;
 	pud_t *pud;
 	pmd_t *pmd;
 	pte_t *pte, new_pte;
 	Dprintk("set_pte_phys %lx to %lx\n", vaddr, phys);
 	pgd = pgd_offset_k(vaddr);
 	if (pgd_none(*pgd)) {
 		printk("PGD FIXMAP MISSING, it should be setup in head.S!\n");
 		return;
 	}
 	pud = pud_offset(pgd, vaddr);
 	if (pud_none(*pud)) {
 		pmd = (pmd_t *) spp_getpage();
 		set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE | _PAGE_USER));
 		if (pmd != pmd_offset(pud, 0)) {
 			printk("PAGETABLE BUG #01! %p <-> %p\n", pmd, pmd_offset(pud,0));
 			return;
 		}
 	}
 	pmd = pmd_offset(pud, vaddr);
 	if (pmd_none(*pmd)) {
 		pte = (pte_t *) spp_getpage();
 		set_pmd(pmd, __pmd(__pa(pte) | _KERNPG_TABLE | _PAGE_USER));
 		if (pte != pte_offset_kernel(pmd, 0)) {
 			printk("PAGETABLE BUG #02!\n");
 			return;
 		}
 	}
 	new_pte = pfn_pte(phys >> PAGE_SHIFT, prot);
 	pte = pte_offset_kernel(pmd, vaddr);
 	if (!pte_none(*pte) &&
 	    pte_val(*pte) != (pte_val(new_pte) & __supported_pte_mask))
 		pte_ERROR(*pte);
 	set_pte(pte, new_pte);
 	/*
 	 * It's enough to flush this one mapping.
 	 * (PGE mappings get flushed as well)
 	 */
 	__flush_tlb_one(vaddr);
 }
 /* NOTE: this is meant to be run only at boot */
 void __init
 __set_fixmap (enum fixed_addresses idx, unsigned long phys, pgprot_t prot)
 {
 	unsigned long address = __fix_to_virt(idx);
 	if (idx >= __end_of_fixed_addresses) {
 		printk("Invalid __set_fixmap\n");
 		return;
 	}
 	set_pte_phys(address, phys, prot);
 }
 unsigned long __initdata table_start, table_end;
 extern pmd_t temp_boot_pmds[];
 static  struct temp_map {
 	pmd_t *pmd;
 	void  *address;
 	int    allocated;
 } temp_mappings[] __initdata = {
 	{ &temp_boot_pmds[0], (void *)(40UL * 1024 * 1024) },
 	{ &temp_boot_pmds[1], (void *)(42UL * 1024 * 1024) },
 	{}
 };
 static __meminit void *alloc_low_page(int *index, unsigned long *phys)
 {
 	struct temp_map *ti;
 	int i;
 	unsigned long pfn = table_end++, paddr;
 	void *adr;
 	if (after_bootmem) {
 		adr = (void *)get_zeroed_page(GFP_ATOMIC);
 		*phys = __pa(adr);
 		return adr;
 	}
 	if (pfn >= end_pfn)
 		panic("alloc_low_page: ran out of memory");
 	for (i = 0; temp_mappings[i].allocated; i++) {
 		if (!temp_mappings[i].pmd)
 			panic("alloc_low_page: ran out of temp mappings");
 	}
 	ti = &temp_mappings[i];
 	paddr = (pfn << PAGE_SHIFT) & PMD_MASK;
 	set_pmd(ti->pmd, __pmd(paddr | _KERNPG_TABLE | _PAGE_PSE));
 	ti->allocated = 1;
 	__flush_tlb();
 	adr = ti->address + ((pfn << PAGE_SHIFT) & ~PMD_MASK);
 	memset(adr, 0, PAGE_SIZE);
 	*index = i;
 	*phys  = pfn * PAGE_SIZE;
 	return adr;
 }
 static __meminit void unmap_low_page(int i)
 {
 	struct temp_map *ti;
 	if (after_bootmem)
 		return;
 	ti = &temp_mappings[i];
 	set_pmd(ti->pmd, __pmd(0));
 	ti->allocated = 0;
 }
 /* Must run before zap_low_mappings */
 __init void *early_ioremap(unsigned long addr, unsigned long size)
 {
 	unsigned long map = round_down(addr, LARGE_PAGE_SIZE);
 	/* actually usually some more */
 	if (size >= LARGE_PAGE_SIZE) {
 		printk("SMBIOS area too long %lu\n", size);
 		return NULL;
 	}
 	set_pmd(temp_mappings[0].pmd,  __pmd(map | _KERNPG_TABLE | _PAGE_PSE));
 	map += LARGE_PAGE_SIZE;
 	set_pmd(temp_mappings[1].pmd,  __pmd(map | _KERNPG_TABLE | _PAGE_PSE));
 	__flush_tlb();
 	return temp_mappings[0].address + (addr & (LARGE_PAGE_SIZE-1));
 }
 /* To avoid virtual aliases later */
 __init void early_iounmap(void *addr, unsigned long size)
 {
 	if ((void *)round_down((unsigned long)addr, LARGE_PAGE_SIZE) != temp_mappings[0].address)
 		printk("early_iounmap: bad address %p\n", addr);
 	set_pmd(temp_mappings[0].pmd, __pmd(0));
 	set_pmd(temp_mappings[1].pmd, __pmd(0));
 	__flush_tlb();
 }
 static void __meminit
 phys_pmd_init(pmd_t *pmd, unsigned long address, unsigned long end)
 {
 	int i;
 	for (i = 0; i < PTRS_PER_PMD; pmd++, i++, address += PMD_SIZE) {
 		unsigned long entry;
 		if (address >= end) {
 			if (!after_bootmem)
 				for (; i < PTRS_PER_PMD; i++, pmd++)
 					set_pmd(pmd, __pmd(0));
 			break;
 		}
 		entry = _PAGE_NX|_PAGE_PSE|_KERNPG_TABLE|_PAGE_GLOBAL|address;
 		entry &= __supported_pte_mask;
 		set_pmd(pmd, __pmd(entry));
 	}
 }
 static void __meminit
 phys_pmd_update(pud_t *pud, unsigned long address, unsigned long end)
 {
 	pmd_t *pmd = pmd_offset(pud, (unsigned long)__va(address));
 	if (pmd_none(*pmd)) {
 		spin_lock(&init_mm.page_table_lock);
 		phys_pmd_init(pmd, address, end);
 		spin_unlock(&init_mm.page_table_lock);
 		__flush_tlb_all();
 	}
 }
 static void __meminit phys_pud_init(pud_t *pud, unsigned long address, unsigned long end)
 {
 	long i = pud_index(address);
 	pud = pud + i;
 	if (after_bootmem && pud_val(*pud)) {
 		phys_pmd_update(pud, address, end);
 		return;
 	}
 	for (; i < PTRS_PER_PUD; pud++, i++) {
 		int map;
 		unsigned long paddr, pmd_phys;
 		pmd_t *pmd;
 		paddr = (address & PGDIR_MASK) + i*PUD_SIZE;
 		if (paddr >= end)
 			break;
 		if (!after_bootmem && !e820_any_mapped(paddr, paddr+PUD_SIZE, 0)) {
 			set_pud(pud, __pud(0));
 			continue;
 		}
 		pmd = alloc_low_page(&map, &pmd_phys);
 		spin_lock(&init_mm.page_table_lock);
 		set_pud(pud, __pud(pmd_phys | _KERNPG_TABLE));
 		phys_pmd_init(pmd, paddr, end);
 		spin_unlock(&init_mm.page_table_lock);
 		unmap_low_page(map);
 	}
 	__flush_tlb();
 }
 static void __init find_early_table_space(unsigned long end)
 {
 	unsigned long puds, pmds, tables, start;
 	puds = (end + PUD_SIZE - 1) >> PUD_SHIFT;
 	pmds = (end + PMD_SIZE - 1) >> PMD_SHIFT;
 	tables = round_up(puds * sizeof(pud_t), PAGE_SIZE) +
 		 round_up(pmds * sizeof(pmd_t), PAGE_SIZE);
  	/* RED-PEN putting page tables only on node 0 could
  	   cause a hotspot and fill up ZONE_DMA. The page tables
  	   need roughly 0.5KB per GB. */
  	start = 0x8000;
  	table_start = find_e820_area(start, end, tables);
 	if (table_start == -1UL)
 		panic("Cannot find space for the kernel page tables");
 	table_start >>= PAGE_SHIFT;
 	table_end = table_start;
 	early_printk("kernel direct mapping tables up to %lx @ %lx-%lx\n",
 		end, table_start << PAGE_SHIFT,
 		(table_start << PAGE_SHIFT) + tables);
 }
 /* Setup the direct mapping of the physical memory at PAGE_OFFSET.
    This runs before bootmem is initialized and gets pages directly from the
    physical memory. To access them they are temporarily mapped. */
 void __meminit init_memory_mapping(unsigned long start, unsigned long end)
 {
 	unsigned long next;
 	Dprintk("init_memory_mapping\n");
 	/*
 	 * Find space for the kernel direct mapping tables.
 	 * Later we should allocate these tables in the local node of the memory
 	 * mapped.  Unfortunately this is done currently before the nodes are
 	 * discovered.
 	 */
 	if (!after_bootmem)
 		find_early_table_space(end);
 	start = (unsigned long)__va(start);
 	end = (unsigned long)__va(end);
 	for (; start < end; start = next) {
 		int map;
 		unsigned long pud_phys;
 		pgd_t *pgd = pgd_offset_k(start);
 		pud_t *pud;
 		if (after_bootmem)
 			pud = pud_offset(pgd, start & PGDIR_MASK);
 		else
 			pud = alloc_low_page(&map, &pud_phys);
 		next = start + PGDIR_SIZE;
 		if (next > end)
 			next = end;
 		phys_pud_init(pud, __pa(start), __pa(next));
 		if (!after_bootmem)
 			set_pgd(pgd_offset_k(start), mk_kernel_pgd(pud_phys));
 		unmap_low_page(map);
 	}
 	if (!after_bootmem)
 		asm volatile("movq %%cr4,%0" : "=r" (mmu_cr4_features));
 	__flush_tlb_all();
 }
 void __cpuinit zap_low_mappings(int cpu)
 {
 	if (cpu == 0) {
 		pgd_t *pgd = pgd_offset_k(0UL);
 		pgd_clear(pgd);
 	} else {
 		/*
 		 * For AP's, zap the low identity mappings by changing the cr3
 		 * to init_level4_pgt and doing local flush tlb all
 		 */
 		asm volatile("movq %0,%%cr3" :: "r" (__pa_symbol(&init_level4_pgt)));
 	}
 	__flush_tlb_all();
 }
 /* Compute zone sizes for the DMA and DMA32 zones in a node. */
 __init void
 size_zones(unsigned long *z, unsigned long *h,
 	   unsigned long start_pfn, unsigned long end_pfn)
 {
  	int i;
  	unsigned long w;
  	for (i = 0; i < MAX_NR_ZONES; i++)
  		z[i] = 0;
  	if (start_pfn < MAX_DMA_PFN)
  		z[ZONE_DMA] = MAX_DMA_PFN - start_pfn;
  	if (start_pfn < MAX_DMA32_PFN) {
  		unsigned long dma32_pfn = MAX_DMA32_PFN;
  		if (dma32_pfn > end_pfn)
  			dma32_pfn = end_pfn;
  		z[ZONE_DMA32] = dma32_pfn - start_pfn;
  	}
  	z[ZONE_NORMAL] = end_pfn - start_pfn;
  	/* Remove lower zones from higher ones. */
  	w = 0;
  	for (i = 0; i < MAX_NR_ZONES; i++) {
  		if (z[i])
  			z[i] -= w;
  	        w += z[i];
 	}
 	/* Compute holes */
 	w = start_pfn;
 	for (i = 0; i < MAX_NR_ZONES; i++) {
 		unsigned long s = w;
 		w += z[i];
 		h[i] = e820_hole_size(s, w);
 	}
 	/* Add the space pace needed for mem_map to the holes too. */
 	for (i = 0; i < MAX_NR_ZONES; i++)
 		h[i] += (z[i] * sizeof(struct page)) / PAGE_SIZE;
 	/* The 16MB DMA zone has the kernel and other misc mappings.
  	   Account them too */
 	if (h[ZONE_DMA]) {
 		h[ZONE_DMA] += dma_reserve;
 		if (h[ZONE_DMA] >= z[ZONE_DMA]) {
 			printk(KERN_WARNING
 				"Kernel too large and filling up ZONE_DMA?\n");
 			h[ZONE_DMA] = z[ZONE_DMA];
 		}
 	}
 }
 #ifndef CONFIG_NUMA
 void __init paging_init(void)
 {
 	unsigned long zones[MAX_NR_ZONES], holes[MAX_NR_ZONES];
 	memory_present(0, 0, end_pfn);
 	sparse_init();
 	size_zones(zones, holes, 0, end_pfn);
 	free_area_init_node(0, NODE_DATA(0), zones,
 			    __pa(PAGE_OFFSET) >> PAGE_SHIFT, holes);
 }
 #endif
 /* Unmap a kernel mapping if it exists. This is useful to avoid prefetches
    from the CPU leading to inconsistent cache lines. address and size
    must be aligned to 2MB boundaries.
    Does nothing when the mapping doesn't exist. */
 void __init clear_kernel_mapping(unsigned long address, unsigned long size)
 {
 	unsigned long end = address + size;
 	BUG_ON(address & ~LARGE_PAGE_MASK);
 	BUG_ON(size & ~LARGE_PAGE_MASK);
 	for (; address < end; address += LARGE_PAGE_SIZE) {
 		pgd_t *pgd = pgd_offset_k(address);
 		pud_t *pud;
 		pmd_t *pmd;
 		if (pgd_none(*pgd))
 			continue;
 		pud = pud_offset(pgd, address);
 		if (pud_none(*pud))
 			continue;
 		pmd = pmd_offset(pud, address);
 		if (!pmd || pmd_none(*pmd))
 			continue;
 		if (0 == (pmd_val(*pmd) & _PAGE_PSE)) {
 			/* Could handle this, but it should not happen currently. */
 			printk(KERN_ERR
 	       "clear_kernel_mapping: mapping has been split. will leak memory\n");
 			pmd_ERROR(*pmd);
 		}
 		set_pmd(pmd, __pmd(0));
 	}
 	__flush_tlb_all();
 }
 /*
  * Memory hotplug specific functions
  */
 void online_page(struct page *page)
 {
 	ClearPageReserved(page);
 	init_page_count(page);
 	__free_page(page);
 	totalram_pages++;
 	num_physpages++;
 }
 #ifdef CONFIG_MEMORY_HOTPLUG
 /*
  * XXX: memory_add_physaddr_to_nid() is to find node id from physical address
  *	via probe interface of sysfs. If acpi notifies hot-add event, then it
  *	can tell node id by searching dsdt. But, probe interface doesn't have
  *	node id. So, return 0 as node id at this time.
  */
 #ifdef CONFIG_NUMA
 int memory_add_physaddr_to_nid(u64 start)
 {
 	return 0;
 }
 #endif
 /*
  * Memory is added always to NORMAL zone. This means you will never get
  * additional DMA/DMA32 memory.
  */
 int arch_add_memory(int nid, u64 start, u64 size)
 {
 	struct pglist_data *pgdat = NODE_DATA(nid);
 	struct zone *zone = pgdat->node_zones + MAX_NR_ZONES-2;
 	unsigned long start_pfn = start >> PAGE_SHIFT;
 	unsigned long nr_pages = size >> PAGE_SHIFT;
 	int ret;
 	ret = __add_pages(zone, start_pfn, nr_pages);
 	if (ret)
 		goto error;
 	init_memory_mapping(start, (start + size -1));
 	return ret;
 error:
 	printk("%s: Problem encountered in __add_pages!\n", __func__);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(arch_add_memory);
 int remove_memory(u64 start, u64 size)
 {
 	return -EINVAL;
 }
 EXPORT_SYMBOL_GPL(remove_memory);
 #else /* CONFIG_MEMORY_HOTPLUG */
 /*
  * Memory Hotadd without sparsemem. The mem_maps have been allocated in advance,
  * just online the pages.
  */
 int __add_pages(struct zone *z, unsigned long start_pfn, unsigned long nr_pages)
 {
 	int err = -EIO;
 	unsigned long pfn;
 	unsigned long total = 0, mem = 0;
 	for (pfn = start_pfn; pfn < start_pfn + nr_pages; pfn++) {
 		if (pfn_valid(pfn)) {
 			online_page(pfn_to_page(pfn));
 			err = 0;
 			mem++;
 		}
 		total++;
 	}
 	if (!err) {
 		z->spanned_pages += total;
 		z->present_pages += mem;
 		z->zone_pgdat->node_spanned_pages += total;
 		z->zone_pgdat->node_present_pages += mem;
 	}
 	return err;
 }
 #endif /* CONFIG_MEMORY_HOTPLUG */
 static struct kcore_list kcore_mem, kcore_vmalloc, kcore_kernel, kcore_modules,
 			 kcore_vsyscall;
 void __init mem_init(void)
 {
 	long codesize, reservedpages, datasize, initsize;
 	pci_iommu_alloc();
 	/* How many end-of-memory variables you have, grandma! */
 	max_low_pfn = end_pfn;
 	max_pfn = end_pfn;
 	num_physpages = end_pfn;
 	high_memory = (void *) __va(end_pfn * PAGE_SIZE);
 	/* clear the zero-page */
 	memset(empty_zero_page, 0, PAGE_SIZE);
 	reservedpages = 0;
 	/* this will put all low memory onto the freelists */
 #ifdef CONFIG_NUMA
 	totalram_pages = numa_free_all_bootmem();
 #else
 	totalram_pages = free_all_bootmem();
 #endif
 	reservedpages = end_pfn - totalram_pages - e820_hole_size(0, end_pfn);
 	after_bootmem = 1;
 	codesize =  (unsigned long) &_etext - (unsigned long) &_text;
 	datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
 	initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
 	/* Register memory areas for /proc/kcore */
 	kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT);
 	kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
 		   VMALLOC_END-VMALLOC_START);
 	kclist_add(&kcore_kernel, &_stext, _end - _stext);
 	kclist_add(&kcore_modules, (void *)MODULES_VADDR, MODULES_LEN);
 	kclist_add(&kcore_vsyscall, (void *)VSYSCALL_START,
 				 VSYSCALL_END - VSYSCALL_START);
 	printk("Memory: %luk/%luk available (%ldk kernel code, %ldk reserved, %ldk data, %ldk init)\n",
 		(unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
 		end_pfn << (PAGE_SHIFT-10),
 		codesize >> 10,
 		reservedpages << (PAGE_SHIFT-10),
 		datasize >> 10,
 		initsize >> 10);
 #ifdef CONFIG_SMP
 	/*
 	 * Sync boot_level4_pgt mappings with the init_level4_pgt
 	 * except for the low identity mappings which are already zapped
 	 * in init_level4_pgt. This sync-up is essential for AP's bringup
 	 */
 	memcpy(boot_level4_pgt+1, init_level4_pgt+1, (PTRS_PER_PGD-1)*sizeof(pgd_t));
 #endif
 }
 void free_init_pages(char *what, unsigned long begin, unsigned long end)
 {
 	unsigned long addr;
 	if (begin >= end)
 		return;
 	printk(KERN_INFO "Freeing %s: %ldk freed\n", what, (end - begin) >> 10);
 	for (addr = begin; addr < end; addr += PAGE_SIZE) {
 		ClearPageReserved(virt_to_page(addr));
 		init_page_count(virt_to_page(addr));
 		memset((void *)(addr & ~(PAGE_SIZE-1)),
 			POISON_FREE_INITMEM, PAGE_SIZE);
 		free_page(addr);
 		totalram_pages++;
 	}
 }
 void free_initmem(void)
 {
 	memset(__initdata_begin, POISON_FREE_INITDATA,
 		__initdata_end - __initdata_begin);
 	free_init_pages("unused kernel memory",
 			(unsigned long)(&__init_begin),
 			(unsigned long)(&__init_end));
 }
 #ifdef CONFIG_DEBUG_RODATA
-extern char __start_rodata, __end_rodata;
 void mark_rodata_ro(void)
 {
-	unsigned long addr = (unsigned long)&__start_rodata;
+	unsigned long addr = (unsigned long)__start_rodata;
-	for (; addr < (unsigned long)&__end_rodata; addr += PAGE_SIZE)
+	for (; addr < (unsigned long)__end_rodata; addr += PAGE_SIZE)
 		change_page_attr_addr(addr, 1, PAGE_KERNEL_RO);
 	printk ("Write protecting the kernel read-only data: %luk\n",
-			(&__end_rodata - &__start_rodata) >> 10);
+			(__end_rodata - __start_rodata) >> 10);
 	/*
 	 * change_page_attr_addr() requires a global_flush_tlb() call after it.
 	 * We do this after the printk so that if something went wrong in the
 	 * change, the printk gets out at least to give a better debug hint
 	 * of who is the culprit.
 	 */
 	global_flush_tlb();
 }
 #endif
 #ifdef CONFIG_BLK_DEV_INITRD
 void free_initrd_mem(unsigned long start, unsigned long end)
 {
 	free_init_pages("initrd memory", start, end);
 }
 #endif
 void __init reserve_bootmem_generic(unsigned long phys, unsigned len)
 {
 	/* Should check here against the e820 map to avoid double free */
 #ifdef CONFIG_NUMA
 	int nid = phys_to_nid(phys);
   	reserve_bootmem_node(NODE_DATA(nid), phys, len);
 #else
 	reserve_bootmem(phys, len);
 #endif
 	if (phys+len <= MAX_DMA_PFN*PAGE_SIZE)
 		dma_reserve += len / PAGE_SIZE;
 }
 int kern_addr_valid(unsigned long addr)
 {
 	unsigned long above = ((long)addr) >> __VIRTUAL_MASK_SHIFT;
        pgd_t *pgd;
        pud_t *pud;
        pmd_t *pmd;
        pte_t *pte;
 	if (above != 0 && above != -1UL)
 		return 0;
 	pgd = pgd_offset_k(addr);
 	if (pgd_none(*pgd))
 		return 0;
 	pud = pud_offset(pgd, addr);
 	if (pud_none(*pud))
 		return 0;
 	pmd = pmd_offset(pud, addr);
 	if (pmd_none(*pmd))
 		return 0;
 	if (pmd_large(*pmd))
 		return pfn_valid(pmd_pfn(*pmd));
 	pte = pte_offset_kernel(pmd, addr);
 	if (pte_none(*pte))
 		return 0;
 	return pfn_valid(pte_pfn(*pte));
 }
 #ifdef CONFIG_SYSCTL
 #include <linux/sysctl.h>
 extern int exception_trace, page_fault_trace;
 static ctl_table debug_table2[] = {
 	{ 99, "exception-trace", &exception_trace, sizeof(int), 0644, NULL,
 	  proc_dointvec },
 	{ 0, }
 };
 static ctl_table debug_root_table2[] = {
 	{ .ctl_name = CTL_DEBUG, .procname = "debug", .mode = 0555,
 	   .child = debug_table2 },
 	{ 0 },
 };
 static __init int x8664_sysctl_init(void)
 {
 	register_sysctl_table(debug_root_table2, 1);
 	return 0;
 }
 __initcall(x8664_sysctl_init);
 #endif
 /* A pseudo VMAs to allow ptrace access for the vsyscall page.   This only
    covers the 64bit vsyscall page now. 32bit has a real VMA now and does
    not need special handling anymore. */
 static struct vm_area_struct gate_vma = {
 	.vm_start = VSYSCALL_START,
 	.vm_end = VSYSCALL_END,
 	.vm_page_prot = PAGE_READONLY
 };
 struct vm_area_struct *get_gate_vma(struct task_struct *tsk)
 {
 #ifdef CONFIG_IA32_EMULATION
 	if (test_tsk_thread_flag(tsk, TIF_IA32))
 		return NULL;
 #endif
 	return &gate_vma;
 }
 int in_gate_area(struct task_struct *task, unsigned long addr)
 {
 	struct vm_area_struct *vma = get_gate_vma(task);
 	if (!vma)
 		return 0;
 	return (addr >= vma->vm_start) && (addr < vma->vm_end);
 }
 /* Use this when you have no reliable task/vma, typically from interrupt
  * context.  It is less reliable than using the task's vma and may give
  * false positives.
  */
 int in_gate_area_no_task(unsigned long addr)
 {
 	return (addr >= VSYSCALL_START) && (addr < VSYSCALL_END);
 }

include/asm-generic/sections.h

Diff comments View file @ a581c2a

 #ifndef _ASM_GENERIC_SECTIONS_H_
 #define _ASM_GENERIC_SECTIONS_H_
 /* References to section boundaries */
 extern char _text[], _stext[], _etext[];
 extern char _data[], _sdata[], _edata[];
 extern char __bss_start[], __bss_stop[];
 extern char __init_begin[], __init_end[];
 extern char _sinittext[], _einittext[];
 extern char _sextratext[] __attribute__((weak));
 extern char _eextratext[] __attribute__((weak));
 extern char _end[];
 extern char __per_cpu_start[], __per_cpu_end[];
 extern char __kprobes_text_start[], __kprobes_text_end[];
 extern char __initdata_begin[], __initdata_end[];
+extern char __start_rodata[], __end_rodata[];
 #endif /* _ASM_GENERIC_SECTIONS_H_ */