[mirror_ubuntu-artful-kernel.git] / arch / s390 / include / asm / pgalloc.h

/*
 *  S390 version
 *    Copyright IBM Corp. 1999, 2000
 *    Author(s): Hartmut Penner (hp@de.ibm.com)
 *               Martin Schwidefsky (schwidefsky@de.ibm.com)
 *
 *  Derived from "include/asm-i386/pgalloc.h"
 *    Copyright (C) 1994  Linus Torvalds
 */

#ifndef _S390_PGALLOC_H
#define _S390_PGALLOC_H

#include <linux/threads.h>
#include <linux/gfp.h>
#include <linux/mm.h>

unsigned long *crst_table_alloc(struct mm_struct *);
void crst_table_free(struct mm_struct *, unsigned long *);

unsigned long *page_table_alloc(struct mm_struct *);
struct page *page_table_alloc_pgste(struct mm_struct *mm);
void page_table_free(struct mm_struct *, unsigned long *);
void page_table_free_rcu(struct mmu_gather *, unsigned long *, unsigned long);
void page_table_free_pgste(struct page *page);
extern int page_table_allocate_pgste;

static inline void clear_table(unsigned long *s, unsigned long val, size_t n)
{
	struct addrtype { char _[256]; };
	int i;

	for (i = 0; i < n; i += 256) {
		*s = val;
		asm volatile(
			"mvc	8(248,%[s]),0(%[s])\n"
			: "+m" (*(struct addrtype *) s)
			: [s] "a" (s));
		s += 256 / sizeof(long);
	}
}

static inline void crst_table_init(unsigned long *crst, unsigned long entry)
{
	clear_table(crst, entry, sizeof(unsigned long)*2048);
}

static inline unsigned long pgd_entry_type(struct mm_struct *mm)
{
	if (mm->context.asce_limit <= (1UL << 31))
		return _SEGMENT_ENTRY_EMPTY;
	if (mm->context.asce_limit <= (1UL << 42))
		return _REGION3_ENTRY_EMPTY;
	if (mm->context.asce_limit <= (1UL << 53))
		return _REGION2_ENTRY_EMPTY;
	return _REGION1_ENTRY_EMPTY;
}

int crst_table_upgrade(struct mm_struct *mm, unsigned long limit);
void crst_table_downgrade(struct mm_struct *);

static inline p4d_t *p4d_alloc_one(struct mm_struct *mm, unsigned long address)
{
	unsigned long *table = crst_table_alloc(mm);

	if (table)
		crst_table_init(table, _REGION2_ENTRY_EMPTY);
	return (p4d_t *) table;
}
#define p4d_free(mm, p4d) crst_table_free(mm, (unsigned long *) p4d)

static inline pud_t *pud_alloc_one(struct mm_struct *mm, unsigned long address)
{
	unsigned long *table = crst_table_alloc(mm);
	if (table)
		crst_table_init(table, _REGION3_ENTRY_EMPTY);
	return (pud_t *) table;
}
#define pud_free(mm, pud) crst_table_free(mm, (unsigned long *) pud)

static inline pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long vmaddr)
{
	unsigned long *table = crst_table_alloc(mm);

	if (!table)
		return NULL;
	crst_table_init(table, _SEGMENT_ENTRY_EMPTY);
	if (!pgtable_pmd_page_ctor(virt_to_page(table))) {
		crst_table_free(mm, table);
		return NULL;
	}
	return (pmd_t *) table;
}

static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
{
	pgtable_pmd_page_dtor(virt_to_page(pmd));
	crst_table_free(mm, (unsigned long *) pmd);
}

static inline void pgd_populate(struct mm_struct *mm, pgd_t *pgd, p4d_t *p4d)
{
	pgd_val(*pgd) = _REGION1_ENTRY | __pa(p4d);
}

static inline void p4d_populate(struct mm_struct *mm, p4d_t *p4d, pud_t *pud)
{
	p4d_val(*p4d) = _REGION2_ENTRY | __pa(pud);
}

static inline void pud_populate(struct mm_struct *mm, pud_t *pud, pmd_t *pmd)
{
	pud_val(*pud) = _REGION3_ENTRY | __pa(pmd);
}

static inline pgd_t *pgd_alloc(struct mm_struct *mm)
{
	unsigned long *table = crst_table_alloc(mm);

	if (!table)
		return NULL;
	if (mm->context.asce_limit == (1UL << 31)) {
		/* Forking a compat process with 2 page table levels */
		if (!pgtable_pmd_page_ctor(virt_to_page(table))) {
			crst_table_free(mm, table);
			return NULL;
		}
	}
	return (pgd_t *) table;
}

static inline void pgd_free(struct mm_struct *mm, pgd_t *pgd)
{
	if (mm->context.asce_limit == (1UL << 31))
		pgtable_pmd_page_dtor(virt_to_page(pgd));
	crst_table_free(mm, (unsigned long *) pgd);
}

static inline void pmd_populate(struct mm_struct *mm,
				pmd_t *pmd, pgtable_t pte)
{
	pmd_val(*pmd) = _SEGMENT_ENTRY + __pa(pte);
}

#define pmd_populate_kernel(mm, pmd, pte) pmd_populate(mm, pmd, pte)

#define pmd_pgtable(pmd) \
	(pgtable_t)(pmd_val(pmd) & -sizeof(pte_t)*PTRS_PER_PTE)

/*
 * page table entry allocation/free routines.
 */
#define pte_alloc_one_kernel(mm, vmaddr) ((pte_t *) page_table_alloc(mm))
#define pte_alloc_one(mm, vmaddr) ((pte_t *) page_table_alloc(mm))

#define pte_free_kernel(mm, pte) page_table_free(mm, (unsigned long *) pte)
#define pte_free(mm, pte) page_table_free(mm, (unsigned long *) pte)

extern void rcu_table_freelist_finish(void);

#endif /* _S390_PGALLOC_H */
Commit	Line	Data
1da177e4	1	/*
1da177e4	2	* S390 version
a53c8fab	3	* Copyright IBM Corp. 1999, 2000
1da177e4 LT	4	* Author(s): Hartmut Penner (hp@de.ibm.com)
	5	* Martin Schwidefsky (schwidefsky@de.ibm.com)
	6	*
	7	* Derived from "include/asm-i386/pgalloc.h"
	8	* Copyright (C) 1994 Linus Torvalds
	9	*/
	10
	11	#ifndef _S390_PGALLOC_H
	12	#define _S390_PGALLOC_H
	13
1da177e4 LT	14	#include <linux/threads.h>
	15	#include <linux/gfp.h>
	16	#include <linux/mm.h>
	17
043d0708	18	unsigned long crst_table_alloc(struct mm_struct );
146e4b3c	19	void crst_table_free(struct mm_struct , unsigned long );
9282ed92	20
527e30b4	21	unsigned long page_table_alloc(struct mm_struct );
4be130a0	22	struct page page_table_alloc_pgste(struct mm_struct mm);
146e4b3c	23	void page_table_free(struct mm_struct , unsigned long );
527e30b4	24	void page_table_free_rcu(struct mmu_gather , unsigned long , unsigned long);
4be130a0	25	void page_table_free_pgste(struct page *page);
0b46e0a3	26	extern int page_table_allocate_pgste;
1da177e4	27
3610cce8	28	static inline void clear_table(unsigned long *s, unsigned long val, size_t n)
1da177e4	29	{
11a247e3 MH	30	struct addrtype { char _[256]; };
11a247e3 MH	31	int i;
4f7e90d6	32
11a247e3 MH	33	for (i = 0; i < n; i += 256) {
	34	*s = val;
	35	asm volatile(
	36	"mvc 8(248,%[s]),0(%[s])\n"
	37	: "+m" ((struct addrtype ) s)
	38	: [s] "a" (s));
	39	s += 256 / sizeof(long);
	40	}
1da177e4 LT	41	}
1da177e4 LT	42
3610cce8	43	static inline void crst_table_init(unsigned long *crst, unsigned long entry)
1da177e4	44	{
3610cce8	45	clear_table(crst, entry, sizeof(unsigned long)*2048);
1da177e4 LT	46	}
1da177e4 LT	47
3610cce8	48	static inline unsigned long pgd_entry_type(struct mm_struct *mm)
1da177e4	49	{
6252d702 MS	50	if (mm->context.asce_limit <= (1UL << 31))
	51	return _SEGMENT_ENTRY_EMPTY;
	52	if (mm->context.asce_limit <= (1UL << 42))
	53	return _REGION3_ENTRY_EMPTY;
1aea9b3f MS	54	if (mm->context.asce_limit <= (1UL << 53))
	55	return _REGION2_ENTRY_EMPTY;
	56	return _REGION1_ENTRY_EMPTY;
1da177e4 LT	57	}
1da177e4 LT	58
1aea9b3f	59	int crst_table_upgrade(struct mm_struct *mm, unsigned long limit);
723cacbd	60	void crst_table_downgrade(struct mm_struct *);
6252d702	61
1aea9b3f MS	62	static inline p4d_t p4d_alloc_one(struct mm_struct mm, unsigned long address)
	63	{
	64	unsigned long *table = crst_table_alloc(mm);
	65
	66	if (table)
	67	crst_table_init(table, _REGION2_ENTRY_EMPTY);
	68	return (p4d_t *) table;
	69	}
	70	#define p4d_free(mm, p4d) crst_table_free(mm, (unsigned long *) p4d)
	71
5a216a20 MS	72	static inline pud_t pud_alloc_one(struct mm_struct mm, unsigned long address)
5a216a20 MS	73	{
043d0708	74	unsigned long *table = crst_table_alloc(mm);
5a216a20 MS	75	if (table)
	76	crst_table_init(table, _REGION3_ENTRY_EMPTY);
	77	return (pud_t *) table;
	78	}
	79	#define pud_free(mm, pud) crst_table_free(mm, (unsigned long *) pud)
190a1d72	80
3610cce8	81	static inline pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long vmaddr)
1da177e4	82	{
043d0708	83	unsigned long *table = crst_table_alloc(mm);
ec66ad66 MS	84
	85	if (!table)
	86	return NULL;
	87	crst_table_init(table, _SEGMENT_ENTRY_EMPTY);
	88	if (!pgtable_pmd_page_ctor(virt_to_page(table))) {
	89	crst_table_free(mm, table);
	90	return NULL;
	91	}
146e4b3c	92	return (pmd_t *) table;
1da177e4	93	}
ec66ad66 MS	94
	95	static inline void pmd_free(struct mm_struct mm, pmd_t pmd)
	96	{
	97	pgtable_pmd_page_dtor(virt_to_page(pmd));
	98	crst_table_free(mm, (unsigned long *) pmd);
	99	}
1da177e4	100
1aea9b3f MS	101	static inline void pgd_populate(struct mm_struct mm, pgd_t pgd, p4d_t *p4d)
	102	{
	103	pgd_val(*pgd) = _REGION1_ENTRY \| __pa(p4d);
	104	}
	105
	106	static inline void p4d_populate(struct mm_struct mm, p4d_t p4d, pud_t *pud)
5a216a20	107	{
1aea9b3f	108	p4d_val(*p4d) = _REGION2_ENTRY \| __pa(pud);
1da177e4 LT	109	}
1da177e4 LT	110
190a1d72	111	static inline void pud_populate(struct mm_struct mm, pud_t pud, pmd_t *pmd)
c1821c2e	112	{
b2fa47e6	113	pud_val(*pud) = _REGION3_ENTRY \| __pa(pmd);
c1821c2e GS	114	}
c1821c2e GS	115
3610cce8 MS	116	static inline pgd_t pgd_alloc(struct mm_struct mm)
3610cce8 MS	117	{
3446c13b MS	118	unsigned long *table = crst_table_alloc(mm);
	119
	120	if (!table)
	121	return NULL;
	122	if (mm->context.asce_limit == (1UL << 31)) {
	123	/* Forking a compat process with 2 page table levels */
	124	if (!pgtable_pmd_page_ctor(virt_to_page(table))) {
	125	crst_table_free(mm, table);
	126	return NULL;
	127	}
	128	}
	129	return (pgd_t *) table;
	130	}
	131
	132	static inline void pgd_free(struct mm_struct mm, pgd_t pgd)
	133	{
	134	if (mm->context.asce_limit == (1UL << 31))
	135	pgtable_pmd_page_dtor(virt_to_page(pgd));
	136	crst_table_free(mm, (unsigned long *) pgd);
3610cce8	137	}
3610cce8	138
146e4b3c MS	139	static inline void pmd_populate(struct mm_struct *mm,
146e4b3c MS	140	pmd_t *pmd, pgtable_t pte)
1da177e4	141	{
b2fa47e6	142	pmd_val(*pmd) = _SEGMENT_ENTRY + __pa(pte);
1da177e4	143	}
146e4b3c	144
b2fa47e6 MS	145	#define pmd_populate_kernel(mm, pmd, pte) pmd_populate(mm, pmd, pte)
b2fa47e6 MS	146
146e4b3c MS	147	#define pmd_pgtable(pmd) \
146e4b3c MS	148	(pgtable_t)(pmd_val(pmd) & -sizeof(pte_t)*PTRS_PER_PTE)
1da177e4 LT	149
	150	/*
	151	* page table entry allocation/free routines.
	152	*/
527e30b4 MS	153	#define pte_alloc_one_kernel(mm, vmaddr) ((pte_t *) page_table_alloc(mm))
527e30b4 MS	154	#define pte_alloc_one(mm, vmaddr) ((pte_t *) page_table_alloc(mm))
146e4b3c MS	155
	156	#define pte_free_kernel(mm, pte) page_table_free(mm, (unsigned long *) pte)
	157	#define pte_free(mm, pte) page_table_free(mm, (unsigned long *) pte)
1da177e4	158
80217147 MS	159	extern void rcu_table_freelist_finish(void);
80217147 MS	160
1da177e4	161	#endif /* _S390_PGALLOC_H */