From b4416a1be86b0c7bdde4e6ba526715c1a055746f Mon Sep 17 00:00:00 2001 From: Ingo Molnar Date: Wed, 30 Jan 2008 13:33:41 +0100 Subject: [PATCH] x86: clean up arch/x86/mm/pageattr_64.c clean up arch/x86/mm/pageattr_64.c. no code changed: text data bss dec hex filename 1751 16 0 1767 6e7 pageattr_64.o.before 1751 16 0 1767 6e7 pageattr_64.o.after Signed-off-by: Ingo Molnar Signed-off-by: Thomas Gleixner --- arch/x86/mm/pageattr_64.c | 143 ++++++++++++++++++++++++++-------------------- 1 file changed, 81 insertions(+), 62 deletions(-) diff --git a/arch/x86/mm/pageattr_64.c b/arch/x86/mm/pageattr_64.c index c40afba..14ab327 100644 --- a/arch/x86/mm/pageattr_64.c +++ b/arch/x86/mm/pageattr_64.c @@ -1,48 +1,54 @@ -/* - * Copyright 2002 Andi Kleen, SuSE Labs. +/* + * Copyright 2002 Andi Kleen, SuSE Labs. * Thanks to Ben LaHaise for precious feedback. - */ + */ -#include -#include #include #include +#include #include -#include +#include + #include #include +#include #include pte_t *lookup_address(unsigned long address) -{ +{ pgd_t *pgd = pgd_offset_k(address); pud_t *pud; pmd_t *pmd; pte_t *pte; + if (pgd_none(*pgd)) return NULL; pud = pud_offset(pgd, address); if (!pud_present(*pud)) - return NULL; + return NULL; pmd = pmd_offset(pud, address); if (!pmd_present(*pmd)) - return NULL; + return NULL; if (pmd_large(*pmd)) return (pte_t *)pmd; + pte = pte_offset_kernel(pmd, address); if (pte && !pte_present(*pte)) - pte = NULL; + pte = NULL; + return pte; -} +} -static struct page *split_large_page(unsigned long address, pgprot_t prot, - pgprot_t ref_prot) -{ - int i; +static struct page * +split_large_page(unsigned long address, pgprot_t prot, pgprot_t ref_prot) +{ unsigned long addr; - struct page *base = alloc_pages(GFP_KERNEL, 0); + struct page *base; pte_t *pbase; - if (!base) + int i; + + base = alloc_pages(GFP_KERNEL, 0); + if (!base) return NULL; /* * page_private is used to track the number of entries in @@ -52,20 +58,21 @@ static struct page *split_large_page(unsigned long address, pgprot_t prot, page_private(base) = 0; address = __pa(address); - addr = address & LARGE_PAGE_MASK; + addr = address & LARGE_PAGE_MASK; pbase = (pte_t *)page_address(base); for (i = 0; i < PTRS_PER_PTE; i++, addr += PAGE_SIZE) { - pbase[i] = pfn_pte(addr >> PAGE_SHIFT, + pbase[i] = pfn_pte(addr >> PAGE_SHIFT, addr == address ? prot : ref_prot); } return base; -} +} -void clflush_cache_range(void *adr, int size) +void clflush_cache_range(void *addr, int size) { int i; + for (i = 0; i < size; i += boot_cpu_data.x86_clflush_size) - clflush(adr+i); + clflush(addr+i); } static void flush_kernel_map(void *arg) @@ -76,17 +83,20 @@ static void flush_kernel_map(void *arg) /* When clflush is available always use it because it is much cheaper than WBINVD. */ /* clflush is still broken. Disable for now. */ - if (1 || !cpu_has_clflush) + if (1 || !cpu_has_clflush) { asm volatile("wbinvd" ::: "memory"); - else list_for_each_entry(pg, l, lru) { - void *adr = page_address(pg); - clflush_cache_range(adr, PAGE_SIZE); + } else { + list_for_each_entry(pg, l, lru) { + void *addr = page_address(pg); + + clflush_cache_range(addr, PAGE_SIZE); + } } __flush_tlb_all(); } static inline void flush_map(struct list_head *l) -{ +{ on_each_cpu(flush_kernel_map, l, 1, 1); } @@ -98,52 +108,56 @@ static inline void save_page(struct page *fpage) list_add(&fpage->lru, &deferred_pages); } -/* +/* * No more special protections in this 2/4MB area - revert to a - * large page again. + * large page again. */ static void revert_page(unsigned long address, pgprot_t ref_prot) { + unsigned long pfn; pgd_t *pgd; pud_t *pud; pmd_t *pmd; pte_t large_pte; - unsigned long pfn; pgd = pgd_offset_k(address); BUG_ON(pgd_none(*pgd)); - pud = pud_offset(pgd,address); + pud = pud_offset(pgd, address); BUG_ON(pud_none(*pud)); pmd = pmd_offset(pud, address); BUG_ON(pmd_val(*pmd) & _PAGE_PSE); pfn = (__pa(address) & LARGE_PAGE_MASK) >> PAGE_SHIFT; large_pte = pfn_pte(pfn, ref_prot); large_pte = pte_mkhuge(large_pte); + set_pte((pte_t *)pmd, large_pte); -} +} static int __change_page_attr(unsigned long address, unsigned long pfn, pgprot_t prot, - pgprot_t ref_prot) -{ - pte_t *kpte; + pgprot_t ref_prot) +{ struct page *kpte_page; pgprot_t ref_prot2; + pte_t *kpte; kpte = lookup_address(address); - if (!kpte) return 0; + if (!kpte) + return 0; + kpte_page = virt_to_page(((unsigned long)kpte) & PAGE_MASK); BUG_ON(PageLRU(kpte_page)); BUG_ON(PageCompound(kpte_page)); - if (pgprot_val(prot) != pgprot_val(ref_prot)) { + if (pgprot_val(prot) != pgprot_val(ref_prot)) { if (!pte_huge(*kpte)) { set_pte(kpte, pfn_pte(pfn, prot)); } else { - /* + /* * split_large_page will take the reference for this * change_page_attr on the split page. - */ + */ struct page *split; + ref_prot2 = pte_pgprot(pte_clrhuge(*kpte)); split = split_large_page(address, prot, ref_prot2); if (!split) @@ -153,21 +167,23 @@ __change_page_attr(unsigned long address, unsigned long pfn, pgprot_t prot, kpte_page = split; } page_private(kpte_page)++; - } else if (!pte_huge(*kpte)) { - set_pte(kpte, pfn_pte(pfn, ref_prot)); - BUG_ON(page_private(kpte_page) == 0); - page_private(kpte_page)--; - } else - BUG(); + } else { + if (!pte_huge(*kpte)) { + set_pte(kpte, pfn_pte(pfn, ref_prot)); + BUG_ON(page_private(kpte_page) == 0); + page_private(kpte_page)--; + } else + BUG(); + } /* on x86-64 the direct mapping set at boot is not using 4k pages */ - BUG_ON(PageReserved(kpte_page)); + BUG_ON(PageReserved(kpte_page)); save_page(kpte_page); if (page_private(kpte_page) == 0) revert_page(address, ref_prot); return 0; -} +} /* * Change the page attributes of an page in the linear mapping. @@ -176,19 +192,19 @@ __change_page_attr(unsigned long address, unsigned long pfn, pgprot_t prot, * than write-back somewhere - some CPUs do not like it when mappings with * different caching policies exist. This changes the page attributes of the * in kernel linear mapping too. - * + * * The caller needs to ensure that there are no conflicting mappings elsewhere. * This function only deals with the kernel linear map. - * + * * Caller must call global_flush_tlb() after this. */ int change_page_attr_addr(unsigned long address, int numpages, pgprot_t prot) { - int err = 0, kernel_map = 0; - int i; + int err = 0, kernel_map = 0, i; + + if (address >= __START_KERNEL_map && + address < __START_KERNEL_map + KERNEL_TEXT_SIZE) { - if (address >= __START_KERNEL_map - && address < __START_KERNEL_map + KERNEL_TEXT_SIZE) { address = (unsigned long)__va(__pa(address)); kernel_map = 1; } @@ -198,7 +214,8 @@ int change_page_attr_addr(unsigned long address, int numpages, pgprot_t prot) unsigned long pfn = __pa(address) >> PAGE_SHIFT; if (!kernel_map || pte_present(pfn_pte(0, prot))) { - err = __change_page_attr(address, pfn, prot, PAGE_KERNEL); + err = __change_page_attr(address, pfn, prot, + PAGE_KERNEL); if (err) break; } @@ -207,14 +224,16 @@ int change_page_attr_addr(unsigned long address, int numpages, pgprot_t prot) if (__pa(address) < KERNEL_TEXT_SIZE) { unsigned long addr2; pgprot_t prot2; + addr2 = __START_KERNEL_map + __pa(address); /* Make sure the kernel mappings stay executable */ prot2 = pte_pgprot(pte_mkexec(pfn_pte(0, prot))); err = __change_page_attr(addr2, pfn, prot2, PAGE_KERNEL_EXEC); - } - } - up_write(&init_mm.mmap_sem); + } + } + up_write(&init_mm.mmap_sem); + return err; } @@ -222,11 +241,13 @@ int change_page_attr_addr(unsigned long address, int numpages, pgprot_t prot) int change_page_attr(struct page *page, int numpages, pgprot_t prot) { unsigned long addr = (unsigned long)page_address(page); + return change_page_attr_addr(addr, numpages, prot); } +EXPORT_SYMBOL(change_page_attr); void global_flush_tlb(void) -{ +{ struct page *pg, *next; struct list_head l; @@ -248,8 +269,6 @@ void global_flush_tlb(void) continue; ClearPagePrivate(pg); __free_page(pg); - } -} - -EXPORT_SYMBOL(change_page_attr); + } +} EXPORT_SYMBOL(global_flush_tlb); -- 2.7.4