[deliverable/linux.git] / arch / powerpc / include / asm / hugetlb.h

#ifndef _ASM_POWERPC_HUGETLB_H
#define _ASM_POWERPC_HUGETLB_H

#ifdef CONFIG_HUGETLB_PAGE
#include <asm/page.h>

extern struct kmem_cache *hugepte_cache;
extern void __init reserve_hugetlb_gpages(void);

static inline pte_t *hugepd_page(hugepd_t hpd)
{
	BUG_ON(!hugepd_ok(hpd));
	return (pte_t *)((hpd.pd & ~HUGEPD_SHIFT_MASK) | PD_HUGE);
}

static inline unsigned int hugepd_shift(hugepd_t hpd)
{
	return hpd.pd & HUGEPD_SHIFT_MASK;
}

static inline pte_t *hugepte_offset(hugepd_t *hpdp, unsigned long addr,
				    unsigned pdshift)
{
	/*
	 * On 32-bit, we have multiple higher-level table entries that point to
	 * the same hugepte.  Just use the first one since they're all
	 * identical.  So for that case, idx=0.
	 */
	unsigned long idx = 0;

	pte_t *dir = hugepd_page(*hpdp);
#ifdef CONFIG_PPC64
	idx = (addr & ((1UL << pdshift) - 1)) >> hugepd_shift(*hpdp);
#endif

	return dir + idx;
}

pte_t *huge_pte_offset_and_shift(struct mm_struct *mm,
				 unsigned long addr, unsigned *shift);

void flush_dcache_icache_hugepage(struct page *page);

#if defined(CONFIG_PPC_MM_SLICES) || defined(CONFIG_PPC_SUBPAGE_PROT)
int is_hugepage_only_range(struct mm_struct *mm, unsigned long addr,
			   unsigned long len);
#else
static inline int is_hugepage_only_range(struct mm_struct *mm,
					 unsigned long addr,
					 unsigned long len)
{
	return 0;
}
#endif

void book3e_hugetlb_preload(struct mm_struct *mm, unsigned long ea, pte_t pte);
void flush_hugetlb_page(struct vm_area_struct *vma, unsigned long vmaddr);

void hugetlb_free_pgd_range(struct mmu_gather *tlb, unsigned long addr,
			    unsigned long end, unsigned long floor,
			    unsigned long ceiling);

/*
 * The version of vma_mmu_pagesize() in arch/powerpc/mm/hugetlbpage.c needs
 * to override the version in mm/hugetlb.c
 */
#define vma_mmu_pagesize vma_mmu_pagesize

/*
 * If the arch doesn't supply something else, assume that hugepage
 * size aligned regions are ok without further preparation.
 */
static inline int prepare_hugepage_range(struct file *file,
			unsigned long addr, unsigned long len)
{
	struct hstate *h = hstate_file(file);
	if (len & ~huge_page_mask(h))
		return -EINVAL;
	if (addr & ~huge_page_mask(h))
		return -EINVAL;
	return 0;
}

static inline void hugetlb_prefault_arch_hook(struct mm_struct *mm)
{
}


static inline void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
				   pte_t *ptep, pte_t pte)
{
	set_pte_at(mm, addr, ptep, pte);
}

static inline pte_t huge_ptep_get_and_clear(struct mm_struct *mm,
					    unsigned long addr, pte_t *ptep)
{
#ifdef CONFIG_PPC64
	return __pte(pte_update(mm, addr, ptep, ~0UL, 1));
#else
	return __pte(pte_update(ptep, ~0UL, 0));
#endif
}

static inline void huge_ptep_clear_flush(struct vm_area_struct *vma,
					 unsigned long addr, pte_t *ptep)
{
	pte_t pte;
	pte = huge_ptep_get_and_clear(vma->vm_mm, addr, ptep);
	flush_tlb_page(vma, addr);
}

static inline int huge_pte_none(pte_t pte)
{
	return pte_none(pte);
}

static inline pte_t huge_pte_wrprotect(pte_t pte)
{
	return pte_wrprotect(pte);
}

static inline int huge_ptep_set_access_flags(struct vm_area_struct *vma,
					     unsigned long addr, pte_t *ptep,
					     pte_t pte, int dirty)
{
	return ptep_set_access_flags(vma, addr, ptep, pte, dirty);
}

static inline pte_t huge_ptep_get(pte_t *ptep)
{
	return *ptep;
}

static inline int arch_prepare_hugepage(struct page *page)
{
	return 0;
}

static inline void arch_release_hugepage(struct page *page)
{
}

#else /* ! CONFIG_HUGETLB_PAGE */
static inline void reserve_hugetlb_gpages(void)
{
	pr_err("Cannot reserve gpages without hugetlb enabled\n");
}
static inline void flush_hugetlb_page(struct vm_area_struct *vma,
				      unsigned long vmaddr)
{
}
#endif

#endif /* _ASM_POWERPC_HUGETLB_H */
Commit	Line	Data
6d779079 GS	1	#ifndef _ASM_POWERPC_HUGETLB_H
	2	#define _ASM_POWERPC_HUGETLB_H
	3
41151e77	4	#ifdef CONFIG_HUGETLB_PAGE
6d779079 GS	5	#include <asm/page.h>
6d779079 GS	6
41151e77 BB	7	extern struct kmem_cache *hugepte_cache;
	8	extern void __init reserve_hugetlb_gpages(void);
	9
	10	static inline pte_t *hugepd_page(hugepd_t hpd)
	11	{
	12	BUG_ON(!hugepd_ok(hpd));
	13	return (pte_t *)((hpd.pd & ~HUGEPD_SHIFT_MASK) \| PD_HUGE);
	14	}
	15
	16	static inline unsigned int hugepd_shift(hugepd_t hpd)
	17	{
	18	return hpd.pd & HUGEPD_SHIFT_MASK;
	19	}
	20
	21	static inline pte_t hugepte_offset(hugepd_t hpdp, unsigned long addr,
	22	unsigned pdshift)
	23	{
	24	/*
	25	* On 32-bit, we have multiple higher-level table entries that point to
	26	* the same hugepte. Just use the first one since they're all
	27	* identical. So for that case, idx=0.
	28	*/
	29	unsigned long idx = 0;
	30
	31	pte_t dir = hugepd_page(hpdp);
	32	#ifdef CONFIG_PPC64
	33	idx = (addr & ((1UL << pdshift) - 1)) >> hugepd_shift(*hpdp);
	34	#endif
	35
	36	return dir + idx;
	37	}
	38
883a3e52 DG	39	pte_t huge_pte_offset_and_shift(struct mm_struct mm,
	40	unsigned long addr, unsigned *shift);
	41
0895ecda DG	42	void flush_dcache_icache_hugepage(struct page *page);
0895ecda DG	43
41151e77	44	#if defined(CONFIG_PPC_MM_SLICES) \|\| defined(CONFIG_PPC_SUBPAGE_PROT)
6d779079 GS	45	int is_hugepage_only_range(struct mm_struct *mm, unsigned long addr,
6d779079 GS	46	unsigned long len);
41151e77 BB	47	#else
	48	static inline int is_hugepage_only_range(struct mm_struct *mm,
	49	unsigned long addr,
	50	unsigned long len)
	51	{
	52	return 0;
	53	}
	54	#endif
	55
	56	void book3e_hugetlb_preload(struct mm_struct *mm, unsigned long ea, pte_t pte);
	57	void flush_hugetlb_page(struct vm_area_struct *vma, unsigned long vmaddr);
6d779079	58
42b77728	59	void hugetlb_free_pgd_range(struct mmu_gather *tlb, unsigned long addr,
6d779079 GS	60	unsigned long end, unsigned long floor,
	61	unsigned long ceiling);
	62
3340289d MG	63	/*
	64	* The version of vma_mmu_pagesize() in arch/powerpc/mm/hugetlbpage.c needs
	65	* to override the version in mm/hugetlb.c
	66	*/
	67	#define vma_mmu_pagesize vma_mmu_pagesize
	68
6d779079 GS	69	/*
	70	* If the arch doesn't supply something else, assume that hugepage
	71	* size aligned regions are ok without further preparation.
	72	*/
a5516438 AK	73	static inline int prepare_hugepage_range(struct file *file,
a5516438 AK	74	unsigned long addr, unsigned long len)
6d779079	75	{
0d9ea754 JT	76	struct hstate *h = hstate_file(file);
0d9ea754 JT	77	if (len & ~huge_page_mask(h))
6d779079	78	return -EINVAL;
0d9ea754	79	if (addr & ~huge_page_mask(h))
6d779079 GS	80	return -EINVAL;
	81	return 0;
	82	}
	83
	84	static inline void hugetlb_prefault_arch_hook(struct mm_struct *mm)
	85	{
	86	}
	87
0895ecda DG	88
	89	static inline void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
	90	pte_t *ptep, pte_t pte)
	91	{
	92	set_pte_at(mm, addr, ptep, pte);
	93	}
	94
	95	static inline pte_t huge_ptep_get_and_clear(struct mm_struct *mm,
	96	unsigned long addr, pte_t *ptep)
	97	{
41151e77 BB	98	#ifdef CONFIG_PPC64
	99	return __pte(pte_update(mm, addr, ptep, ~0UL, 1));
	100	#else
	101	return __pte(pte_update(ptep, ~0UL, 0));
	102	#endif
0895ecda DG	103	}
0895ecda DG	104
8fe627ec GS	105	static inline void huge_ptep_clear_flush(struct vm_area_struct *vma,
	106	unsigned long addr, pte_t *ptep)
	107	{
0895ecda DG	108	pte_t pte;
	109	pte = huge_ptep_get_and_clear(vma->vm_mm, addr, ptep);
	110	flush_tlb_page(vma, addr);
8fe627ec GS	111	}
8fe627ec GS	112
7f2e9525 GS	113	static inline int huge_pte_none(pte_t pte)
	114	{
	115	return pte_none(pte);
	116	}
	117
	118	static inline pte_t huge_pte_wrprotect(pte_t pte)
	119	{
	120	return pte_wrprotect(pte);
	121	}
	122
7f2e9525 GS	123	static inline int huge_ptep_set_access_flags(struct vm_area_struct *vma,
	124	unsigned long addr, pte_t *ptep,
	125	pte_t pte, int dirty)
	126	{
	127	return ptep_set_access_flags(vma, addr, ptep, pte, dirty);
	128	}
	129
	130	static inline pte_t huge_ptep_get(pte_t *ptep)
	131	{
	132	return *ptep;
	133	}
	134
	135	static inline int arch_prepare_hugepage(struct page *page)
	136	{
	137	return 0;
	138	}
	139
	140	static inline void arch_release_hugepage(struct page *page)
	141	{
	142	}
	143
41151e77 BB	144	#else /* ! CONFIG_HUGETLB_PAGE */
	145	static inline void reserve_hugetlb_gpages(void)
	146	{
	147	pr_err("Cannot reserve gpages without hugetlb enabled\n");
	148	}
	149	static inline void flush_hugetlb_page(struct vm_area_struct *vma,
	150	unsigned long vmaddr)
	151	{
	152	}
	153	#endif
	154
6d779079	155	#endif /* _ASM_POWERPC_HUGETLB_H */