x86: clean up arch/x86/mm/pageattr_64.c (b4416a1b) · Commits · e / devices / android_kernel_xiaomi_markw

arch/x86/mm/pageattr_64.c

+81 −62

Original line number	Original line	Diff line number	Diff line
	@@ -3,14 +3,15 @@
	* Thanks to Ben LaHaise for precious feedback.		* Thanks to Ben LaHaise for precious feedback.
	*/		*/

	#include <linux/mm.h>
	#include <linux/sched.h>
	#include <linux/highmem.h>		#include <linux/highmem.h>
	#include <linux/module.h>		#include <linux/module.h>
			#include <linux/sched.h>
	#include <linux/slab.h>		#include <linux/slab.h>
	#include <asm/uaccess.h>		#include <linux/mm.h>

	#include <asm/processor.h>		#include <asm/processor.h>
	#include <asm/tlbflush.h>		#include <asm/tlbflush.h>
			#include <asm/uaccess.h>
	#include <asm/io.h>		#include <asm/io.h>

	pte_t *lookup_address(unsigned long address)		pte_t *lookup_address(unsigned long address)
	@@ -19,6 +20,7 @@ pte_t *lookup_address(unsigned long address)
	pud_t *pud;		pud_t *pud;
	pmd_t *pmd;		pmd_t *pmd;
	pte_t *pte;		pte_t *pte;

	if (pgd_none(*pgd))		if (pgd_none(*pgd))
	return NULL;		return NULL;
	pud = pud_offset(pgd, address);		pud = pud_offset(pgd, address);
	@@ -29,19 +31,23 @@ pte_t *lookup_address(unsigned long address)
	return NULL;		return NULL;
	if (pmd_large(*pmd))		if (pmd_large(*pmd))
	return (pte_t *)pmd;		return (pte_t *)pmd;

	pte = pte_offset_kernel(pmd, address);		pte = pte_offset_kernel(pmd, address);
	if (pte && !pte_present(*pte))		if (pte && !pte_present(*pte))
	pte = NULL;		pte = NULL;

	return pte;		return pte;
	}		}

	static struct page *split_large_page(unsigned long address, pgprot_t prot,		static struct page *
	pgprot_t ref_prot)		split_large_page(unsigned long address, pgprot_t prot, pgprot_t ref_prot)
	{		{
	int i;
	unsigned long addr;		unsigned long addr;
	struct page *base = alloc_pages(GFP_KERNEL, 0);		struct page *base;
	pte_t *pbase;		pte_t *pbase;
			int i;

			base = alloc_pages(GFP_KERNEL, 0);
	if (!base)		if (!base)
	return NULL;		return NULL;
	/*		/*
	@@ -61,11 +67,12 @@ static struct page *split_large_page(unsigned long address, pgprot_t prot,
	return base;		return base;
	}		}

	void clflush_cache_range(void *adr, int size)		void clflush_cache_range(void *addr, int size)
	{		{
	int i;		int i;

	for (i = 0; i < size; i += boot_cpu_data.x86_clflush_size)		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)		static void flush_kernel_map(void *arg)
	@@ -76,11 +83,14 @@ static void flush_kernel_map(void *arg)
	/* When clflush is available always use it because it is		/* When clflush is available always use it because it is
	much cheaper than WBINVD. */		much cheaper than WBINVD. */
	/* clflush is still broken. Disable for now. */		/* clflush is still broken. Disable for now. */
	if (1 \|\| !cpu_has_clflush)		if (1 \|\| !cpu_has_clflush) {
	asm volatile("wbinvd" ::: "memory");		asm volatile("wbinvd" ::: "memory");
	else list_for_each_entry(pg, l, lru) {		} else {
	void *adr = page_address(pg);		list_for_each_entry(pg, l, lru) {
	clflush_cache_range(adr, PAGE_SIZE);		void *addr = page_address(pg);

			clflush_cache_range(addr, PAGE_SIZE);
			}
	}		}
	__flush_tlb_all();		__flush_tlb_all();
	}		}
	@@ -104,11 +114,11 @@ static inline void save_page(struct page *fpage)
	*/		*/
	static void revert_page(unsigned long address, pgprot_t ref_prot)		static void revert_page(unsigned long address, pgprot_t ref_prot)
	{		{
			unsigned long pfn;
	pgd_t *pgd;		pgd_t *pgd;
	pud_t *pud;		pud_t *pud;
	pmd_t *pmd;		pmd_t *pmd;
	pte_t large_pte;		pte_t large_pte;
	unsigned long pfn;

	pgd = pgd_offset_k(address);		pgd = pgd_offset_k(address);
	BUG_ON(pgd_none(*pgd));		BUG_ON(pgd_none(*pgd));
	@@ -119,6 +129,7 @@ static void revert_page(unsigned long address, pgprot_t ref_prot)
	pfn = (__pa(address) & LARGE_PAGE_MASK) >> PAGE_SHIFT;		pfn = (__pa(address) & LARGE_PAGE_MASK) >> PAGE_SHIFT;
	large_pte = pfn_pte(pfn, ref_prot);		large_pte = pfn_pte(pfn, ref_prot);
	large_pte = pte_mkhuge(large_pte);		large_pte = pte_mkhuge(large_pte);

	set_pte((pte_t *)pmd, large_pte);		set_pte((pte_t *)pmd, large_pte);
	}		}

	@@ -126,12 +137,14 @@ static int
	__change_page_attr(unsigned long address, unsigned long pfn, pgprot_t prot,		__change_page_attr(unsigned long address, unsigned long pfn, pgprot_t prot,
	pgprot_t ref_prot)		pgprot_t ref_prot)
	{		{
	pte_t *kpte;
	struct page *kpte_page;		struct page *kpte_page;
	pgprot_t ref_prot2;		pgprot_t ref_prot2;
			pte_t *kpte;

	kpte = lookup_address(address);		kpte = lookup_address(address);
	if (!kpte) return 0;		if (!kpte)
			return 0;

	kpte_page = virt_to_page(((unsigned long)kpte) & PAGE_MASK);		kpte_page = virt_to_page(((unsigned long)kpte) & PAGE_MASK);
	BUG_ON(PageLRU(kpte_page));		BUG_ON(PageLRU(kpte_page));
	BUG_ON(PageCompound(kpte_page));		BUG_ON(PageCompound(kpte_page));
	@@ -144,6 +157,7 @@ __change_page_attr(unsigned long address, unsigned long pfn, pgprot_t prot,
	* change_page_attr on the split page.		* change_page_attr on the split page.
	*/		*/
	struct page *split;		struct page *split;

	ref_prot2 = pte_pgprot(pte_clrhuge(*kpte));		ref_prot2 = pte_pgprot(pte_clrhuge(*kpte));
	split = split_large_page(address, prot, ref_prot2);		split = split_large_page(address, prot, ref_prot2);
	if (!split)		if (!split)
	@@ -153,12 +167,14 @@ __change_page_attr(unsigned long address, unsigned long pfn, pgprot_t prot,
	kpte_page = split;		kpte_page = split;
	}		}
	page_private(kpte_page)++;		page_private(kpte_page)++;
	} else if (!pte_huge(*kpte)) {		} else {
			if (!pte_huge(*kpte)) {
	set_pte(kpte, pfn_pte(pfn, ref_prot));		set_pte(kpte, pfn_pte(pfn, ref_prot));
	BUG_ON(page_private(kpte_page) == 0);		BUG_ON(page_private(kpte_page) == 0);
	page_private(kpte_page)--;		page_private(kpte_page)--;
	} else		} else
	BUG();		BUG();
			}

	/* on x86-64 the direct mapping set at boot is not using 4k pages */		/* on x86-64 the direct mapping set at boot is not using 4k pages */
	BUG_ON(PageReserved(kpte_page));		BUG_ON(PageReserved(kpte_page));
	@@ -184,11 +200,11 @@ __change_page_attr(unsigned long address, unsigned long pfn, pgprot_t prot,
	*/		*/
	int change_page_attr_addr(unsigned long address, int numpages, pgprot_t prot)		int change_page_attr_addr(unsigned long address, int numpages, pgprot_t prot)
	{		{
	int err = 0, kernel_map = 0;		int err = 0, kernel_map = 0, i;
	int 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));		address = (unsigned long)__va(__pa(address));
	kernel_map = 1;		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;		unsigned long pfn = __pa(address) >> PAGE_SHIFT;

	if (!kernel_map \|\| pte_present(pfn_pte(0, prot))) {		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)		if (err)
	break;		break;
	}		}
	@@ -207,6 +224,7 @@ int change_page_attr_addr(unsigned long address, int numpages, pgprot_t prot)
	if (__pa(address) < KERNEL_TEXT_SIZE) {		if (__pa(address) < KERNEL_TEXT_SIZE) {
	unsigned long addr2;		unsigned long addr2;
	pgprot_t prot2;		pgprot_t prot2;

	addr2 = __START_KERNEL_map + __pa(address);		addr2 = __START_KERNEL_map + __pa(address);
	/* Make sure the kernel mappings stay executable */		/* Make sure the kernel mappings stay executable */
	prot2 = pte_pgprot(pte_mkexec(pfn_pte(0, prot)));		prot2 = pte_pgprot(pte_mkexec(pfn_pte(0, prot)));
	@@ -215,6 +233,7 @@ int change_page_attr_addr(unsigned long address, int numpages, pgprot_t prot)
	}		}
	}		}
	up_write(&init_mm.mmap_sem);		up_write(&init_mm.mmap_sem);

	return err;		return err;
	}		}

	@@ -222,8 +241,10 @@ 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)		int change_page_attr(struct page *page, int numpages, pgprot_t prot)
	{		{
	unsigned long addr = (unsigned long)page_address(page);		unsigned long addr = (unsigned long)page_address(page);

	return change_page_attr_addr(addr, numpages, prot);		return change_page_attr_addr(addr, numpages, prot);
	}		}
			EXPORT_SYMBOL(change_page_attr);

	void global_flush_tlb(void)		void global_flush_tlb(void)
	{		{
	@@ -250,6 +271,4 @@ void global_flush_tlb(void)
	__free_page(pg);		__free_page(pg);
	}		}
	}		}

	EXPORT_SYMBOL(change_page_attr);
	EXPORT_SYMBOL(global_flush_tlb);		EXPORT_SYMBOL(global_flush_tlb);