[linux-2.6-block.git] / arch / powerpc / mm / pgtable-book3s64.c

/*
 * Copyright 2015-2016, Aneesh Kumar K.V, IBM Corporation.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/sched.h>
#include <asm/pgalloc.h>
#include <asm/tlb.h>

#include "mmu_decl.h"
#include <trace/events/thp.h>

int (*register_process_table)(unsigned long base, unsigned long page_size,
			      unsigned long tbl_size);

#ifdef CONFIG_TRANSPARENT_HUGEPAGE
/*
 * This is called when relaxing access to a hugepage. It's also called in the page
 * fault path when we don't hit any of the major fault cases, ie, a minor
 * update of _PAGE_ACCESSED, _PAGE_DIRTY, etc... The generic code will have
 * handled those two for us, we additionally deal with missing execute
 * permission here on some processors
 */
int pmdp_set_access_flags(struct vm_area_struct *vma, unsigned long address,
			  pmd_t *pmdp, pmd_t entry, int dirty)
{
	int changed;
#ifdef CONFIG_DEBUG_VM
	WARN_ON(!pmd_trans_huge(*pmdp));
	assert_spin_locked(&vma->vm_mm->page_table_lock);
#endif
	changed = !pmd_same(*(pmdp), entry);
	if (changed) {
		__ptep_set_access_flags(vma->vm_mm, pmdp_ptep(pmdp),
					pmd_pte(entry), address);
		flush_pmd_tlb_range(vma, address, address + HPAGE_PMD_SIZE);
	}
	return changed;
}

int pmdp_test_and_clear_young(struct vm_area_struct *vma,
			      unsigned long address, pmd_t *pmdp)
{
	return __pmdp_test_and_clear_young(vma->vm_mm, address, pmdp);
}
/*
 * set a new huge pmd. We should not be called for updating
 * an existing pmd entry. That should go via pmd_hugepage_update.
 */
void set_pmd_at(struct mm_struct *mm, unsigned long addr,
		pmd_t *pmdp, pmd_t pmd)
{
#ifdef CONFIG_DEBUG_VM
	WARN_ON(pte_present(pmd_pte(*pmdp)) && !pte_protnone(pmd_pte(*pmdp)));
	assert_spin_locked(&mm->page_table_lock);
	WARN_ON(!pmd_trans_huge(pmd));
#endif
	trace_hugepage_set_pmd(addr, pmd_val(pmd));
	return set_pte_at(mm, addr, pmdp_ptep(pmdp), pmd_pte(pmd));
}
/*
 * We use this to invalidate a pmdp entry before switching from a
 * hugepte to regular pmd entry.
 */
void pmdp_invalidate(struct vm_area_struct *vma, unsigned long address,
		     pmd_t *pmdp)
{
	pmd_hugepage_update(vma->vm_mm, address, pmdp, _PAGE_PRESENT, 0);
	flush_pmd_tlb_range(vma, address, address + HPAGE_PMD_SIZE);
	/*
	 * This ensures that generic code that rely on IRQ disabling
	 * to prevent a parallel THP split work as expected.
	 */
	kick_all_cpus_sync();
}

static pmd_t pmd_set_protbits(pmd_t pmd, pgprot_t pgprot)
{
	return __pmd(pmd_val(pmd) | pgprot_val(pgprot));
}

pmd_t pfn_pmd(unsigned long pfn, pgprot_t pgprot)
{
	unsigned long pmdv;

	pmdv = (pfn << PAGE_SHIFT) & PTE_RPN_MASK;
	return pmd_set_protbits(__pmd(pmdv), pgprot);
}

pmd_t mk_pmd(struct page *page, pgprot_t pgprot)
{
	return pfn_pmd(page_to_pfn(page), pgprot);
}

pmd_t pmd_modify(pmd_t pmd, pgprot_t newprot)
{
	unsigned long pmdv;

	pmdv = pmd_val(pmd);
	pmdv &= _HPAGE_CHG_MASK;
	return pmd_set_protbits(__pmd(pmdv), newprot);
}

/*
 * This is called at the end of handling a user page fault, when the
 * fault has been handled by updating a HUGE PMD entry in the linux page tables.
 * We use it to preload an HPTE into the hash table corresponding to
 * the updated linux HUGE PMD entry.
 */
void update_mmu_cache_pmd(struct vm_area_struct *vma, unsigned long addr,
			  pmd_t *pmd)
{
	return;
}
#endif /* CONFIG_TRANSPARENT_HUGEPAGE */

/* For use by kexec */
void mmu_cleanup_all(void)
{
	if (radix_enabled())
		radix__mmu_cleanup_all();
	else if (mmu_hash_ops.hpte_clear_all)
		mmu_hash_ops.hpte_clear_all();
}

#ifdef CONFIG_MEMORY_HOTPLUG
int create_section_mapping(unsigned long start, unsigned long end)
{
	if (radix_enabled())
		return radix__create_section_mapping(start, end);

	return hash__create_section_mapping(start, end);
}

int remove_section_mapping(unsigned long start, unsigned long end)
{
	if (radix_enabled())
		return -ENODEV;

	return hash__remove_section_mapping(start, end);
}
#endif /* CONFIG_MEMORY_HOTPLUG */
Commit	Line	Data
3df33f12 AK	1	/*
	2	* Copyright 2015-2016, Aneesh Kumar K.V, IBM Corporation.
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; either version
	7	* 2 of the License, or (at your option) any later version.
	8	*/
	9
	10	#include <linux/sched.h>
	11	#include <asm/pgalloc.h>
	12	#include <asm/tlb.h>
	13
	14	#include "mmu_decl.h"
	15	#include <trace/events/thp.h>
	16
eea8148c ME	17	int (*register_process_table)(unsigned long base, unsigned long page_size,
	18	unsigned long tbl_size);
	19
3df33f12 AK	20	#ifdef CONFIG_TRANSPARENT_HUGEPAGE
	21	/*
	22	* This is called when relaxing access to a hugepage. It's also called in the page
	23	* fault path when we don't hit any of the major fault cases, ie, a minor
	24	* update of _PAGE_ACCESSED, _PAGE_DIRTY, etc... The generic code will have
	25	* handled those two for us, we additionally deal with missing execute
	26	* permission here on some processors
	27	*/
	28	int pmdp_set_access_flags(struct vm_area_struct *vma, unsigned long address,
	29	pmd_t *pmdp, pmd_t entry, int dirty)
	30	{
	31	int changed;
	32	#ifdef CONFIG_DEBUG_VM
	33	WARN_ON(!pmd_trans_huge(*pmdp));
	34	assert_spin_locked(&vma->vm_mm->page_table_lock);
	35	#endif
	36	changed = !pmd_same(*(pmdp), entry);
	37	if (changed) {
b3603e17 AK	38	__ptep_set_access_flags(vma->vm_mm, pmdp_ptep(pmdp),
b3603e17 AK	39	pmd_pte(entry), address);
d8e91e93	40	flush_pmd_tlb_range(vma, address, address + HPAGE_PMD_SIZE);
3df33f12 AK	41	}
	42	return changed;
	43	}
	44
	45	int pmdp_test_and_clear_young(struct vm_area_struct *vma,
	46	unsigned long address, pmd_t *pmdp)
	47	{
	48	return __pmdp_test_and_clear_young(vma->vm_mm, address, pmdp);
	49	}
	50	/*
	51	* set a new huge pmd. We should not be called for updating
	52	* an existing pmd entry. That should go via pmd_hugepage_update.
	53	*/
	54	void set_pmd_at(struct mm_struct *mm, unsigned long addr,
	55	pmd_t *pmdp, pmd_t pmd)
	56	{
	57	#ifdef CONFIG_DEBUG_VM
	58	WARN_ON(pte_present(pmd_pte(pmdp)) && !pte_protnone(pmd_pte(pmdp)));
	59	assert_spin_locked(&mm->page_table_lock);
	60	WARN_ON(!pmd_trans_huge(pmd));
	61	#endif
	62	trace_hugepage_set_pmd(addr, pmd_val(pmd));
	63	return set_pte_at(mm, addr, pmdp_ptep(pmdp), pmd_pte(pmd));
	64	}
	65	/*
	66	* We use this to invalidate a pmdp entry before switching from a
	67	* hugepte to regular pmd entry.
	68	*/
	69	void pmdp_invalidate(struct vm_area_struct *vma, unsigned long address,
	70	pmd_t *pmdp)
	71	{
	72	pmd_hugepage_update(vma->vm_mm, address, pmdp, _PAGE_PRESENT, 0);
d8e91e93	73	flush_pmd_tlb_range(vma, address, address + HPAGE_PMD_SIZE);
3df33f12 AK	74	/*
	75	* This ensures that generic code that rely on IRQ disabling
	76	* to prevent a parallel THP split work as expected.
	77	*/
	78	kick_all_cpus_sync();
	79	}
	80
	81	static pmd_t pmd_set_protbits(pmd_t pmd, pgprot_t pgprot)
	82	{
	83	return __pmd(pmd_val(pmd) \| pgprot_val(pgprot));
	84	}
	85
	86	pmd_t pfn_pmd(unsigned long pfn, pgprot_t pgprot)
	87	{
	88	unsigned long pmdv;
	89
	90	pmdv = (pfn << PAGE_SHIFT) & PTE_RPN_MASK;
	91	return pmd_set_protbits(__pmd(pmdv), pgprot);
	92	}
	93
	94	pmd_t mk_pmd(struct page *page, pgprot_t pgprot)
	95	{
	96	return pfn_pmd(page_to_pfn(page), pgprot);
	97	}
	98
	99	pmd_t pmd_modify(pmd_t pmd, pgprot_t newprot)
	100	{
	101	unsigned long pmdv;
	102
	103	pmdv = pmd_val(pmd);
	104	pmdv &= _HPAGE_CHG_MASK;
	105	return pmd_set_protbits(__pmd(pmdv), newprot);
	106	}
	107
	108	/*
	109	* This is called at the end of handling a user page fault, when the
	110	* fault has been handled by updating a HUGE PMD entry in the linux page tables.
	111	* We use it to preload an HPTE into the hash table corresponding to
	112	* the updated linux HUGE PMD entry.
	113	*/
	114	void update_mmu_cache_pmd(struct vm_area_struct *vma, unsigned long addr,
	115	pmd_t *pmd)
	116	{
	117	return;
	118	}
	119	#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
fe036a06 BH	120
	121	/* For use by kexec */
	122	void mmu_cleanup_all(void)
	123	{
	124	if (radix_enabled())
	125	radix__mmu_cleanup_all();
	126	else if (mmu_hash_ops.hpte_clear_all)
	127	mmu_hash_ops.hpte_clear_all();
	128	}
32b53c01 RA	129
	130	#ifdef CONFIG_MEMORY_HOTPLUG
	131	int create_section_mapping(unsigned long start, unsigned long end)
	132	{
	133	if (radix_enabled())
6cc27341	134	return radix__create_section_mapping(start, end);
32b53c01 RA	135
	136	return hash__create_section_mapping(start, end);
	137	}
	138
	139	int remove_section_mapping(unsigned long start, unsigned long end)
	140	{
	141	if (radix_enabled())
	142	return -ENODEV;
	143
	144	return hash__remove_section_mapping(start, end);
	145	}
	146	#endif /* CONFIG_MEMORY_HOTPLUG */