2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* 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>
|
2005-11-05 11:25:53 -05:00
|
|
|
#include <linux/pci.h>
|
[PATCH] x86: tighten kernel image page access rights
On x86-64, kernel memory freed after init can be entirely unmapped instead
of just getting 'poisoned' by overwriting with a debug pattern.
On i386 and x86-64 (under CONFIG_DEBUG_RODATA), kernel text and bug table
can also be write-protected.
Compared to the first version, this one prevents re-creating deleted
mappings in the kernel image range on x86-64, if those got removed
previously. This, together with the original changes, prevents temporarily
having inconsistent mappings when cacheability attributes are being
changed on such pages (e.g. from AGP code). While on i386 such duplicate
mappings don't exist, the same change is done there, too, both for
consistency and because checking pte_present() before using various other
pte_XXX functions is a requirement anyway. At once, i386 code gets
adjusted to use pte_huge() instead of open coding this.
AK: split out cpa() changes
Signed-off-by: Jan Beulich <jbeulich@novell.com>
Signed-off-by: Andi Kleen <ak@suse.de>
2007-05-02 13:27:10 -04:00
|
|
|
#include <linux/pfn.h>
|
2006-06-27 05:53:52 -04:00
|
|
|
#include <linux/poison.h>
|
2006-01-11 16:44:42 -05:00
|
|
|
#include <linux/dma-mapping.h>
|
2006-01-17 01:03:41 -05:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/memory_hotplug.h>
|
2007-05-02 13:27:11 -04:00
|
|
|
#include <linux/nmi.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
#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>
|
2005-11-05 11:25:53 -05:00
|
|
|
#include <asm/sections.h>
|
2008-01-30 07:30:17 -05:00
|
|
|
#include <asm/kdebug.h>
|
2008-01-30 07:30:17 -05:00
|
|
|
#include <asm/numa.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
const struct dma_mapping_ops *dma_ops;
|
2006-01-11 16:44:42 -05:00
|
|
|
EXPORT_SYMBOL(dma_ops);
|
|
|
|
|
2005-11-05 11:25:53 -05:00
|
|
|
static unsigned long dma_reserve __initdata;
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
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)
|
|
|
|
{
|
2005-09-12 12:49:24 -04:00
|
|
|
long i, total = 0, reserved = 0;
|
|
|
|
long shared = 0, cached = 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
struct page *page;
|
2008-01-30 07:34:10 -05:00
|
|
|
pg_data_t *pgdat;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-09-12 12:49:24 -04:00
|
|
|
printk(KERN_INFO "Mem-info:\n");
|
2005-04-16 18:20:36 -04:00
|
|
|
show_free_areas();
|
2008-01-30 07:34:10 -05:00
|
|
|
printk(KERN_INFO "Free swap: %6ldkB\n",
|
|
|
|
nr_swap_pages << (PAGE_SHIFT-10));
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-03-27 04:15:59 -05:00
|
|
|
for_each_online_pgdat(pgdat) {
|
2008-01-30 07:34:10 -05:00
|
|
|
for (i = 0; i < pgdat->node_spanned_pages; ++i) {
|
|
|
|
/*
|
|
|
|
* This loop can take a while with 256 GB and
|
|
|
|
* 4k pages so defer the NMI watchdog:
|
|
|
|
*/
|
|
|
|
if (unlikely(i % MAX_ORDER_NR_PAGES == 0))
|
2007-05-02 13:27:11 -04:00
|
|
|
touch_nmi_watchdog();
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2007-06-08 16:47:00 -04:00
|
|
|
if (!pfn_valid(pgdat->node_start_pfn + i))
|
|
|
|
continue;
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
page = pfn_to_page(pgdat->node_start_pfn + i);
|
|
|
|
total++;
|
2005-09-12 12:49:24 -04:00
|
|
|
if (PageReserved(page))
|
|
|
|
reserved++;
|
|
|
|
else if (PageSwapCache(page))
|
|
|
|
cached++;
|
|
|
|
else if (page_count(page))
|
|
|
|
shared += page_count(page) - 1;
|
2008-01-30 07:34:10 -05:00
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
2008-01-30 07:34:10 -05:00
|
|
|
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);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
int after_bootmem;
|
|
|
|
|
2006-03-25 10:30:25 -05:00
|
|
|
static __init void *spp_getpage(void)
|
2008-01-30 07:34:10 -05:00
|
|
|
{
|
2005-04-16 18:20:36 -04:00
|
|
|
void *ptr;
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
if (after_bootmem)
|
2008-01-30 07:34:10 -05:00
|
|
|
ptr = (void *) get_zeroed_page(GFP_ATOMIC);
|
2005-04-16 18:20:36 -04:00
|
|
|
else
|
|
|
|
ptr = alloc_bootmem_pages(PAGE_SIZE);
|
2008-01-30 07:34:10 -05:00
|
|
|
|
|
|
|
if (!ptr || ((unsigned long)ptr & ~PAGE_MASK)) {
|
|
|
|
panic("set_pte_phys: cannot allocate page data %s\n",
|
|
|
|
after_bootmem ? "after bootmem" : "");
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
pr_debug("spp_getpage %p\n", ptr);
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
return ptr;
|
2008-01-30 07:34:10 -05:00
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
static __init void
|
|
|
|
set_pte_phys(unsigned long vaddr, unsigned long phys, pgprot_t prot)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
pgd_t *pgd;
|
|
|
|
pud_t *pud;
|
|
|
|
pmd_t *pmd;
|
|
|
|
pte_t *pte, new_pte;
|
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
pr_debug("set_pte_phys %lx to %lx\n", vaddr, phys);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
pgd = pgd_offset_k(vaddr);
|
|
|
|
if (pgd_none(*pgd)) {
|
2008-01-30 07:34:10 -05:00
|
|
|
printk(KERN_ERR
|
|
|
|
"PGD FIXMAP MISSING, it should be setup in head.S!\n");
|
2005-04-16 18:20:36 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
pud = pud_offset(pgd, vaddr);
|
|
|
|
if (pud_none(*pud)) {
|
2008-01-30 07:34:10 -05:00
|
|
|
pmd = (pmd_t *) spp_getpage();
|
2005-04-16 18:20:36 -04:00
|
|
|
set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE | _PAGE_USER));
|
|
|
|
if (pmd != pmd_offset(pud, 0)) {
|
2008-01-30 07:34:10 -05:00
|
|
|
printk(KERN_ERR "PAGETABLE BUG #01! %p <-> %p\n",
|
2008-01-30 07:34:10 -05:00
|
|
|
pmd, pmd_offset(pud, 0));
|
2005-04-16 18:20:36 -04:00
|
|
|
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)) {
|
2008-01-30 07:34:10 -05:00
|
|
|
printk(KERN_ERR "PAGETABLE BUG #02!\n");
|
2005-04-16 18:20:36 -04:00
|
|
|
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 */
|
2008-01-30 07:34:10 -05:00
|
|
|
void __init
|
|
|
|
__set_fixmap(enum fixed_addresses idx, unsigned long phys, pgprot_t prot)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
unsigned long address = __fix_to_virt(idx);
|
|
|
|
|
|
|
|
if (idx >= __end_of_fixed_addresses) {
|
2008-01-30 07:34:10 -05:00
|
|
|
printk(KERN_ERR "Invalid __set_fixmap\n");
|
2005-04-16 18:20:36 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
set_pte_phys(address, phys, prot);
|
|
|
|
}
|
|
|
|
|
2008-01-30 07:33:17 -05:00
|
|
|
static unsigned long __initdata table_start;
|
|
|
|
static unsigned long __meminitdata table_end;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-05-02 13:27:06 -04:00
|
|
|
static __meminit void *alloc_low_page(unsigned long *phys)
|
2008-01-30 07:34:10 -05:00
|
|
|
{
|
2007-05-02 13:27:06 -04:00
|
|
|
unsigned long pfn = table_end++;
|
2005-04-16 18:20:36 -04:00
|
|
|
void *adr;
|
|
|
|
|
2006-01-17 01:03:41 -05:00
|
|
|
if (after_bootmem) {
|
|
|
|
adr = (void *)get_zeroed_page(GFP_ATOMIC);
|
|
|
|
*phys = __pa(adr);
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2006-01-17 01:03:41 -05:00
|
|
|
return adr;
|
|
|
|
}
|
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
if (pfn >= end_pfn)
|
|
|
|
panic("alloc_low_page: ran out of memory");
|
2007-05-02 13:27:06 -04:00
|
|
|
|
|
|
|
adr = early_ioremap(pfn * PAGE_SIZE, PAGE_SIZE);
|
2006-01-17 01:03:41 -05:00
|
|
|
memset(adr, 0, PAGE_SIZE);
|
2007-05-02 13:27:06 -04:00
|
|
|
*phys = pfn * PAGE_SIZE;
|
|
|
|
return adr;
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-05-02 13:27:06 -04:00
|
|
|
static __meminit void unmap_low_page(void *adr)
|
2008-01-30 07:34:10 -05:00
|
|
|
{
|
2006-01-17 01:03:41 -05:00
|
|
|
if (after_bootmem)
|
|
|
|
return;
|
|
|
|
|
2007-05-02 13:27:06 -04:00
|
|
|
early_iounmap(adr, PAGE_SIZE);
|
2008-01-30 07:34:10 -05:00
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-03-25 10:30:22 -05:00
|
|
|
/* Must run before zap_low_mappings */
|
2007-05-08 03:23:07 -04:00
|
|
|
__meminit void *early_ioremap(unsigned long addr, unsigned long size)
|
2006-03-25 10:30:22 -05:00
|
|
|
{
|
2007-05-02 13:27:06 -04:00
|
|
|
pmd_t *pmd, *last_pmd;
|
2008-01-30 07:34:10 -05:00
|
|
|
unsigned long vaddr;
|
2007-05-02 13:27:06 -04:00
|
|
|
int i, pmds;
|
|
|
|
|
|
|
|
pmds = ((addr & ~PMD_MASK) + size + ~PMD_MASK) / PMD_SIZE;
|
|
|
|
vaddr = __START_KERNEL_map;
|
|
|
|
pmd = level2_kernel_pgt;
|
|
|
|
last_pmd = level2_kernel_pgt + PTRS_PER_PMD - 1;
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2007-05-02 13:27:06 -04:00
|
|
|
for (; pmd <= last_pmd; pmd++, vaddr += PMD_SIZE) {
|
|
|
|
for (i = 0; i < pmds; i++) {
|
|
|
|
if (pmd_present(pmd[i]))
|
2008-01-30 07:34:10 -05:00
|
|
|
goto continue_outer_loop;
|
2007-05-02 13:27:06 -04:00
|
|
|
}
|
|
|
|
vaddr += addr & ~PMD_MASK;
|
|
|
|
addr &= PMD_MASK;
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2007-05-02 13:27:06 -04:00
|
|
|
for (i = 0; i < pmds; i++, addr += PMD_SIZE)
|
2008-01-30 07:31:08 -05:00
|
|
|
set_pmd(pmd+i, __pmd(addr | __PAGE_KERNEL_LARGE_EXEC));
|
2008-01-30 07:33:54 -05:00
|
|
|
__flush_tlb_all();
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2007-05-02 13:27:06 -04:00
|
|
|
return (void *)vaddr;
|
2008-01-30 07:34:10 -05:00
|
|
|
continue_outer_loop:
|
2007-05-02 13:27:06 -04:00
|
|
|
;
|
2006-03-25 10:30:22 -05:00
|
|
|
}
|
2008-01-30 07:34:10 -05:00
|
|
|
printk(KERN_ERR "early_ioremap(0x%lx, %lu) failed\n", addr, size);
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2007-05-02 13:27:06 -04:00
|
|
|
return NULL;
|
2006-03-25 10:30:22 -05:00
|
|
|
}
|
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
/*
|
|
|
|
* To avoid virtual aliases later:
|
|
|
|
*/
|
2007-05-08 03:23:07 -04:00
|
|
|
__meminit void early_iounmap(void *addr, unsigned long size)
|
2006-03-25 10:30:22 -05:00
|
|
|
{
|
2007-05-02 13:27:06 -04:00
|
|
|
unsigned long vaddr;
|
|
|
|
pmd_t *pmd;
|
|
|
|
int i, pmds;
|
|
|
|
|
|
|
|
vaddr = (unsigned long)addr;
|
|
|
|
pmds = ((vaddr & ~PMD_MASK) + size + ~PMD_MASK) / PMD_SIZE;
|
|
|
|
pmd = level2_kernel_pgt + pmd_index(vaddr);
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2007-05-02 13:27:06 -04:00
|
|
|
for (i = 0; i < pmds; i++)
|
|
|
|
pmd_clear(pmd + i);
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2008-01-30 07:33:54 -05:00
|
|
|
__flush_tlb_all();
|
2006-03-25 10:30:22 -05:00
|
|
|
}
|
|
|
|
|
2006-01-17 01:03:41 -05:00
|
|
|
static void __meminit
|
2006-09-26 04:52:36 -04:00
|
|
|
phys_pmd_init(pmd_t *pmd_page, unsigned long address, unsigned long end)
|
2006-01-17 01:03:41 -05:00
|
|
|
{
|
2006-09-26 04:52:36 -04:00
|
|
|
int i = pmd_index(address);
|
2006-01-17 01:03:41 -05:00
|
|
|
|
2006-09-26 04:52:36 -04:00
|
|
|
for (; i < PTRS_PER_PMD; i++, address += PMD_SIZE) {
|
|
|
|
pmd_t *pmd = pmd_page + pmd_index(address);
|
2006-01-17 01:03:41 -05:00
|
|
|
|
2006-06-26 07:59:02 -04:00
|
|
|
if (address >= end) {
|
2008-01-30 07:34:10 -05:00
|
|
|
if (!after_bootmem) {
|
2006-06-26 07:59:02 -04:00
|
|
|
for (; i < PTRS_PER_PMD; i++, pmd++)
|
|
|
|
set_pmd(pmd, __pmd(0));
|
2008-01-30 07:34:10 -05:00
|
|
|
}
|
2006-01-17 01:03:41 -05:00
|
|
|
break;
|
|
|
|
}
|
2006-09-26 04:52:36 -04:00
|
|
|
|
|
|
|
if (pmd_val(*pmd))
|
|
|
|
continue;
|
|
|
|
|
2008-02-04 10:48:09 -05:00
|
|
|
set_pte((pte_t *)pmd,
|
|
|
|
pfn_pte(address >> PAGE_SHIFT, PAGE_KERNEL_LARGE));
|
2006-01-17 01:03:41 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __meminit
|
|
|
|
phys_pmd_update(pud_t *pud, unsigned long address, unsigned long end)
|
|
|
|
{
|
2008-01-30 07:34:10 -05:00
|
|
|
pmd_t *pmd = pmd_offset(pud, 0);
|
2006-09-26 04:52:36 -04:00
|
|
|
spin_lock(&init_mm.page_table_lock);
|
|
|
|
phys_pmd_init(pmd, address, end);
|
|
|
|
spin_unlock(&init_mm.page_table_lock);
|
|
|
|
__flush_tlb_all();
|
2006-01-17 01:03:41 -05:00
|
|
|
}
|
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
static void __meminit
|
|
|
|
phys_pud_init(pud_t *pud_page, unsigned long addr, unsigned long end)
|
|
|
|
{
|
2006-09-26 04:52:36 -04:00
|
|
|
int i = pud_index(addr);
|
2006-01-17 01:03:41 -05:00
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
for (; i < PTRS_PER_PUD; i++, addr = (addr & PUD_MASK) + PUD_SIZE) {
|
2006-09-26 04:52:36 -04:00
|
|
|
unsigned long pmd_phys;
|
|
|
|
pud_t *pud = pud_page + pud_index(addr);
|
2005-04-16 18:20:36 -04:00
|
|
|
pmd_t *pmd;
|
|
|
|
|
2006-09-26 04:52:36 -04:00
|
|
|
if (addr >= end)
|
2005-04-16 18:20:36 -04:00
|
|
|
break;
|
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
if (!after_bootmem &&
|
|
|
|
!e820_any_mapped(addr, addr+PUD_SIZE, 0)) {
|
|
|
|
set_pud(pud, __pud(0));
|
2005-04-16 18:20:36 -04:00
|
|
|
continue;
|
2008-01-30 07:34:10 -05:00
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-09-26 04:52:36 -04:00
|
|
|
if (pud_val(*pud)) {
|
|
|
|
phys_pmd_update(pud, addr, end);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2007-05-02 13:27:06 -04:00
|
|
|
pmd = alloc_low_page(&pmd_phys);
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2006-01-17 01:03:41 -05:00
|
|
|
spin_lock(&init_mm.page_table_lock);
|
2005-04-16 18:20:36 -04:00
|
|
|
set_pud(pud, __pud(pmd_phys | _KERNPG_TABLE));
|
2006-09-26 04:52:36 -04:00
|
|
|
phys_pmd_init(pmd, addr, end);
|
2006-01-17 01:03:41 -05:00
|
|
|
spin_unlock(&init_mm.page_table_lock);
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2007-05-02 13:27:06 -04:00
|
|
|
unmap_low_page(pmd);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
2008-01-30 07:33:54 -05:00
|
|
|
__flush_tlb_all();
|
2008-01-30 07:34:10 -05:00
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
static void __init find_early_table_space(unsigned long end)
|
|
|
|
{
|
2006-01-11 16:46:57 -05:00
|
|
|
unsigned long puds, pmds, tables, start;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
/*
|
|
|
|
* 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;
|
2008-02-01 11:49:41 -05:00
|
|
|
table_start = find_e820_area(start, end, tables, PAGE_SIZE);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (table_start == -1UL)
|
|
|
|
panic("Cannot find space for the kernel page tables");
|
|
|
|
|
|
|
|
table_start >>= PAGE_SHIFT;
|
|
|
|
table_end = table_start;
|
2006-01-17 01:03:41 -05:00
|
|
|
|
|
|
|
early_printk("kernel direct mapping tables up to %lx @ %lx-%lx\n",
|
2006-06-26 07:59:02 -04:00
|
|
|
end, table_start << PAGE_SHIFT,
|
|
|
|
(table_start << PAGE_SHIFT) + tables);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2007-11-28 19:21:58 -05:00
|
|
|
void __init_refok init_memory_mapping(unsigned long start, unsigned long end)
|
2008-01-30 07:34:10 -05:00
|
|
|
{
|
|
|
|
unsigned long next;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
pr_debug("init_memory_mapping\n");
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
/*
|
2005-04-16 18:20:36 -04:00
|
|
|
* Find space for the kernel direct mapping tables.
|
2008-01-30 07:34:10 -05:00
|
|
|
*
|
|
|
|
* Later we should allocate these tables in the local node of the
|
|
|
|
* memory mapped. Unfortunately this is done currently before the
|
|
|
|
* nodes are discovered.
|
2005-04-16 18:20:36 -04:00
|
|
|
*/
|
2006-01-17 01:03:41 -05:00
|
|
|
if (!after_bootmem)
|
|
|
|
find_early_table_space(end);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
start = (unsigned long)__va(start);
|
|
|
|
end = (unsigned long)__va(end);
|
|
|
|
|
|
|
|
for (; start < end; start = next) {
|
2006-01-17 01:03:41 -05:00
|
|
|
pgd_t *pgd = pgd_offset_k(start);
|
2008-01-30 07:34:10 -05:00
|
|
|
unsigned long pud_phys;
|
2006-01-17 01:03:41 -05:00
|
|
|
pud_t *pud;
|
|
|
|
|
|
|
|
if (after_bootmem)
|
2006-06-26 07:57:56 -04:00
|
|
|
pud = pud_offset(pgd, start & PGDIR_MASK);
|
2006-01-17 01:03:41 -05:00
|
|
|
else
|
2007-05-02 13:27:06 -04:00
|
|
|
pud = alloc_low_page(&pud_phys);
|
2006-01-17 01:03:41 -05:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
next = start + PGDIR_SIZE;
|
2008-01-30 07:34:10 -05:00
|
|
|
if (next > end)
|
|
|
|
next = end;
|
2005-04-16 18:20:36 -04:00
|
|
|
phys_pud_init(pud, __pa(start), __pa(next));
|
2006-01-17 01:03:41 -05:00
|
|
|
if (!after_bootmem)
|
|
|
|
set_pgd(pgd_offset_k(start), mk_kernel_pgd(pud_phys));
|
2007-05-02 13:27:06 -04:00
|
|
|
unmap_low_page(pud);
|
2008-01-30 07:34:10 -05:00
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-01-17 01:03:41 -05:00
|
|
|
if (!after_bootmem)
|
2007-07-22 05:12:29 -04:00
|
|
|
mmu_cr4_features = read_cr4();
|
2005-04-16 18:20:36 -04:00
|
|
|
__flush_tlb_all();
|
2008-01-30 07:33:17 -05:00
|
|
|
|
2008-02-01 11:49:41 -05:00
|
|
|
if (!after_bootmem)
|
|
|
|
reserve_early(table_start << PAGE_SHIFT,
|
|
|
|
table_end << PAGE_SHIFT, "PGTABLE");
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2005-06-23 03:08:06 -04:00
|
|
|
#ifndef CONFIG_NUMA
|
2005-04-16 18:20:36 -04:00
|
|
|
void __init paging_init(void)
|
|
|
|
{
|
2006-10-11 04:20:39 -04:00
|
|
|
unsigned long max_zone_pfns[MAX_NR_ZONES];
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2006-10-11 04:20:39 -04:00
|
|
|
memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
|
|
|
|
max_zone_pfns[ZONE_DMA] = MAX_DMA_PFN;
|
|
|
|
max_zone_pfns[ZONE_DMA32] = MAX_DMA32_PFN;
|
|
|
|
max_zone_pfns[ZONE_NORMAL] = end_pfn;
|
|
|
|
|
2006-01-17 01:03:41 -05:00
|
|
|
memory_present(0, 0, end_pfn);
|
|
|
|
sparse_init();
|
2006-09-27 04:49:52 -04:00
|
|
|
free_area_init_nodes(max_zone_pfns);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-01-17 01:03:41 -05:00
|
|
|
/*
|
|
|
|
* Memory hotplug specific functions
|
|
|
|
*/
|
|
|
|
void online_page(struct page *page)
|
|
|
|
{
|
|
|
|
ClearPageReserved(page);
|
2006-03-22 03:08:40 -05:00
|
|
|
init_page_count(page);
|
2006-01-17 01:03:41 -05:00
|
|
|
__free_page(page);
|
|
|
|
totalram_pages++;
|
|
|
|
num_physpages++;
|
|
|
|
}
|
|
|
|
|
2006-06-27 05:53:30 -04:00
|
|
|
#ifdef CONFIG_MEMORY_HOTPLUG
|
2006-04-07 13:49:15 -04:00
|
|
|
/*
|
|
|
|
* Memory is added always to NORMAL zone. This means you will never get
|
|
|
|
* additional DMA/DMA32 memory.
|
|
|
|
*/
|
2006-06-27 05:53:30 -04:00
|
|
|
int arch_add_memory(int nid, u64 start, u64 size)
|
2006-01-17 01:03:41 -05:00
|
|
|
{
|
2006-06-27 05:53:30 -04:00
|
|
|
struct pglist_data *pgdat = NODE_DATA(nid);
|
2006-09-26 02:31:09 -04:00
|
|
|
struct zone *zone = pgdat->node_zones + ZONE_NORMAL;
|
2006-01-17 01:03:41 -05:00
|
|
|
unsigned long start_pfn = start >> PAGE_SHIFT;
|
|
|
|
unsigned long nr_pages = size >> PAGE_SHIFT;
|
|
|
|
int ret;
|
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
init_memory_mapping(start, start + size-1);
|
2006-10-01 02:27:09 -04:00
|
|
|
|
2006-01-17 01:03:41 -05:00
|
|
|
ret = __add_pages(zone, start_pfn, nr_pages);
|
2008-01-30 07:34:10 -05:00
|
|
|
WARN_ON(1);
|
2006-01-17 01:03:41 -05:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2006-06-27 05:53:30 -04:00
|
|
|
EXPORT_SYMBOL_GPL(arch_add_memory);
|
2006-01-17 01:03:41 -05:00
|
|
|
|
2006-11-19 01:19:40 -05:00
|
|
|
#if !defined(CONFIG_ACPI_NUMA) && defined(CONFIG_NUMA)
|
2006-10-01 02:27:06 -04:00
|
|
|
int memory_add_physaddr_to_nid(u64 start)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2006-10-01 02:27:07 -04:00
|
|
|
EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
|
2006-10-01 02:27:06 -04:00
|
|
|
#endif
|
|
|
|
|
2006-10-01 02:27:09 -04:00
|
|
|
#endif /* CONFIG_MEMORY_HOTPLUG */
|
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
static struct kcore_list kcore_mem, kcore_vmalloc, kcore_kernel,
|
|
|
|
kcore_modules, kcore_vsyscall;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
void __init mem_init(void)
|
|
|
|
{
|
2005-09-12 12:49:24 -04:00
|
|
|
long codesize, reservedpages, datasize, initsize;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-06-26 07:58:11 -04:00
|
|
|
pci_iommu_alloc();
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-01-30 07:32:36 -05:00
|
|
|
/* clear_bss() already clear the empty_zero_page */
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-01-30 07:32:36 -05:00
|
|
|
/* temporary debugging - double check it's true: */
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < 1024; i++)
|
|
|
|
WARN_ON_ONCE(empty_zero_page[i]);
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
reservedpages = 0;
|
|
|
|
|
|
|
|
/* this will put all low memory onto the freelists */
|
2005-06-23 03:08:06 -04:00
|
|
|
#ifdef CONFIG_NUMA
|
2005-09-12 12:49:24 -04:00
|
|
|
totalram_pages = numa_free_all_bootmem();
|
2005-04-16 18:20:36 -04:00
|
|
|
#else
|
2005-09-12 12:49:24 -04:00
|
|
|
totalram_pages = free_all_bootmem();
|
2005-04-16 18:20:36 -04:00
|
|
|
#endif
|
2006-09-27 04:49:52 -04:00
|
|
|
reservedpages = end_pfn - totalram_pages -
|
|
|
|
absent_pages_in_range(0, end_pfn);
|
2005-04-16 18:20:36 -04:00
|
|
|
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 */
|
2008-01-30 07:34:10 -05:00
|
|
|
kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT);
|
|
|
|
kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
|
2005-04-16 18:20:36 -04:00
|
|
|
VMALLOC_END-VMALLOC_START);
|
|
|
|
kclist_add(&kcore_kernel, &_stext, _end - _stext);
|
|
|
|
kclist_add(&kcore_modules, (void *)MODULES_VADDR, MODULES_LEN);
|
2008-01-30 07:34:10 -05:00
|
|
|
kclist_add(&kcore_vsyscall, (void *)VSYSCALL_START,
|
2005-04-16 18:20:36 -04:00
|
|
|
VSYSCALL_END - VSYSCALL_START);
|
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
printk(KERN_INFO "Memory: %luk/%luk available (%ldk kernel code, "
|
2008-01-30 07:34:10 -05:00
|
|
|
"%ldk reserved, %ldk data, %ldk init)\n",
|
2005-04-16 18:20:36 -04:00
|
|
|
(unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
|
|
|
|
end_pfn << (PAGE_SHIFT-10),
|
|
|
|
codesize >> 10,
|
|
|
|
reservedpages << (PAGE_SHIFT-10),
|
|
|
|
datasize >> 10,
|
|
|
|
initsize >> 10);
|
|
|
|
}
|
|
|
|
|
2006-06-26 07:56:16 -04:00
|
|
|
void free_init_pages(char *what, unsigned long begin, unsigned long end)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
unsigned long addr;
|
|
|
|
|
2006-06-26 07:56:16 -04:00
|
|
|
if (begin >= end)
|
|
|
|
return;
|
|
|
|
|
2008-01-30 07:34:09 -05:00
|
|
|
/*
|
|
|
|
* If debugging page accesses then do not free this memory but
|
|
|
|
* mark them not present - any buggy init-section access will
|
|
|
|
* create a kernel page fault:
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_DEBUG_PAGEALLOC
|
|
|
|
printk(KERN_INFO "debug: unmapping init memory %08lx..%08lx\n",
|
|
|
|
begin, PAGE_ALIGN(end));
|
|
|
|
set_memory_np(begin, (end - begin) >> PAGE_SHIFT);
|
|
|
|
#else
|
[PATCH] x86: tighten kernel image page access rights
On x86-64, kernel memory freed after init can be entirely unmapped instead
of just getting 'poisoned' by overwriting with a debug pattern.
On i386 and x86-64 (under CONFIG_DEBUG_RODATA), kernel text and bug table
can also be write-protected.
Compared to the first version, this one prevents re-creating deleted
mappings in the kernel image range on x86-64, if those got removed
previously. This, together with the original changes, prevents temporarily
having inconsistent mappings when cacheability attributes are being
changed on such pages (e.g. from AGP code). While on i386 such duplicate
mappings don't exist, the same change is done there, too, both for
consistency and because checking pte_present() before using various other
pte_XXX functions is a requirement anyway. At once, i386 code gets
adjusted to use pte_huge() instead of open coding this.
AK: split out cpa() changes
Signed-off-by: Jan Beulich <jbeulich@novell.com>
Signed-off-by: Andi Kleen <ak@suse.de>
2007-05-02 13:27:10 -04:00
|
|
|
printk(KERN_INFO "Freeing %s: %luk freed\n", what, (end - begin) >> 10);
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2006-06-26 07:56:16 -04:00
|
|
|
for (addr = begin; addr < end; addr += PAGE_SIZE) {
|
Revert "[PATCH] x86: __pa and __pa_symbol address space separation"
This was broken. It adds complexity, for no good reason. Rather than
separate __pa() and __pa_symbol(), we should deprecate __pa_symbol(),
and preferably __pa() too - and just use "virt_to_phys()" instead, which
is more readable and has nicer semantics.
However, right now, just undo the separation, and make __pa_symbol() be
the exact same as __pa(). That fixes the bugs this patch introduced,
and we can do the fairly obvious cleanups later.
Do the new __phys_addr() function (which is now the actual workhorse for
the unified __pa()/__pa_symbol()) as a real external function, that way
all the potential issues with compile/link-time optimizations of
constant symbol addresses go away, and we can also, if we choose to, add
more sanity-checking of the argument.
Cc: Eric W. Biederman <ebiederm@xmission.com>
Cc: Vivek Goyal <vgoyal@in.ibm.com>
Cc: Andi Kleen <ak@suse.de>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-07 11:44:24 -04:00
|
|
|
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);
|
2005-04-16 18:20:36 -04:00
|
|
|
totalram_pages++;
|
|
|
|
}
|
2008-01-30 07:34:09 -05:00
|
|
|
#endif
|
2006-06-26 07:56:16 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void free_initmem(void)
|
|
|
|
{
|
|
|
|
free_init_pages("unused kernel memory",
|
Revert "[PATCH] x86: __pa and __pa_symbol address space separation"
This was broken. It adds complexity, for no good reason. Rather than
separate __pa() and __pa_symbol(), we should deprecate __pa_symbol(),
and preferably __pa() too - and just use "virt_to_phys()" instead, which
is more readable and has nicer semantics.
However, right now, just undo the separation, and make __pa_symbol() be
the exact same as __pa(). That fixes the bugs this patch introduced,
and we can do the fairly obvious cleanups later.
Do the new __phys_addr() function (which is now the actual workhorse for
the unified __pa()/__pa_symbol()) as a real external function, that way
all the potential issues with compile/link-time optimizations of
constant symbol addresses go away, and we can also, if we choose to, add
more sanity-checking of the argument.
Cc: Eric W. Biederman <ebiederm@xmission.com>
Cc: Vivek Goyal <vgoyal@in.ibm.com>
Cc: Andi Kleen <ak@suse.de>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-07 11:44:24 -04:00
|
|
|
(unsigned long)(&__init_begin),
|
|
|
|
(unsigned long)(&__init_end));
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2006-01-06 03:12:04 -05:00
|
|
|
#ifdef CONFIG_DEBUG_RODATA
|
2008-01-30 07:34:08 -05:00
|
|
|
const int rodata_test_data = 0xC3;
|
|
|
|
EXPORT_SYMBOL_GPL(rodata_test_data);
|
2006-01-06 03:12:04 -05:00
|
|
|
|
|
|
|
void mark_rodata_ro(void)
|
|
|
|
{
|
Revert "[PATCH] x86: __pa and __pa_symbol address space separation"
This was broken. It adds complexity, for no good reason. Rather than
separate __pa() and __pa_symbol(), we should deprecate __pa_symbol(),
and preferably __pa() too - and just use "virt_to_phys()" instead, which
is more readable and has nicer semantics.
However, right now, just undo the separation, and make __pa_symbol() be
the exact same as __pa(). That fixes the bugs this patch introduced,
and we can do the fairly obvious cleanups later.
Do the new __phys_addr() function (which is now the actual workhorse for
the unified __pa()/__pa_symbol()) as a real external function, that way
all the potential issues with compile/link-time optimizations of
constant symbol addresses go away, and we can also, if we choose to, add
more sanity-checking of the argument.
Cc: Eric W. Biederman <ebiederm@xmission.com>
Cc: Vivek Goyal <vgoyal@in.ibm.com>
Cc: Andi Kleen <ak@suse.de>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-07 11:44:24 -04:00
|
|
|
unsigned long start = (unsigned long)_stext, end;
|
2006-01-06 03:12:04 -05:00
|
|
|
|
2007-07-26 15:07:21 -04:00
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
/* It must still be possible to apply SMP alternatives. */
|
|
|
|
if (num_possible_cpus() > 1)
|
|
|
|
start = (unsigned long)_etext;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_KPROBES
|
|
|
|
start = (unsigned long)__start_rodata;
|
|
|
|
#endif
|
2008-01-30 07:34:10 -05:00
|
|
|
|
Revert "[PATCH] x86: __pa and __pa_symbol address space separation"
This was broken. It adds complexity, for no good reason. Rather than
separate __pa() and __pa_symbol(), we should deprecate __pa_symbol(),
and preferably __pa() too - and just use "virt_to_phys()" instead, which
is more readable and has nicer semantics.
However, right now, just undo the separation, and make __pa_symbol() be
the exact same as __pa(). That fixes the bugs this patch introduced,
and we can do the fairly obvious cleanups later.
Do the new __phys_addr() function (which is now the actual workhorse for
the unified __pa()/__pa_symbol()) as a real external function, that way
all the potential issues with compile/link-time optimizations of
constant symbol addresses go away, and we can also, if we choose to, add
more sanity-checking of the argument.
Cc: Eric W. Biederman <ebiederm@xmission.com>
Cc: Vivek Goyal <vgoyal@in.ibm.com>
Cc: Andi Kleen <ak@suse.de>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-07 11:44:24 -04:00
|
|
|
end = (unsigned long)__end_rodata;
|
|
|
|
start = (start + PAGE_SIZE - 1) & PAGE_MASK;
|
|
|
|
end &= PAGE_MASK;
|
|
|
|
if (end <= start)
|
|
|
|
return;
|
|
|
|
|
2006-01-06 03:12:04 -05:00
|
|
|
|
[PATCH] x86: tighten kernel image page access rights
On x86-64, kernel memory freed after init can be entirely unmapped instead
of just getting 'poisoned' by overwriting with a debug pattern.
On i386 and x86-64 (under CONFIG_DEBUG_RODATA), kernel text and bug table
can also be write-protected.
Compared to the first version, this one prevents re-creating deleted
mappings in the kernel image range on x86-64, if those got removed
previously. This, together with the original changes, prevents temporarily
having inconsistent mappings when cacheability attributes are being
changed on such pages (e.g. from AGP code). While on i386 such duplicate
mappings don't exist, the same change is done there, too, both for
consistency and because checking pte_present() before using various other
pte_XXX functions is a requirement anyway. At once, i386 code gets
adjusted to use pte_huge() instead of open coding this.
AK: split out cpa() changes
Signed-off-by: Jan Beulich <jbeulich@novell.com>
Signed-off-by: Andi Kleen <ak@suse.de>
2007-05-02 13:27:10 -04:00
|
|
|
printk(KERN_INFO "Write protecting the kernel read-only data: %luk\n",
|
Revert "[PATCH] x86: __pa and __pa_symbol address space separation"
This was broken. It adds complexity, for no good reason. Rather than
separate __pa() and __pa_symbol(), we should deprecate __pa_symbol(),
and preferably __pa() too - and just use "virt_to_phys()" instead, which
is more readable and has nicer semantics.
However, right now, just undo the separation, and make __pa_symbol() be
the exact same as __pa(). That fixes the bugs this patch introduced,
and we can do the fairly obvious cleanups later.
Do the new __phys_addr() function (which is now the actual workhorse for
the unified __pa()/__pa_symbol()) as a real external function, that way
all the potential issues with compile/link-time optimizations of
constant symbol addresses go away, and we can also, if we choose to, add
more sanity-checking of the argument.
Cc: Eric W. Biederman <ebiederm@xmission.com>
Cc: Vivek Goyal <vgoyal@in.ibm.com>
Cc: Andi Kleen <ak@suse.de>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-07 11:44:24 -04:00
|
|
|
(end - start) >> 10);
|
2008-02-06 16:39:45 -05:00
|
|
|
set_memory_ro(start, (end - start) >> PAGE_SHIFT);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The rodata section (but not the kernel text!) should also be
|
|
|
|
* not-executable.
|
|
|
|
*/
|
|
|
|
start = ((unsigned long)__start_rodata + PAGE_SIZE - 1) & PAGE_MASK;
|
|
|
|
set_memory_nx(start, (end - start) >> PAGE_SHIFT);
|
2006-01-06 03:12:04 -05:00
|
|
|
|
2008-01-30 07:34:09 -05:00
|
|
|
rodata_test();
|
|
|
|
|
2008-01-30 07:33:42 -05:00
|
|
|
#ifdef CONFIG_CPA_DEBUG
|
2008-01-30 07:34:10 -05:00
|
|
|
printk(KERN_INFO "Testing CPA: undo %lx-%lx\n", start, end);
|
2008-01-30 07:34:06 -05:00
|
|
|
set_memory_rw(start, (end-start) >> PAGE_SHIFT);
|
2008-01-30 07:33:42 -05:00
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
printk(KERN_INFO "Testing CPA: again\n");
|
2008-01-30 07:34:06 -05:00
|
|
|
set_memory_ro(start, (end-start) >> PAGE_SHIFT);
|
2008-01-30 07:33:42 -05:00
|
|
|
#endif
|
2006-01-06 03:12:04 -05:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
#ifdef CONFIG_BLK_DEV_INITRD
|
|
|
|
void free_initrd_mem(unsigned long start, unsigned long end)
|
|
|
|
{
|
Revert "[PATCH] x86: __pa and __pa_symbol address space separation"
This was broken. It adds complexity, for no good reason. Rather than
separate __pa() and __pa_symbol(), we should deprecate __pa_symbol(),
and preferably __pa() too - and just use "virt_to_phys()" instead, which
is more readable and has nicer semantics.
However, right now, just undo the separation, and make __pa_symbol() be
the exact same as __pa(). That fixes the bugs this patch introduced,
and we can do the fairly obvious cleanups later.
Do the new __phys_addr() function (which is now the actual workhorse for
the unified __pa()/__pa_symbol()) as a real external function, that way
all the potential issues with compile/link-time optimizations of
constant symbol addresses go away, and we can also, if we choose to, add
more sanity-checking of the argument.
Cc: Eric W. Biederman <ebiederm@xmission.com>
Cc: Vivek Goyal <vgoyal@in.ibm.com>
Cc: Andi Kleen <ak@suse.de>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-07 11:44:24 -04:00
|
|
|
free_init_pages("initrd memory", start, end);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
void __init reserve_bootmem_generic(unsigned long phys, unsigned len)
|
|
|
|
{
|
2005-06-23 03:08:06 -04:00
|
|
|
#ifdef CONFIG_NUMA
|
2005-04-16 18:20:36 -04:00
|
|
|
int nid = phys_to_nid(phys);
|
2006-11-14 10:57:46 -05:00
|
|
|
#endif
|
|
|
|
unsigned long pfn = phys >> PAGE_SHIFT;
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2006-11-14 10:57:46 -05:00
|
|
|
if (pfn >= end_pfn) {
|
2008-01-30 07:34:10 -05:00
|
|
|
/*
|
|
|
|
* This can happen with kdump kernels when accessing
|
|
|
|
* firmware tables:
|
|
|
|
*/
|
2006-11-14 10:57:46 -05:00
|
|
|
if (pfn < end_pfn_map)
|
|
|
|
return;
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2006-11-14 10:57:46 -05:00
|
|
|
printk(KERN_ERR "reserve_bootmem: illegal reserve %lx %u\n",
|
|
|
|
phys, len);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Should check here against the e820 map to avoid double free */
|
|
|
|
#ifdef CONFIG_NUMA
|
2008-01-30 07:34:10 -05:00
|
|
|
reserve_bootmem_node(NODE_DATA(nid), phys, len);
|
|
|
|
#else
|
|
|
|
reserve_bootmem(phys, len);
|
2005-04-16 18:20:36 -04:00
|
|
|
#endif
|
2006-09-27 04:49:56 -04:00
|
|
|
if (phys+len <= MAX_DMA_PFN*PAGE_SIZE) {
|
2005-11-05 11:25:53 -05:00
|
|
|
dma_reserve += len / PAGE_SIZE;
|
2006-09-27 04:49:56 -04:00
|
|
|
set_dma_reserve(dma_reserve);
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
int kern_addr_valid(unsigned long addr)
|
|
|
|
{
|
2005-04-16 18:20:36 -04:00
|
|
|
unsigned long above = ((long)addr) >> __VIRTUAL_MASK_SHIFT;
|
2008-01-30 07:34:10 -05:00
|
|
|
pgd_t *pgd;
|
|
|
|
pud_t *pud;
|
|
|
|
pmd_t *pmd;
|
|
|
|
pte_t *pte;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
if (above != 0 && above != -1UL)
|
2008-01-30 07:34:10 -05:00
|
|
|
return 0;
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
pgd = pgd_offset_k(addr);
|
|
|
|
if (pgd_none(*pgd))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
pud = pud_offset(pgd, addr);
|
|
|
|
if (pud_none(*pud))
|
2008-01-30 07:34:10 -05:00
|
|
|
return 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
pmd = pmd_offset(pud, addr);
|
|
|
|
if (pmd_none(*pmd))
|
|
|
|
return 0;
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
if (pmd_large(*pmd))
|
|
|
|
return pfn_valid(pmd_pfn(*pmd));
|
|
|
|
|
|
|
|
pte = pte_offset_kernel(pmd, addr);
|
|
|
|
if (pte_none(*pte))
|
|
|
|
return 0;
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
return pfn_valid(pte_pfn(*pte));
|
|
|
|
}
|
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
/*
|
|
|
|
* A pseudo VMA 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:
|
|
|
|
*/
|
2005-04-16 18:20:36 -04:00
|
|
|
static struct vm_area_struct gate_vma = {
|
2008-01-30 07:34:10 -05:00
|
|
|
.vm_start = VSYSCALL_START,
|
|
|
|
.vm_end = VSYSCALL_START + (VSYSCALL_MAPPED_PAGES * PAGE_SIZE),
|
|
|
|
.vm_page_prot = PAGE_READONLY_EXEC,
|
|
|
|
.vm_flags = VM_READ | VM_EXEC
|
2005-04-16 18:20:36 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct vm_area_struct *get_gate_vma(struct task_struct *tsk)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_IA32_EMULATION
|
2005-04-16 18:24:55 -04:00
|
|
|
if (test_tsk_thread_flag(tsk, TIF_IA32))
|
|
|
|
return NULL;
|
2005-04-16 18:20:36 -04:00
|
|
|
#endif
|
|
|
|
return &gate_vma;
|
|
|
|
}
|
|
|
|
|
|
|
|
int in_gate_area(struct task_struct *task, unsigned long addr)
|
|
|
|
{
|
|
|
|
struct vm_area_struct *vma = get_gate_vma(task);
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2005-04-16 18:24:55 -04:00
|
|
|
if (!vma)
|
|
|
|
return 0;
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
return (addr >= vma->vm_start) && (addr < vma->vm_end);
|
|
|
|
}
|
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
/*
|
|
|
|
* 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:
|
2005-04-16 18:20:36 -04:00
|
|
|
*/
|
|
|
|
int in_gate_area_no_task(unsigned long addr)
|
|
|
|
{
|
2005-04-16 18:24:55 -04:00
|
|
|
return (addr >= VSYSCALL_START) && (addr < VSYSCALL_END);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
2007-06-01 03:46:28 -04:00
|
|
|
|
2007-07-21 11:10:01 -04:00
|
|
|
const char *arch_vma_name(struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
if (vma->vm_mm && vma->vm_start == (long)vma->vm_mm->context.vdso)
|
|
|
|
return "[vdso]";
|
|
|
|
if (vma == &gate_vma)
|
|
|
|
return "[vsyscall]";
|
|
|
|
return NULL;
|
|
|
|
}
|
2007-10-16 04:24:15 -04:00
|
|
|
|
|
|
|
#ifdef CONFIG_SPARSEMEM_VMEMMAP
|
|
|
|
/*
|
|
|
|
* Initialise the sparsemem vmemmap using huge-pages at the PMD level.
|
|
|
|
*/
|
2008-01-30 07:34:10 -05:00
|
|
|
int __meminit
|
|
|
|
vmemmap_populate(struct page *start_page, unsigned long size, int node)
|
2007-10-16 04:24:15 -04:00
|
|
|
{
|
|
|
|
unsigned long addr = (unsigned long)start_page;
|
|
|
|
unsigned long end = (unsigned long)(start_page + size);
|
|
|
|
unsigned long next;
|
|
|
|
pgd_t *pgd;
|
|
|
|
pud_t *pud;
|
|
|
|
pmd_t *pmd;
|
|
|
|
|
|
|
|
for (; addr < end; addr = next) {
|
|
|
|
next = pmd_addr_end(addr, end);
|
|
|
|
|
|
|
|
pgd = vmemmap_pgd_populate(addr, node);
|
|
|
|
if (!pgd)
|
|
|
|
return -ENOMEM;
|
2008-01-30 07:34:10 -05:00
|
|
|
|
2007-10-16 04:24:15 -04:00
|
|
|
pud = vmemmap_pud_populate(pgd, addr, node);
|
|
|
|
if (!pud)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
pmd = pmd_offset(pud, addr);
|
|
|
|
if (pmd_none(*pmd)) {
|
|
|
|
pte_t entry;
|
2008-01-30 07:34:10 -05:00
|
|
|
void *p;
|
|
|
|
|
|
|
|
p = vmemmap_alloc_block(PMD_SIZE, node);
|
2007-10-16 04:24:15 -04:00
|
|
|
if (!p)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-01-30 07:34:10 -05:00
|
|
|
entry = pfn_pte(__pa(p) >> PAGE_SHIFT,
|
|
|
|
PAGE_KERNEL_LARGE);
|
2007-10-16 04:24:15 -04:00
|
|
|
set_pmd(pmd, __pmd(pte_val(entry)));
|
|
|
|
|
|
|
|
printk(KERN_DEBUG " [%lx-%lx] PMD ->%p on node %d\n",
|
|
|
|
addr, addr + PMD_SIZE - 1, p, node);
|
2008-01-30 07:34:10 -05:00
|
|
|
} else {
|
2007-10-16 04:24:15 -04:00
|
|
|
vmemmap_verify((pte_t *)pmd, node, addr, next);
|
2008-01-30 07:34:10 -05:00
|
|
|
}
|
2007-10-16 04:24:15 -04:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|