[linux-2.6-block.git] / arch / powerpc / include / asm / book3s / 32 / pgalloc.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _ASM_POWERPC_BOOK3S_32_PGALLOC_H
#define _ASM_POWERPC_BOOK3S_32_PGALLOC_H

#include <linux/threads.h>
#include <linux/slab.h>

/*
 * Functions that deal with pagetables that could be at any level of
 * the table need to be passed an "index_size" so they know how to
 * handle allocation.  For PTE pages (which are linked to a struct
 * page for now, and drawn from the main get_free_pages() pool), the
 * allocation size will be (2^index_size * sizeof(pointer)) and
 * allocations are drawn from the kmem_cache in PGT_CACHE(index_size).
 *
 * The maximum index size needs to be big enough to allow any
 * pagetable sizes we need, but small enough to fit in the low bits of
 * any page table pointer.  In other words all pagetables, even tiny
 * ones, must be aligned to allow at least enough low 0 bits to
 * contain this value.  This value is also used as a mask, so it must
 * be one less than a power of two.
 */
#define MAX_PGTABLE_INDEX_SIZE	0xf

extern void __bad_pte(pmd_t *pmd);

extern struct kmem_cache *pgtable_cache[];
#define PGT_CACHE(shift) ({				\
			BUG_ON(!(shift));		\
			pgtable_cache[(shift) - 1];	\
		})

static inline pgd_t *pgd_alloc(struct mm_struct *mm)
{
	return kmem_cache_alloc(PGT_CACHE(PGD_INDEX_SIZE),
			pgtable_gfp_flags(mm, GFP_KERNEL));
}

static inline void pgd_free(struct mm_struct *mm, pgd_t *pgd)
{
	kmem_cache_free(PGT_CACHE(PGD_INDEX_SIZE), pgd);
}

/*
 * We don't have any real pmd's, and this code never triggers because
 * the pgd will always be present..
 */
/* #define pmd_alloc_one(mm,address)       ({ BUG(); ((pmd_t *)2); }) */
#define pmd_free(mm, x) 		do { } while (0)
#define __pmd_free_tlb(tlb,x,a)		do { } while (0)
/* #define pgd_populate(mm, pmd, pte)      BUG() */

#ifndef CONFIG_BOOKE

static inline void pmd_populate_kernel(struct mm_struct *mm, pmd_t *pmdp,
				       pte_t *pte)
{
	*pmdp = __pmd(__pa(pte) | _PMD_PRESENT);
}

static inline void pmd_populate(struct mm_struct *mm, pmd_t *pmdp,
				pgtable_t pte_page)
{
	*pmdp = __pmd((page_to_pfn(pte_page) << PAGE_SHIFT) | _PMD_PRESENT);
}

#define pmd_pgtable(pmd) pmd_page(pmd)
#else

static inline void pmd_populate_kernel(struct mm_struct *mm, pmd_t *pmdp,
				       pte_t *pte)
{
	*pmdp = __pmd((unsigned long)pte | _PMD_PRESENT);
}

static inline void pmd_populate(struct mm_struct *mm, pmd_t *pmdp,
				pgtable_t pte_page)
{
	*pmdp = __pmd((unsigned long)lowmem_page_address(pte_page) | _PMD_PRESENT);
}

#define pmd_pgtable(pmd) pmd_page(pmd)
#endif

extern pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long addr);
extern pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long addr);

static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
{
	free_page((unsigned long)pte);
}

static inline void pte_free(struct mm_struct *mm, pgtable_t ptepage)
{
	pgtable_page_dtor(ptepage);
	__free_page(ptepage);
}

static inline void pgtable_free(void *table, unsigned index_size)
{
	if (!index_size) {
		pgtable_page_dtor(virt_to_page(table));
		free_page((unsigned long)table);
	} else {
		BUG_ON(index_size > MAX_PGTABLE_INDEX_SIZE);
		kmem_cache_free(PGT_CACHE(index_size), table);
	}
}

#define check_pgt_cache()	do { } while (0)
#define get_hugepd_cache_index(x)  (x)

#ifdef CONFIG_SMP
static inline void pgtable_free_tlb(struct mmu_gather *tlb,
				    void *table, int shift)
{
	unsigned long pgf = (unsigned long)table;
	BUG_ON(shift > MAX_PGTABLE_INDEX_SIZE);
	pgf |= shift;
	tlb_remove_table(tlb, (void *)pgf);
}

static inline void __tlb_remove_table(void *_table)
{
	void *table = (void *)((unsigned long)_table & ~MAX_PGTABLE_INDEX_SIZE);
	unsigned shift = (unsigned long)_table & MAX_PGTABLE_INDEX_SIZE;

	pgtable_free(table, shift);
}
#else
static inline void pgtable_free_tlb(struct mmu_gather *tlb,
				    void *table, int shift)
{
	pgtable_free(table, shift);
}
#endif

static inline void __pte_free_tlb(struct mmu_gather *tlb, pgtable_t table,
				  unsigned long address)
{
	pgtable_page_dtor(table);
	pgtable_free_tlb(tlb, page_address(table), 0);
}
#endif /* _ASM_POWERPC_BOOK3S_32_PGALLOC_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
75a9b8a6 AK	2	#ifndef _ASM_POWERPC_BOOK3S_32_PGALLOC_H
75a9b8a6 AK	3	#define _ASM_POWERPC_BOOK3S_32_PGALLOC_H
101ad5c6 AK	4
101ad5c6 AK	5	#include <linux/threads.h>
9b081e10	6	#include <linux/slab.h>
101ad5c6	7
9b081e10 CL	8	/*
	9	* Functions that deal with pagetables that could be at any level of
	10	* the table need to be passed an "index_size" so they know how to
	11	* handle allocation. For PTE pages (which are linked to a struct
	12	* page for now, and drawn from the main get_free_pages() pool), the
	13	* allocation size will be (2^index_size * sizeof(pointer)) and
	14	* allocations are drawn from the kmem_cache in PGT_CACHE(index_size).
	15	*
	16	* The maximum index size needs to be big enough to allow any
	17	* pagetable sizes we need, but small enough to fit in the low bits of
	18	* any page table pointer. In other words all pagetables, even tiny
	19	* ones, must be aligned to allow at least enough low 0 bits to
	20	* contain this value. This value is also used as a mask, so it must
	21	* be one less than a power of two.
	22	*/
	23	#define MAX_PGTABLE_INDEX_SIZE 0xf
101ad5c6 AK	24
	25	extern void __bad_pte(pmd_t *pmd);
	26
9b081e10 CL	27	extern struct kmem_cache *pgtable_cache[];
	28	#define PGT_CACHE(shift) ({ \
	29	BUG_ON(!(shift)); \
	30	pgtable_cache[(shift) - 1]; \
	31	})
	32
	33	static inline pgd_t pgd_alloc(struct mm_struct mm)
	34	{
de3b8761 BS	35	return kmem_cache_alloc(PGT_CACHE(PGD_INDEX_SIZE),
de3b8761 BS	36	pgtable_gfp_flags(mm, GFP_KERNEL));
9b081e10 CL	37	}
	38
	39	static inline void pgd_free(struct mm_struct mm, pgd_t pgd)
	40	{
	41	kmem_cache_free(PGT_CACHE(PGD_INDEX_SIZE), pgd);
	42	}
101ad5c6 AK	43
	44	/*
	45	* We don't have any real pmd's, and this code never triggers because
	46	* the pgd will always be present..
	47	*/
	48	/* #define pmd_alloc_one(mm,address) ({ BUG(); ((pmd_t )2); }) /
	49	#define pmd_free(mm, x) do { } while (0)
	50	#define __pmd_free_tlb(tlb,x,a) do { } while (0)
	51	/* #define pgd_populate(mm, pmd, pte) BUG() */
	52
	53	#ifndef CONFIG_BOOKE
	54
	55	static inline void pmd_populate_kernel(struct mm_struct mm, pmd_t pmdp,
	56	pte_t *pte)
	57	{
	58	*pmdp = __pmd(__pa(pte) \| _PMD_PRESENT);
	59	}
	60
	61	static inline void pmd_populate(struct mm_struct mm, pmd_t pmdp,
	62	pgtable_t pte_page)
	63	{
	64	*pmdp = __pmd((page_to_pfn(pte_page) << PAGE_SHIFT) \| _PMD_PRESENT);
	65	}
	66
	67	#define pmd_pgtable(pmd) pmd_page(pmd)
	68	#else
	69
	70	static inline void pmd_populate_kernel(struct mm_struct mm, pmd_t pmdp,
	71	pte_t *pte)
	72	{
	73	*pmdp = __pmd((unsigned long)pte \| _PMD_PRESENT);
	74	}
	75
	76	static inline void pmd_populate(struct mm_struct mm, pmd_t pmdp,
	77	pgtable_t pte_page)
	78	{
	79	*pmdp = __pmd((unsigned long)lowmem_page_address(pte_page) \| _PMD_PRESENT);
	80	}
	81
	82	#define pmd_pgtable(pmd) pmd_page(pmd)
	83	#endif
	84
	85	extern pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long addr);
	86	extern pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long addr);
	87
	88	static inline void pte_free_kernel(struct mm_struct mm, pte_t pte)
	89	{
	90	free_page((unsigned long)pte);
	91	}
	92
	93	static inline void pte_free(struct mm_struct *mm, pgtable_t ptepage)
	94	{
	95	pgtable_page_dtor(ptepage);
	96	__free_page(ptepage);
	97	}
	98
	99	static inline void pgtable_free(void *table, unsigned index_size)
	100	{
9b081e10	101	if (!index_size) {
667416f3	102	pgtable_page_dtor(virt_to_page(table));
9b081e10 CL	103	free_page((unsigned long)table);
	104	} else {
	105	BUG_ON(index_size > MAX_PGTABLE_INDEX_SIZE);
	106	kmem_cache_free(PGT_CACHE(index_size), table);
	107	}
101ad5c6 AK	108	}
	109
	110	#define check_pgt_cache() do { } while (0)
fadd03c6	111	#define get_hugepd_cache_index(x) (x)
101ad5c6 AK	112
	113	#ifdef CONFIG_SMP
	114	static inline void pgtable_free_tlb(struct mmu_gather *tlb,
	115	void *table, int shift)
	116	{
	117	unsigned long pgf = (unsigned long)table;
	118	BUG_ON(shift > MAX_PGTABLE_INDEX_SIZE);
	119	pgf \|= shift;
	120	tlb_remove_table(tlb, (void *)pgf);
	121	}
	122
	123	static inline void __tlb_remove_table(void *_table)
	124	{
	125	void table = (void )((unsigned long)_table & ~MAX_PGTABLE_INDEX_SIZE);
	126	unsigned shift = (unsigned long)_table & MAX_PGTABLE_INDEX_SIZE;
	127
	128	pgtable_free(table, shift);
	129	}
	130	#else
	131	static inline void pgtable_free_tlb(struct mmu_gather *tlb,
	132	void *table, int shift)
	133	{
	134	pgtable_free(table, shift);
	135	}
	136	#endif
	137
	138	static inline void __pte_free_tlb(struct mmu_gather *tlb, pgtable_t table,
	139	unsigned long address)
	140	{
101ad5c6 AK	141	pgtable_page_dtor(table);
	142	pgtable_free_tlb(tlb, page_address(table), 0);
	143	}
75a9b8a6	144	#endif /* _ASM_POWERPC_BOOK3S_32_PGALLOC_H */