aboutsummaryrefslogtreecommitdiff
path: root/include/asm-sparc64/pgalloc.h
blob: ecea1bbdc11549e05f097b5bf75c5ceeb1af270b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
/* $Id: pgalloc.h,v 1.30 2001/12/21 04:56:17 davem Exp $ */
#ifndef _SPARC64_PGALLOC_H
#define _SPARC64_PGALLOC_H

#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/mm.h>

#include <asm/spitfire.h>
#include <asm/cpudata.h>
#include <asm/cacheflush.h>
#include <asm/page.h>

/* Page table allocation/freeing. */
#ifdef CONFIG_SMP
/* Sliiiicck */
#define pgt_quicklists	local_cpu_data()
#else
extern struct pgtable_cache_struct {
	unsigned long *pgd_cache;
	unsigned long *pte_cache;
	unsigned int pgcache_size;
} pgt_quicklists;
#endif
#define pgd_quicklist		(pgt_quicklists.pgd_cache)
#define pte_quicklist		(pgt_quicklists.pte_cache)
#define pgtable_cache_size	(pgt_quicklists.pgcache_size)

static inline void free_pgd_fast(pgd_t *pgd)
{
	preempt_disable();
	*(unsigned long *)pgd = (unsigned long) pgd_quicklist;
	pgd_quicklist = (unsigned long *) pgd;
	pgtable_cache_size++;
	preempt_enable();
}

static inline pgd_t *get_pgd_fast(void)
{
	unsigned long *ret;

	preempt_disable();
	if((ret = pgd_quicklist) != NULL) {
		pgd_quicklist = (unsigned long *)(*ret);
		ret[0] = 0;
		pgtable_cache_size--;
		preempt_enable();
	} else {
		preempt_enable();
		ret = (unsigned long *) __get_free_page(GFP_KERNEL|__GFP_REPEAT);
		if(ret)
			memset(ret, 0, PAGE_SIZE);
	}
	return (pgd_t *)ret;
}

static inline void free_pgd_slow(pgd_t *pgd)
{
	free_page((unsigned long)pgd);
}

#define pud_populate(MM, PUD, PMD)	pud_set(PUD, PMD)

static inline pmd_t *pmd_alloc_one_fast(void)
{
	unsigned long *ret;

	preempt_disable();
	ret = (unsigned long *) pte_quicklist;
	if (likely(ret)) {
		pte_quicklist = (unsigned long *)(*ret);
		ret[0] = 0;
		pgtable_cache_size--;
	}
	preempt_enable();

	return (pmd_t *) ret;
}

static inline pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address)
{
	pmd_t *pmd;

	pmd = pmd_alloc_one_fast();
	if (unlikely(!pmd)) {
		pmd = (pmd_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT);
		if (pmd)
			memset(pmd, 0, PAGE_SIZE);
	}
	return pmd;
}

static inline void free_pmd_fast(pmd_t *pmd)
{
	preempt_disable();
	*(unsigned long *)pmd = (unsigned long) pte_quicklist;
	pte_quicklist = (unsigned long *) pmd;
	pgtable_cache_size++;
	preempt_enable();
}

static inline void free_pmd_slow(pmd_t *pmd)
{
	free_page((unsigned long)pmd);
}

#define pmd_populate_kernel(MM, PMD, PTE)	pmd_set(PMD, PTE)
#define pmd_populate(MM,PMD,PTE_PAGE)		\
	pmd_populate_kernel(MM,PMD,page_address(PTE_PAGE))

static inline pte_t *pte_alloc_one_fast(void)
{
	unsigned long *ret;

	preempt_disable();
	ret = (unsigned long *) pte_quicklist;
	if (likely(ret)) {
		pte_quicklist = (unsigned long *)(*ret);
		ret[0] = 0;
		pgtable_cache_size--;
	}
	preempt_enable();

	return (pte_t *) ret;
}

static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
{
	pte_t *ptep = pte_alloc_one_fast();

	if (likely(ptep))
		return ptep;

	return (pte_t *) get_zeroed_page(GFP_KERNEL|__GFP_REPEAT);
}

static inline struct page *pte_alloc_one(struct mm_struct *mm, unsigned long addr)
{
	pte_t *pte = pte_alloc_one_fast();

	if (likely(pte))
		return virt_to_page(pte);

	return alloc_pages(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO, 0);
}

static inline void free_pte_fast(pte_t *pte)
{
	preempt_disable();
	*(unsigned long *)pte = (unsigned long) pte_quicklist;
	pte_quicklist = (unsigned long *) pte;
	pgtable_cache_size++;
	preempt_enable();
}

static inline void free_pte_slow(pte_t *pte)
{
	free_page((unsigned long) pte);
}

static inline void pte_free_kernel(pte_t *pte)
{
	free_pte_fast(pte);
}

static inline void pte_free(struct page *ptepage)
{
	free_pte_fast(page_address(ptepage));
}

#define pmd_free(pmd)		free_pmd_fast(pmd)
#define pgd_free(pgd)		free_pgd_fast(pgd)
#define pgd_alloc(mm)		get_pgd_fast()

#endif /* _SPARC64_PGALLOC_H */