Attachment #314493 for bug #416685

Lines 38-47 pgd_free(struct mm_struct mm, pgd_t pgd) Link Here

(-)a/arch/alpha/include/asm/pgalloc.h (-4 / +14 lines)
38	}	38	}
39		39
40	static inline pmd_t *	40	static inline pmd_t *
		41	__pmd_alloc_one(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
		42	{
		43	return (pmd_t *)__get_free_page(gfp_mask \| __GFP_ZERO);
		44	}
		45
		46	static inline pmd_t *
41	pmd_alloc_one(struct mm_struct *mm, unsigned long address)	47	pmd_alloc_one(struct mm_struct *mm, unsigned long address)
42	{	48	{
43	pmd_t ret = (pmd_t )__get_free_page(GFP_KERNEL\|__GFP_REPEAT\|__GFP_ZERO);	49	return __pmd_alloc_one(mm, address, GFP_KERNEL \| __GFP_REPEAT);
44	return ret;
45	}	50	}
46		51
47	static inline void	52	static inline void
Lines 51-60 pmd_free(struct mm_struct mm, pmd_t pmd) Link Here
51	}	56	}
52		57
53	static inline pte_t *	58	static inline pte_t *
		59	__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long addressi, gfp_t gfp_mask)
		60	{
		61	return (pte_t *)__get_free_page(gfp_mask \| __GFP_ZERO);
		62	}
		63
		64	static inline pte_t *
54	pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)	65	pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
55	{	66	{
56	pte_t pte = (pte_t )__get_free_page(GFP_KERNEL\|__GFP_REPEAT\|__GFP_ZERO);	67	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
57	return pte;
58	}	68	}
59		69
60	static inline void	70	static inline void




/*
 * Since we have only two-level page tables, these are trivial
 */
#define __pmd_alloc_one(mm,addr,mask)	({ BUG(); ((pmd_t *)2); })
#define pmd_alloc_one(mm,addr)		({ BUG(); ((pmd_t *)2); })
#define pmd_free(mm, pmd)		do { } while (0)
#define pud_populate(mm,pmd,pte)	BUG()

 *  +------------+
 */
static inline pte_t *
__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long addr, gfp_t gfp_mask)
{
	pte_t *pte;

	pte = (pte_t *)__get_free_page(gfp_mask | __GFP_NOTRACK | __GFP_ZERO);
	if (pte)
		clean_pte_table(pte);

	return pte;
}

static inline pte_t *
pte_alloc_one_kernel(struct mm_struct *mm, unsigned long addr)
{
	return __pte_alloc_one_kernel(mm, addr, GFP_KERNEL | __GFP_REPEAT);
}

static inline pgtable_t
pte_alloc_one(struct mm_struct *mm, unsigned long addr)
{




	quicklist_free(QUICK_PGD, NULL, pgd);
}

static inline pte_t *__pte_alloc_one_kernel(struct mm_struct *mm,
					  unsigned long address, gfp_t gfp_mask)
{
	return quicklist_alloc(QUICK_PT, gfp_mask, NULL);
}

static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
					  unsigned long address)
{
	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL | __GFP_REPEAT);
}

static inline pgtable_t pte_alloc_one(struct mm_struct *mm,




	free_page((unsigned long)pgd);
}

static inline pte_t *
__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address, 
	gfp_t gfp_mask)
{
  	return (pte_t *) __get_free_page(gfp_mask | __GFP_ZERO);
}

static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
{
	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL | __GFP_REPEAT);
 	return pte;
}

static inline pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)




extern void pgd_free(struct mm_struct *mm, pgd_t *);

extern pte_t *pte_alloc_one_kernel(struct mm_struct *, unsigned long);
extern pte_t *__pte_alloc_one_kernel(struct mm_struct *, unsigned long, gfp_t);

extern pgtable_t pte_alloc_one(struct mm_struct *, unsigned long);
extern pgtable_t __pte_alloc_one(struct mm_struct *, unsigned long, gfp_t);

static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
{

 * inside the pgd, so has no extra memory associated with it.
 * (In the PAE case we free the pmds as part of the pgd.)
 */
#define __pmd_alloc_one(mm, addr,mask)		({ BUG(); ((pmd_t *) 2); })
#define pmd_alloc_one(mm, addr)		({ BUG(); ((pmd_t *) 2); })
#define pmd_free(mm, x)			do { } while (0)
#define __pmd_free_tlb(tlb,x,a)		do { } while (0)

Lines 223-228 static inline pud_t pud_offset(pgd_t pgd, unsigned long address) Link Here

(-)a/arch/frv/include/asm/pgtable.h (+1 lines)
223	* allocating and freeing a pud is trivial: the 1-entry pud is	223	* allocating and freeing a pud is trivial: the 1-entry pud is
224	* inside the pgd, so has no extra memory associated with it.	224	* inside the pgd, so has no extra memory associated with it.
225	*/	225	*/
		226	#define __pud_alloc_one(mm, address, mask) NULL
226	#define pud_alloc_one(mm, address) NULL	227	#define pud_alloc_one(mm, address) NULL
227	#define pud_free(mm, x) do { } while (0)	228	#define pud_free(mm, x) do { } while (0)
228	#define __pud_free_tlb(tlb, x, address) do { } while (0)	229	#define __pud_free_tlb(tlb, x, address) do { } while (0)





pgd_t swapper_pg_dir[PTRS_PER_PGD] __attribute__((aligned(PAGE_SIZE)));

pte_t *__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
{
	pte_t *pte = (pte_t *)__get_free_page(gfp_mask);
	if (pte)
		clear_page(pte);
	return pte;
}

pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
{
	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL | __GFP_REPEAT);
}

pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)
{
	struct page *page;

Lines 39-47 pgd_populate(struct mm_struct mm, pgd_t pgd_entry, pud_t * pud) Link Here

(-)a/arch/ia64/include/asm/pgalloc.h (-3 / +21 lines)
39	pgd_val(*pgd_entry) = __pa(pud);	39	pgd_val(*pgd_entry) = __pa(pud);
40	}	40	}
41		41
		42	static inline pud_t *
		43	__pud_alloc_one(struct mm_struct *mm, unsigned long addr, gfp_t gfp_mask)
		44	{
		45	return quicklist_alloc(0, gfp_mask, NULL);
		46	}
		47
42	static inline pud_t pud_alloc_one(struct mm_struct mm, unsigned long addr)	48	static inline pud_t pud_alloc_one(struct mm_struct mm, unsigned long addr)
43	{	49	{
44	return quicklist_alloc(0, GFP_KERNEL, NULL);	50	return __pud_alloc_one(mm, addr, GFP_KERNEL);
45	}	51	}
46		52
47	static inline void pud_free(struct mm_struct mm, pud_t pud)	53	static inline void pud_free(struct mm_struct mm, pud_t pud)
Lines 57-65 pud_populate(struct mm_struct mm, pud_t pud_entry, pmd_t * pmd) Link Here
57	pud_val(*pud_entry) = __pa(pmd);	63	pud_val(*pud_entry) = __pa(pmd);
58	}	64	}
59		65
		66	static inline pmd_t *
		67	__pmd_alloc_one(struct mm_struct *mm, unsigned long addr, gfp_t gfp_mask)
		68	{
		69	return quicklist_alloc(0, gfp_mask, NULL);
		70	}
		71
60	static inline pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long addr)	72	static inline pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long addr)
61	{	73	{
62	return quicklist_alloc(0, GFP_KERNEL, NULL);	74	return __pmd_alloc_one(mm, addr, GFP_KERNEL);
63	}	75	}
64		76
65	static inline void pmd_free(struct mm_struct mm, pmd_t pmd)	77	static inline void pmd_free(struct mm_struct mm, pmd_t pmd)
Lines 95-104 static inline pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long addr) Link Here
95	return page;	107	return page;
96	}	108	}
97		109
		110	static inline pte_t __pte_alloc_one_kernel(struct mm_struct mm,
		111	unsigned long addr, gfp_t gfp_mask)
		112	{
		113	return quicklist_alloc(0, gfp_mask, NULL);
		114	}
		115
98	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,	116	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,
99	unsigned long addr)	117	unsigned long addr)
100	{	118	{
101	return quicklist_alloc(0, GFP_KERNEL, NULL);	119	return __pte_alloc_one_kernel(mm, addr, GFP_KERNEL);
102	}	120	}
103		121
104	static inline void pte_free(struct mm_struct *mm, pgtable_t pte)	122	static inline void pte_free(struct mm_struct *mm, pgtable_t pte)




	free_page((unsigned long)pgd);
}

static __inline__ pte_t *__pte_alloc_one_kernel(struct mm_struct *mm,
	unsigned long address, gfp_t gfp_mask)
{
	return (pte_t *)__get_free_page(gfp_mask | __GFP_ZERO);
}

static __inline__ pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
	unsigned long address)
{
	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL);

	return pte;
}

static __inline__ pgtable_t pte_alloc_one(struct mm_struct *mm,

 * (In the PAE case we free the pmds as part of the pgd.)
 */

#define __pmd_alloc_one(mm, addr,mask)		({ BUG(); ((pmd_t *)2); })
#define pmd_alloc_one(mm, addr)		({ BUG(); ((pmd_t *)2); })
#define pmd_free(mm, x)			do { } while (0)
#define __pmd_free_tlb(tlb, x, addr)	do { } while (0)

Lines 5-17 Link Here

(-)a/arch/m68k/include/asm/motorola_pgalloc.h (-3 / +17 lines)
5	#include <asm/tlbflush.h>	5	#include <asm/tlbflush.h>
6		6
7	extern pmd_t *get_pointer_table(void);	7	extern pmd_t *get_pointer_table(void);
		8	extern pmd_t *__get_pointer_table (gfp_t);
8	extern int free_pointer_table(pmd_t *);	9	extern int free_pointer_table(pmd_t *);
9		10
10	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long address)	11	static inline pte_t *
		12	__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address,
		13	gfp_t gfp_mask)
11	{	14	{
12	pte_t *pte;	15	pte_t *pte;
13		16
14	pte = (pte_t *)__get_free_page(GFP_KERNEL\|__GFP_REPEAT\|__GFP_ZERO);	17	pte = (pte_t *)__get_free_page(gfp_mask \| __GFP_ZERO);
15	if (pte) {	18	if (pte) {
16	__flush_page_to_ram(pte);	19	__flush_page_to_ram(pte);
17	flush_tlb_kernel_page(pte);	20	flush_tlb_kernel_page(pte);
Lines 21-26 static inline pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long ad Link Here
21	return pte;	24	return pte;
22	}	25	}
23		26
		27	static inline pte_t *
		28	pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
		29	{
		30	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
		31	}
		32
24	static inline void pte_free_kernel(struct mm_struct mm, pte_t pte)	33	static inline void pte_free_kernel(struct mm_struct mm, pte_t pte)
25	{	34	{
26	cache_page(pte);	35	cache_page(pte);
Lines 61-70 static inline void __pte_free_tlb(struct mmu_gather *tlb, pgtable_t page, Link Here
61	__free_page(page);	70	__free_page(page);
62	}	71	}
63		72
		73	static inline pmd_t *
		74	__pmd_alloc_one(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
		75	{
		76	return __get_pointer_table(gfp_mask);
		77	}
64		78
65	static inline pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long address)	79	static inline pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long address)
66	{	80	{
67	return get_pointer_table();	81	return __pmd_alloc_one(mm, address, GFP_KERNEL);
68	}	82	}
69		83
70	static inline int pmd_free(struct mm_struct mm, pmd_t pmd)	84	static inline int pmd_free(struct mm_struct mm, pmd_t pmd)





extern const char bad_pmd_string[];

#define __pmd_alloc_one(mm,address,mask)       ({ BUG(); ((pmd_t *)2); })
#define pmd_alloc_one(mm,address)       ({ BUG(); ((pmd_t *)2); })



	tlb_remove_page((tlb), pte);			\
} while (0)

static inline pte_t *
__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address, 
		gfp_t gfp_mask)
{
	unsigned long page = __get_free_page(gfp_mask);

	if (!page)
		return NULL;

	return (pte_t *) (page);
}

static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
					  unsigned long address)
{
	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL | __GFP_REPEAT);
}

static inline pgtable_t pte_alloc_one(struct mm_struct *mm,
					unsigned long address)
{

Lines 58-64 void __init init_pointer_table(unsigned long ptable) Link Here

(-)a/arch/m68k/mm/memory.c (-2 / +7 lines)
58	return;	58	return;
59	}	59	}
60		60
61	pmd_t *get_pointer_table (void)	61	pmd_t *__get_pointer_table (gfp_t gfp_mask)
62	{	62	{
63	ptable_desc *dp = ptable_list.next;	63	ptable_desc *dp = ptable_list.next;
64	unsigned char mask = PD_MARKBITS (dp);	64	unsigned char mask = PD_MARKBITS (dp);
Lines 75-81 pmd_t *get_pointer_table (void) Link Here
75	void *page;	75	void *page;
76	ptable_desc *new;	76	ptable_desc *new;
77		77
78	if (!(page = (void *)get_zeroed_page(GFP_KERNEL)))	78	if (!(page = (void *)get_zeroed_page(gfp_mask)))
79	return NULL;	79	return NULL;
80		80
81	flush_tlb_kernel_page(page);	81	flush_tlb_kernel_page(page);
Lines 98-103 pmd_t *get_pointer_table (void) Link Here
98	return (pmd_t *) (page_address(PD_PAGE(dp)) + off);	98	return (pmd_t *) (page_address(PD_PAGE(dp)) + off);
99	}	99	}
100		100
		101	pmd_t *get_pointer_table (void)
		102	{
		103	return __get_pointer_table(GFP_KERNEL);
		104	}
		105
101	int free_pointer_table (pmd_t *ptable)	106	int free_pointer_table (pmd_t *ptable)
102	{	107	{
103	ptable_desc *dp;	108	ptable_desc *dp;




 * the pgd will always be present..
 */
#define pmd_alloc_one_fast(mm, address)	({ BUG(); ((pmd_t *)1); })
#define __pmd_alloc_one(mm, address,mask)	({ BUG(); ((pmd_t *)2); })
#define pmd_alloc_one(mm, address)	({ BUG(); ((pmd_t *)2); })

extern pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long addr);
extern pte_t *__pte_alloc_one_kernel(struct mm_struct *, unsigned long, gfp_t);

static inline struct page *pte_alloc_one(struct mm_struct *mm,
		unsigned long address)

 * 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,mask)	({ BUG(); ((pmd_t *)2); })
#define pmd_alloc_one(mm, address)	({ BUG(); ((pmd_t *)2); })
#define pmd_free(mm, x)			do { } while (0)
#define __pmd_free_tlb(tlb, x, addr)	pmd_free((tlb)->mm, x)




	return pa;
}

__init_refok pte_t *__pte_alloc_one_kernel(struct mm_struct *mm,
		unsigned long address, gfp_t gfp_mask)
{
	pte_t *pte;
	if (mem_init_done) {
		pte = (pte_t *)__get_free_page(gfp_mask | __GFP_ZERO);
					__GFP_REPEAT | __GFP_ZERO);
	} else {
		pte = (pte_t *)early_get_page();
		if (pte)


	map_page(address, phys, pgprot_val(flags));
}

__init_refok pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
		unsigned long address)
{
	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL | __GFP_REPEAT);
}




	free_pages((unsigned long)pgd, PGD_ORDER);
}

static inline pte_t *__pte_alloc_one_kernel(struct mm_struct *mm,
	unsigned long address, gfp_t gfp_mask)
{
	return (pte_t *) __get_free_pages(gfp_mask | __GFP_ZERO, PTE_ORDER);
}

static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
	unsigned long address)
{
	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL | __GFP_REPEAT);

	pte = (pte_t *) __get_free_pages(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO, PTE_ORDER);

	return pte;
}

static inline struct page *pte_alloc_one(struct mm_struct *mm,


#ifndef __PAGETABLE_PMD_FOLDED

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

	pmd = (pmd_t *) __get_free_pages(gfp_mask, PMD_ORDER);
	if (pmd)
		pmd_init((unsigned long)pmd, (unsigned long)invalid_pte_table);
	return pmd;
}

static inline pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address)
{
	return __pmd_alloc_one(mm, address, GFP_KERNEL | __GFP_REPEAT);
}

static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
{
	free_pages((unsigned long)pmd, PMD_ORDER);

Lines 37-42 extern pgd_t pgd_alloc(struct mm_struct ); Link Here

(-)a/arch/mn10300/include/asm/pgalloc.h (+2 lines)
37	extern void pgd_free(struct mm_struct , pgd_t );	37	extern void pgd_free(struct mm_struct , pgd_t );
38		38
39	extern pte_t pte_alloc_one_kernel(struct mm_struct , unsigned long);	39	extern pte_t pte_alloc_one_kernel(struct mm_struct , unsigned long);
		40	extern pte_t __pte_alloc_one_kernel(struct mm_struct , unsigned long, gfp_t);
		41
40	extern struct page pte_alloc_one(struct mm_struct , unsigned long);	42	extern struct page pte_alloc_one(struct mm_struct , unsigned long);
41		43
42	static inline void pte_free_kernel(struct mm_struct mm, pte_t pte)	44	static inline void pte_free_kernel(struct mm_struct mm, pte_t pte)




	local_flush_tlb_one(vaddr);
}

pte_t *__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address, 
		gfp_t gfp_mask)
{
	pte_t *pte = (pte_t *)__get_free_page(gfp_mask);
	if (pte)
		clear_page(pte);
	return pte;
}

pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
{
	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL | __GFP_REPEAT);
}

struct page *pte_alloc_one(struct mm_struct *mm, unsigned long address)
{
	struct page *pte;




		        (__u32)(__pa((unsigned long)pmd) >> PxD_VALUE_SHIFT));
}

static inline pmd_t *
__pmd_alloc_one(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
{
	pmd_t *pmd = (pmd_t *)__get_free_pages(gfp_mask, PMD_ORDER);
					       PMD_ORDER);
	if (pmd)
		memset(pmd, 0, PAGE_SIZE<<PMD_ORDER);
	return pmd;
}

static inline pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address)
{
	return __pmd_alloc_one(mm, address, GFP_KERNEL | __GFP_REPEAT);
}

static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
{
#ifdef CONFIG_64BIT

 * inside the pgd, so has no extra memory associated with it.
 */

#define __pmd_alloc_one(mm, addr, mask)		({ BUG(); ((pmd_t *)2); })
#define pmd_alloc_one(mm, addr)		({ BUG(); ((pmd_t *)2); })
#define pmd_free(mm, x)			do { } while (0)
#define pgd_populate(mm, pmd, pte)	BUG()

}

static inline pte_t *
__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long addr, gfp_t gfp_mask)
{
	return (pte_t *)__get_free_page(gfp_mask | __GFP_ZERO);
}

static inline pte_t *
pte_alloc_one_kernel(struct mm_struct *mm, unsigned long addr)
{
	return __pte_alloc_one_kernel(mm, addr, GFP_KERNEL | __GFP_REPEAT);
	return pte;
}

static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)

Lines 35-40 extern void pgd_free(struct mm_struct mm, pgd_t pgd); Link Here

(-)a/arch/powerpc/include/asm/pgalloc-32.h (+2 lines)
35	#endif	35	#endif
36		36
37	extern pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long addr);	37	extern pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long addr);
		38	extern pte_t __pte_alloc_one_kernel(struct mm_struct , unsigned long, gfp_t);
		39
38	extern pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long addr);	40	extern pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long addr);
39		41
40	static inline void pgtable_free(void *table, unsigned index_size)	42	static inline void pgtable_free(void *table, unsigned index_size)

Lines 51-60 static inline void pgd_free(struct mm_struct mm, pgd_t pgd) Link Here

(-)a/arch/powerpc/include/asm/pgalloc-64.h (-5 / +22 lines)
51		51
52	#define pgd_populate(MM, PGD, PUD) pgd_set(PGD, PUD)	52	#define pgd_populate(MM, PGD, PUD) pgd_set(PGD, PUD)
53		53
		54	static inline pud_t *
		55	__pud_alloc_one(struct mm_struct *mm, unsigned long addr, gfp_t gfp_mask)
		56	{
		57	return kmem_cache_alloc(PGT_CACHE(PUD_INDEX_SIZE), gfp_mask);
		58	}
		59
54	static inline pud_t pud_alloc_one(struct mm_struct mm, unsigned long addr)	60	static inline pud_t pud_alloc_one(struct mm_struct mm, unsigned long addr)
55	{	61	{
56	return kmem_cache_alloc(PGT_CACHE(PUD_INDEX_SIZE),	62	return __pud_alloc_one(mm, addr, GFP_KERNEL \| __GFP_REPEAT);
57	GFP_KERNEL\|__GFP_REPEAT);
58	}	63	}
59		64
60	static inline void pud_free(struct mm_struct mm, pud_t pud)	65	static inline void pud_free(struct mm_struct mm, pud_t pud)
Lines 89-98 static inline void pmd_populate_kernel(struct mm_struct mm, pmd_t pmd, Link Here
89		94
90	#endif /* CONFIG_PPC_64K_PAGES */	95	#endif /* CONFIG_PPC_64K_PAGES */
91		96
		97	static inline pmd_t *
		98	__pmd_alloc_one(struct mm_struct *mm, unsigned long addr, gfp_t gfp_mask)
		99	{
		100	return kmem_cache_alloc(PGT_CACHE(PMD_INDEX_SIZE), gfp_mask);
		101	}
		102
92	static inline pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long addr)	103	static inline pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long addr)
93	{	104	{
94	return kmem_cache_alloc(PGT_CACHE(PMD_INDEX_SIZE),	105	return __pmd_alloc_one(mm, addr, GFP_KERNEL \| __GFP_REPEAT);
95	GFP_KERNEL\|__GFP_REPEAT);
96	}	106	}
97		107
98	static inline void pmd_free(struct mm_struct mm, pmd_t pmd)	108	static inline void pmd_free(struct mm_struct mm, pmd_t pmd)
Lines 100-109 static inline void pmd_free(struct mm_struct mm, pmd_t pmd) Link Here
100	kmem_cache_free(PGT_CACHE(PMD_INDEX_SIZE), pmd);	110	kmem_cache_free(PGT_CACHE(PMD_INDEX_SIZE), pmd);
101	}	111	}
102		112
		113	static inline pte_t *
		114	__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address,
		115	gfp_t gfp_mask)
		116	{
		117	return (pte_t *)__get_free_page(gfp_mask \| __GFP_ZERO);
		118	}
		119
103	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,	120	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,
104	unsigned long address)	121	unsigned long address)
105	{	122	{
106	return (pte_t *)__get_free_page(GFP_KERNEL \| __GFP_REPEAT \| __GFP_ZERO);	123	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
107	}	124	}
108		125
109	static inline pgtable_t pte_alloc_one(struct mm_struct *mm,	126	static inline pgtable_t pte_alloc_one(struct mm_struct *mm,




#endif
}

__init_refok pte_t *
__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
{
	pte_t *pte;
	extern int mem_init_done;
	extern void *early_get_page(void);

	if (mem_init_done) {
		pte = (pte_t *)__get_free_page(gfp_mask | __GFP_ZERO);
	} else {
		pte = (pte_t *)early_get_page();
		if (pte)

	return pte;
}

__init_refok pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
{
	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL | __GFP_REPEAT);
}

pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)
{
	struct page *ptepage;




#include <linux/mm.h>

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

unsigned long *page_table_alloc(struct mm_struct *, unsigned long);
unsigned long *__page_table_alloc(struct mm_struct *, gfp_t);
void page_table_free(struct mm_struct *, unsigned long *);
void page_table_free_rcu(struct mmu_gather *, unsigned long *);


	return _SEGMENT_ENTRY_EMPTY;
}

#define __pud_alloc_one(mm,address,mask)		({ BUG(); ((pud_t *)2); })
#define pud_alloc_one(mm,address)		({ BUG(); ((pud_t *)2); })
#define pud_free(mm, x)				do { } while (0)

#define __pmd_alloc_one(mm,address,mask)		({ BUG(); ((pmd_t *)2); })
#define pmd_alloc_one(mm,address)		({ BUG(); ((pmd_t *)2); })
#define pmd_free(mm, x)				do { } while (0)


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

static inline pud_t *
__pud_alloc_one(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
{
	unsigned long *table = __crst_table_alloc(mm, mm->context.noexec, gfp_mask);
	if (table)
		crst_table_init(table, _REGION3_ENTRY_EMPTY);
	return (pud_t *) table;
}

static inline pud_t *pud_alloc_one(struct mm_struct *mm, unsigned long address)
{
	return __pud_alloc_one(mm, address, GFP_KERNEL);
}
#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, gfp_t gfp_mask)
{
	unsigned long *table = __crst_table_alloc(mm, mm->context.noexec, gfp_mask);
	if (table)
		crst_table_init(table, _SEGMENT_ENTRY_EMPTY);
	return (pmd_t *) table;
}

static inline pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long vmaddr)
{
	return __pmd_alloc_one(mm, vmaddr, GFP_KERNEL);
}
#define pmd_free(mm, pmd) crst_table_free(mm, (unsigned long *) pmd)

static inline void pgd_populate(struct mm_struct *mm, pgd_t *pgd, pud_t *pud)

/*
 * page table entry allocation/free routines.
 */
#define __pte_alloc_one_kernel(mm, vmaddr, mask) \
	((pte_t *) __page_table_alloc((mm), (mask)))
#define pte_alloc_one_kernel(mm, vmaddr) \
	((pte_t *) __pte_alloc_one_kernel((mm), (vmaddr), GFP_KERNEL|__GFP_REPEAT)

#define pte_alloc_one(mm, vmaddr) ((pte_t *) page_table_alloc(mm, vmaddr))

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




#endif


unsigned long *
__crst_table_alloc(struct mm_struct *mm, int noexec, gfp_t gfp_mask)
{
	struct page *page = alloc_pages(gfp_mask, ALLOC_ORDER);

	if (!page)
		return NULL;
	return (unsigned long *) page_to_phys(page);
}

unsigned long *crst_table_alloc(struct mm_struct *mm, int noexec)
{
	return __crst_table_alloc(mm, noexec, GFP_KERNEL);
}

void crst_table_free(struct mm_struct *mm, unsigned long *table)
{
	free_pages((unsigned long) table, ALLOC_ORDER);

/*
 * page table entry allocation/free routines.
 */
unsigned long *__page_table_alloc(struct mm_struct *mm, gfp_t gfp_mask)
{
	struct page *page;
	unsigned long *table;

	}
	if ((mask & FRAG_MASK) == FRAG_MASK) {
		spin_unlock_bh(&mm->context.list_lock);
		page = alloc_page(gfp_mask);
		if (!page)
			return NULL;
		pgtable_page_ctor(page);

	return table;
}

unsigned long *page_table_alloc(struct mm_struct *mm)
{
	return __page_table_alloc(mm, GFP_KERNEL | __GFP_REPEAT);
}

void page_table_free(struct mm_struct *mm, unsigned long *table)
{
	struct page *page;




	free_pages((unsigned long)pgd, PGD_ORDER);
}

static inline pte_t *
__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
{
	return (pte_t *) __get_free_pages(gfp_mask | __GFP_ZERO, PTE_ORDER);
}

static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
	unsigned long address)
{
	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL | __GFP_REPEAT);

	pte = (pte_t *) __get_free_pages(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO,
					PTE_ORDER);

	return pte;
}

static inline struct page *pte_alloc_one(struct mm_struct *mm,




/*
 * Allocate and free page tables.
 */
static inline pte_t *__pte_alloc_one_kernel(struct mm_struct *mm,
					  unsigned long address, gfp_t gfp_mask)
{
	return quicklist_alloc(QUICK_PT, gfp_mask, NULL);
}

static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
					  unsigned long address)
{
	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL | __GFP_REPEAT);
}

static inline pgtable_t pte_alloc_one(struct mm_struct *mm,

Lines 45-53 void pud_populate(struct mm_struct mm, pud_t pud, pmd_t *pmd) Link Here

(-)a/arch/sh/mm/pgtable.c (-1 / +7 lines)
45	set_pud(pud, __pud((unsigned long)pmd));	45	set_pud(pud, __pud((unsigned long)pmd));
46	}	46	}
47		47
		48	pmd_t *
		49	__pmd_alloc_one(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
		50	{
		51	return kmem_cache_alloc(pmd_cachep, gfp_mask \| __GFP_ZERO);
		52	}
		53
48	pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long address)	54	pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long address)
49	{	55	{
50	return kmem_cache_alloc(pmd_cachep, PGALLOC_GFP);	56	return __pmd_alloc_one(mm, address, GFP_KERNEL \| __GFP_REPEAT);
51	}	57	}
52		58
53	void pmd_free(struct mm_struct mm, pmd_t pmd)	59	void pmd_free(struct mm_struct mm, pmd_t pmd)




#define pmd_pgtable(pmd) pmd_page(pmd)

static inline pte_t *
__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address, 
		gfp_t gfp_mask)
{
	return pfn_to_kaddr(page_to_pfn(__pte_alloc_one(mm, address, gfp_mask)));
}

static inline pte_t *
pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
{
	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL | __GFP_REPEAT);
}

static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)

Lines 280-288 void pgd_free(struct mm_struct mm, pgd_t pgd) Link Here

(-)a/arch/tile/mm/pgtable.c (-2 / +8 lines)
280		280
281	#define L2_USER_PGTABLE_PAGES (1 << L2_USER_PGTABLE_ORDER)	281	#define L2_USER_PGTABLE_PAGES (1 << L2_USER_PGTABLE_ORDER)
282		282
283	struct page pte_alloc_one(struct mm_struct mm, unsigned long address)	283	struct page *
		284	__pte_alloc_one(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
284	{	285	{
285	gfp_t flags = GFP_KERNEL\|__GFP_REPEAT\|__GFP_ZERO;	286	gfp_t flags = gfp_mask\|__GFP_REPEAT\|__GFP_ZERO;
286	struct page *p;	287	struct page *p;
287	#if L2_USER_PGTABLE_ORDER > 0	288	#if L2_USER_PGTABLE_ORDER > 0
Lines 305-310 struct page pgtable_alloc_one(struct mm_struct mm, unsigned long address, Link Here
305	return p;	306	return p;
306	}	307	}
307		308
		309	struct page pte_alloc_one(struct mm_struct mm, unsigned long address, int order)
		310	{
		311	return __pte_alloc_one(mm, address, GFP_KERNEL);
		312	}
		313
308	/*	314	/*
309	* Free page immediately (used in __pte_alloc if we raced with another	315	* Free page immediately (used in __pte_alloc if we raced with another
310	* process). We have to correct whatever pte_alloc_one() did before	316	* process). We have to correct whatever pte_alloc_one() did before

Lines 26-31 extern pgd_t pgd_alloc(struct mm_struct ); Link Here

(-)a/arch/um/include/asm/pgalloc.h (+1 lines)
26	extern void pgd_free(struct mm_struct mm, pgd_t pgd);	26	extern void pgd_free(struct mm_struct mm, pgd_t pgd);
27		27
28	extern pte_t pte_alloc_one_kernel(struct mm_struct , unsigned long);	28	extern pte_t pte_alloc_one_kernel(struct mm_struct , unsigned long);
		29	extern pte_t __pte_alloc_one_kernel(struct mm_struct , unsigned long, gfp_t);
29	extern pgtable_t pte_alloc_one(struct mm_struct *, unsigned long);	30	extern pgtable_t pte_alloc_one(struct mm_struct *, unsigned long);
30		31
31	static inline void pte_free_kernel(struct mm_struct mm, pte_t pte)	32	static inline void pte_free_kernel(struct mm_struct mm, pte_t pte)




	free_page((unsigned long) pgd);
}

pte_t *
__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
{
	return (pte_t *)__get_free_page(gfp_mask | __GFP_ZERO);
}

pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
{
	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL | __GFP_REPEAT);
}

pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)

}

#ifdef CONFIG_3_LEVEL_PGTABLES
pmd_t *
__pmd_alloc_one(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
{
	pmd_t *pmd = (pmd_t *) __get_free_page(gfp_mask);

	if (pmd)
		memset(pmd, 0, PAGE_SIZE);

	return pmd;
}

pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address)
{
	return __pmd_alloc_one(mm, address, GFP_KERNEL);
}
#endif

void *uml_kmalloc(int size, int flags)

Lines 34-39 extern pgd_t pgd_alloc(struct mm_struct ); Link Here

(-)a/arch/x86/include/asm/pgalloc.h (-2 / +15 lines)
34	extern void pgd_free(struct mm_struct mm, pgd_t pgd);	34	extern void pgd_free(struct mm_struct mm, pgd_t pgd);
35		35
36	extern pte_t pte_alloc_one_kernel(struct mm_struct , unsigned long);	36	extern pte_t pte_alloc_one_kernel(struct mm_struct , unsigned long);
		37	extern pte_t __pte_alloc_one_kernel(struct mm_struct , unsigned long, gfp_t);
37	extern pgtable_t pte_alloc_one(struct mm_struct *, unsigned long);	38	extern pgtable_t pte_alloc_one(struct mm_struct *, unsigned long);
38		39
39	/* Should really implement gc for free page table pages. This could be	40	/* Should really implement gc for free page table pages. This could be
Lines 78-86 static inline void pmd_populate(struct mm_struct mm, pmd_t pmd, Link Here
78	#define pmd_pgtable(pmd) pmd_page(pmd)	79	#define pmd_pgtable(pmd) pmd_page(pmd)
79		80
80	#if PAGETABLE_LEVELS > 2	81	#if PAGETABLE_LEVELS > 2
		82	static inline pmd_t *
		83	__pmd_alloc_one(struct mm_struct *mm, unsigned long addr, gfp_t gfp_mask)
		84	{
		85	return (pmd_t *)get_zeroed_page(gfp_mask);
		86	}
		87
81	static inline pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long addr)	88	static inline pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long addr)
82	{	89	{
83	return (pmd_t *)get_zeroed_page(GFP_KERNEL\|__GFP_REPEAT);	90	return __pmd_alloc_one(mm, addr, GFP_KERNEL \| __GFP_REPEAT);
84	}	91	}
85		92
86	static inline void pmd_free(struct mm_struct mm, pmd_t pmd)	93	static inline void pmd_free(struct mm_struct mm, pmd_t pmd)
Lines 114-122 static inline void pgd_populate(struct mm_struct mm, pgd_t pgd, pud_t *pud) Link Here
114	set_pgd(pgd, __pgd(_PAGE_TABLE \| __pa(pud)));	121	set_pgd(pgd, __pgd(_PAGE_TABLE \| __pa(pud)));
115	}	122	}
116		123
		124	static inline pud_t *
		125	__pud_alloc_one(struct mm_struct *mm, unsigned long addr, gfp_t gfp_mask)
		126	{
		127	return (pud_t *)get_zeroed_page(gfp_mask);
		128	}
		129
117	static inline pud_t pud_alloc_one(struct mm_struct mm, unsigned long addr)	130	static inline pud_t pud_alloc_one(struct mm_struct mm, unsigned long addr)
118	{	131	{
119	return (pud_t *)get_zeroed_page(GFP_KERNEL\|__GFP_REPEAT);	132	return __pud_alloc_one(mm, addr, GFP_KERNEL \| __GFP_REPEAT);
120	}	133	}
121		134
122	static inline void pud_free(struct mm_struct mm, pud_t pud)	135	static inline void pud_free(struct mm_struct mm, pud_t pud)

Lines 15-23 Link Here

(-)a/arch/x86/mm/pgtable.c (-1 / +7 lines)
15		15
16	gfp_t __userpte_alloc_gfp = PGALLOC_GFP \| PGALLOC_USER_GFP;	16	gfp_t __userpte_alloc_gfp = PGALLOC_GFP \| PGALLOC_USER_GFP;
17		17
		18	pte_t *
		19	__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
		20	{
		21	return (pte_t *)__get_free_page(gfp_mask \| __GFP_NOTRACK \| __GFP_ZERO);
		22	}
		23
18	pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long address)	24	pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long address)
19	{	25	{
20	return (pte_t *)__get_free_page(PGALLOC_GFP);	26	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
21	}	27	}
22		28
23	pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)	29	pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)





extern struct kmem_cache *pgtable_cache;

static inline pte_t *
__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address, 
		gfp_t gfp_mask)
{
	return kmem_cache_alloc(pgtable_cache, gfp_mask);
}

static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm, 
					 unsigned long address)
{
	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL | __GFP_REPEAT);
}

static inline pgtable_t pte_alloc_one(struct mm_struct *mm,

Lines 10-19 Link Here

(-)a/include/asm-generic/4level-fixup.h (-2 / +6 lines)
10		10
11	#define pud_t pgd_t	11	#define pud_t pgd_t
12		12
13	#define pmd_alloc(mm, pud, address) \	13	#define pmd_alloc_with_mask(mm, pud, address, mask) \
14	((unlikely(pgd_none(*(pud))) && __pmd_alloc(mm, pud, address))? \	14	((unlikely(pgd_none(*(pud))) && __pmd_alloc(mm, pud, address, mask))? \
15	NULL: pmd_offset(pud, address))	15	NULL: pmd_offset(pud, address))
16		16
		17	#define pmd_alloc(mm, pud, address) \
		18	pmd_alloc_with_mask(mm, pud, address, GFP_KERNEL)
		19
		20	#define pud_alloc_with_mask(mm, pgd, address, mask) (pgd)
17	#define pud_alloc(mm, pgd, address) (pgd)	21	#define pud_alloc(mm, pgd, address) (pgd)
18	#define pud_offset(pgd, start) (pgd)	22	#define pud_offset(pgd, start) (pgd)
19	#define pud_none(pud) 0	23	#define pud_none(pud) 0

Lines 55-61 static inline pmd_t * pmd_offset(pud_t * pud, unsigned long address) Link Here

(-)a/include/asm-generic/pgtable-nopmd.h (-1 / +2 lines)
55	* allocating and freeing a pmd is trivial: the 1-entry pmd is	55	* allocating and freeing a pmd is trivial: the 1-entry pmd is
56	* inside the pud, so has no extra memory associated with it.	56	* inside the pud, so has no extra memory associated with it.
57	*/	57	*/
58	#define pmd_alloc_one(mm, address) NULL	58	#define __pmd_alloc_one(mm, address, mask) NULL
		59	#define pmd_alloc_one(mm, address) NULL
59	static inline void pmd_free(struct mm_struct mm, pmd_t pmd)	60	static inline void pmd_free(struct mm_struct mm, pmd_t pmd)
60	{	61	{
61	}	62	}

Lines 50-55 static inline pud_t * pud_offset(pgd_t * pgd, unsigned long address) Link Here

(-)a/include/asm-generic/pgtable-nopud.h (+1 lines)
50	* allocating and freeing a pud is trivial: the 1-entry pud is	50	* allocating and freeing a pud is trivial: the 1-entry pud is
51	* inside the pgd, so has no extra memory associated with it.	51	* inside the pgd, so has no extra memory associated with it.
52	*/	52	*/
		53	#define __pud_alloc_one(mm, address, mask) NULL
53	#define pud_alloc_one(mm, address) NULL	54	#define pud_alloc_one(mm, address) NULL
54	#define pud_free(mm, x) do { } while (0)	55	#define pud_free(mm, x) do { } while (0)
55	#define __pud_free_tlb(tlb, x, a) do { } while (0)	56	#define __pud_free_tlb(tlb, x, a) do { } while (0)





#ifdef __PAGETABLE_PUD_FOLDED
static inline int __pud_alloc(struct mm_struct *mm, pgd_t *pgd,
						unsigned long address, gfp_t gfp_mask)
{
	return 0;
}
#else
int __pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address, 
		gfp_t gfp_mask);
#endif

#ifdef __PAGETABLE_PMD_FOLDED
static inline int __pmd_alloc(struct mm_struct *mm, pud_t *pud,
						unsigned long address, gfp_t gfp_mask)
{
	return 0;
}
#else
int __pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address, 
		gfp_t gfp_mask);
#endif

int __pte_alloc(struct mm_struct *mm, struct vm_area_struct *vma,
		pmd_t *pmd, unsigned long address);
int __pte_alloc_kernel(pmd_t *pmd, unsigned long address, gfp_t gfp_mask);

/*
 * The following ifdef needed to get the 4level-fixup.h header to work.
 * Remove it when 4level-fixup.h has been removed.
 */
#if defined(CONFIG_MMU) && !defined(__ARCH_HAS_4LEVEL_HACK)
static inline pud_t *pud_alloc_with_mask(struct mm_struct *mm, pgd_t *pgd, 
		unsigned long address, gfp_t gfp_mask)
{
	return (unlikely(pgd_none(*pgd)) && __pud_alloc(mm, pgd, address, gfp_mask))?
		NULL: pud_offset(pgd, address);
}

static inline pud_t *pud_alloc(struct mm_struct *mm, pgd_t *pgd, 
		unsigned long address)
{
	return pud_alloc_with_mask(mm, pgd, address, GFP_KERNEL);
}

static inline pmd_t *pmd_alloc_with_mask(struct mm_struct *mm, pud_t *pud, 
		unsigned long address, gfp_t gfp_mask)
{
	return (unlikely(pud_none(*pud)) && __pmd_alloc(mm, pud, address, gfp_mask))?
		NULL: pmd_offset(pud, address);
}

static inline pmd_t *pmd_alloc(struct mm_struct *mm, pud_t *pud, 
		unsigned long address)
{
	return pmd_alloc_with_mask(mm, pud, address, GFP_KERNEL);
}
#endif /* CONFIG_MMU && !__ARCH_HAS_4LEVEL_HACK */

#if USE_SPLIT_PTLOCKS

							pmd, address))?	\
		NULL: pte_offset_map_lock(mm, pmd, address, ptlp))

#define pte_alloc_kernel_with_mask(pmd, address, mask)			\
	((unlikely(pmd_none(*(pmd))) && __pte_alloc_kernel(pmd, address, mask))? \
		NULL: pte_offset_kernel(pmd, address))

#define pte_alloc_kernel(pmd, address)			\
	((unlikely(pmd_none(*(pmd))) && __pte_alloc_kernel(pmd, address, GFP_KERNEL))? \
		NULL: pte_offset_kernel(pmd, address))

extern void free_area_init(unsigned long * zones_size);




	return 0;
}

int __pte_alloc_kernel(pmd_t *pmd, unsigned long address, gfp_t gfp_mask)
{
	pte_t *new = __pte_alloc_one_kernel(&init_mm, address, gfp_mask);
	if (!new)
		return -ENOMEM;


 * Allocate page upper directory.
 * We've already handled the fast-path in-line.
 */
int __pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address, 
		gfp_t gfp_mask)
{
	pud_t *new = __pud_alloc_one(mm, address, gfp_mask);
	if (!new)
		return -ENOMEM;


 * Allocate page middle directory.
 * We've already handled the fast-path in-line.
 */
int __pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address, 
		gfp_t gfp_mask)
{
	pmd_t *new = __pmd_alloc_one(mm, address, gfp_mask);
	if (!new)
		return -ENOMEM;





	} while (pgd++, addr = next, addr != end);
}

static int vmap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end, 
		pgprot_t prot, struct page **pages, int *nr, gfp_t gfp_mask)
{
	pte_t *pte;


	 * callers keep track of where we're up to.
	 */

	pte = pte_alloc_kernel_with_mask(pmd, addr, gfp_mask);
	if (!pte)
		return -ENOMEM;
	do {

}

static int vmap_pmd_range(pud_t *pud, unsigned long addr,
		unsigned long end, pgprot_t prot, struct page **pages, int *nr, gfp_t gfp_mask)
{
	pmd_t *pmd;
	unsigned long next;

	pmd = pmd_alloc_with_mask(&init_mm, pud, addr, gfp_mask);
	if (!pmd)
		return -ENOMEM;
	do {
		next = pmd_addr_end(addr, end);
		if (vmap_pte_range(pmd, addr, next, prot, pages, nr, gfp_mask))
			return -ENOMEM;
	} while (pmd++, addr = next, addr != end);
	return 0;
}

static int vmap_pud_range(pgd_t *pgd, unsigned long addr, unsigned long end, 
		pgprot_t prot, struct page **pages, int *nr, gfp_t gfp_mask)
{
	pud_t *pud;
	unsigned long next;

	pud = pud_alloc_with_mask(&init_mm, pgd, addr, gfp_mask);
	if (!pud)
		return -ENOMEM;
	do {
		next = pud_addr_end(addr, end);
		if (vmap_pmd_range(pud, addr, next, prot, pages, nr, gfp_mask))
			return -ENOMEM;
	} while (pud++, addr = next, addr != end);
	return 0;

 *
 * Ie. pte at addr+N*PAGE_SIZE shall point to pfn corresponding to pages[N]
 */
static int __vmap_page_range_noflush(unsigned long start, unsigned long end,
				   pgprot_t prot, struct page **pages, gfp_t gfp_mask)
{
	pgd_t *pgd;
	unsigned long next;

	pgd = pgd_offset_k(addr);
	do {
		next = pgd_addr_end(addr, end);
		err = vmap_pud_range(pgd, addr, next, prot, pages, &nr, gfp_mask);
		if (err)
			return err;
	} while (pgd++, addr = next, addr != end);

	return nr;
}


static int vmap_page_range_noflush(unsigned long start, unsigned long end,
				   pgprot_t prot, struct page **pages)
{
	return __vmap_page_range_noflush(start, end, prot, pages, GFP_KERNEL);
}

static int __vmap_page_range(unsigned long start, unsigned long end,
			   pgprot_t prot, struct page **pages, gfp_t gfp_mask)
{
	int ret;

	ret = __vmap_page_range_noflush(start, end, prot, pages, gfp_mask);
	flush_cache_vmap(start, end);
	return ret;
}

static int vmap_page_range(unsigned long start, unsigned long end,
			   pgprot_t prot, struct page **pages)
{
	return __vmap_page_range(start, end, prot, pages, GFP_KERNEL);
}

int is_vmalloc_or_module_addr(const void *x)
{
	/*

	flush_tlb_kernel_range(addr, end);
}

int __map_vm_area(struct vm_struct *area, pgprot_t prot, 
		struct page ***pages, gfp_t gfp_mask)
{
	unsigned long addr = (unsigned long)area->addr;
	unsigned long end = addr + area->size - PAGE_SIZE;
	int err;

	err = __vmap_page_range(addr, end, prot, *pages, gfp_mask);
	if (err > 0) {
		*pages += err;
		err = 0;


	return err;
}

int map_vm_area(struct vm_struct *area, pgprot_t prot, struct page ***pages)
{
	return __map_vm_area(area, prot, pages, GFP_KERNEL);
}
EXPORT_SYMBOL_GPL(map_vm_area);

/*** Old vmalloc interfaces ***/

		area->pages[i] = page;
	}

	if (__map_vm_area(area, prot, &pages, gfp_mask))
		goto fail;
	return area->addr;


Return to bug 416685

Lines 236-248 unsigned long iopa(unsigned long addr) Link Here

(-)a/arch/microblaze/mm/pgtable.c (-4 / +9 lines)
236	return pa;	236	return pa;
237	}	237	}
238		238
239	__init_refok pte_t pte_alloc_one_kernel(struct mm_struct mm,	239	__init_refok pte_t __pte_alloc_one_kernel(struct mm_struct mm,
240	unsigned long address)	240	unsigned long address, gfp_t gfp_mask)
241	{	241	{
242	pte_t *pte;	242	pte_t *pte;
243	if (mem_init_done) {	243	if (mem_init_done) {
244	pte = (pte_t *)__get_free_page(GFP_KERNEL \|	244	pte = (pte_t *)__get_free_page(gfp_mask \| __GFP_ZERO);
245	__GFP_REPEAT \| __GFP_ZERO);
246	} else {	245	} else {
247	pte = (pte_t *)early_get_page();	246	pte = (pte_t *)early_get_page();
248	if (pte)	247	if (pte)
Lines 260-262 void __set_fixmap(enum fixed_addresses idx, phys_addr_t phys, pgprot_t flags) Link Here
260		259
261	map_page(address, phys, pgprot_val(flags));	260	map_page(address, phys, pgprot_val(flags));
262	}	261	}
		262
		263	__init_refok pte_t pte_alloc_one_kernel(struct mm_struct mm,
		264	unsigned long address)
		265	{
		266	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
		267	}

Lines 1149-1192 static inline pte_t get_locked_pte(struct mm_struct mm, unsigned long addr, Link Here

(-)a/include/linux/mm.h (-10 / +30 lines)
1149		1149
1150	#ifdef __PAGETABLE_PUD_FOLDED	1150	#ifdef __PAGETABLE_PUD_FOLDED
1151	static inline int __pud_alloc(struct mm_struct mm, pgd_t pgd,	1151	static inline int __pud_alloc(struct mm_struct mm, pgd_t pgd,
1152	unsigned long address)	1152	unsigned long address, gfp_t gfp_mask)
1153	{	1153	{
1154	return 0;	1154	return 0;
1155	}	1155	}
1156	#else	1156	#else
1157	int __pud_alloc(struct mm_struct mm, pgd_t pgd, unsigned long address);	1157	int __pud_alloc(struct mm_struct mm, pgd_t pgd, unsigned long address,
		1158	gfp_t gfp_mask);
1158	#endif	1159	#endif
1159		1160
1160	#ifdef __PAGETABLE_PMD_FOLDED	1161	#ifdef __PAGETABLE_PMD_FOLDED
1161	static inline int __pmd_alloc(struct mm_struct mm, pud_t pud,	1162	static inline int __pmd_alloc(struct mm_struct mm, pud_t pud,
1162	unsigned long address)	1163	unsigned long address, gfp_t gfp_mask)
1163	{	1164	{
1164	return 0;	1165	return 0;
1165	}	1166	}
1166	#else	1167	#else
1167	int __pmd_alloc(struct mm_struct mm, pud_t pud, unsigned long address);	1168	int __pmd_alloc(struct mm_struct mm, pud_t pud, unsigned long address,
		1169	gfp_t gfp_mask);
1168	#endif	1170	#endif
1169		1171
1170	int __pte_alloc(struct mm_struct mm, struct vm_area_struct vma,	1172	int __pte_alloc(struct mm_struct mm, struct vm_area_struct vma,
1171	pmd_t *pmd, unsigned long address);	1173	pmd_t *pmd, unsigned long address);
1172	int __pte_alloc_kernel(pmd_t *pmd, unsigned long address);	1174	int __pte_alloc_kernel(pmd_t *pmd, unsigned long address, gfp_t gfp_mask);
1173		1175
1174	/*	1176	/*
1175	* The following ifdef needed to get the 4level-fixup.h header to work.	1177	* The following ifdef needed to get the 4level-fixup.h header to work.
1176	* Remove it when 4level-fixup.h has been removed.	1178	* Remove it when 4level-fixup.h has been removed.
1177	*/	1179	*/
1178	#if defined(CONFIG_MMU) && !defined(__ARCH_HAS_4LEVEL_HACK)	1180	#if defined(CONFIG_MMU) && !defined(__ARCH_HAS_4LEVEL_HACK)
1179	static inline pud_t pud_alloc(struct mm_struct mm, pgd_t *pgd, unsigned long address)	1181	static inline pud_t pud_alloc_with_mask(struct mm_struct mm, pgd_t *pgd,
		1182	unsigned long address, gfp_t gfp_mask)
1180	{	1183	{
1181	return (unlikely(pgd_none(*pgd)) && __pud_alloc(mm, pgd, address))?	1184	return (unlikely(pgd_none(*pgd)) && __pud_alloc(mm, pgd, address, gfp_mask))?
1182	NULL: pud_offset(pgd, address);	1185	NULL: pud_offset(pgd, address);
1183	}	1186	}
1184		1187
1185	static inline pmd_t pmd_alloc(struct mm_struct mm, pud_t *pud, unsigned long address)	1188	static inline pud_t pud_alloc(struct mm_struct mm, pgd_t *pgd,
		1189	unsigned long address)
1186	{	1190	{
1187	return (unlikely(pud_none(*pud)) && __pmd_alloc(mm, pud, address))?	1191	return pud_alloc_with_mask(mm, pgd, address, GFP_KERNEL);
		1192	}
		1193
		1194	static inline pmd_t pmd_alloc_with_mask(struct mm_struct mm, pud_t *pud,
		1195	unsigned long address, gfp_t gfp_mask)
		1196	{
		1197	return (unlikely(pud_none(*pud)) && __pmd_alloc(mm, pud, address, gfp_mask))?
1188	NULL: pmd_offset(pud, address);	1198	NULL: pmd_offset(pud, address);
1189	}	1199	}
		1200
		1201	static inline pmd_t pmd_alloc(struct mm_struct mm, pud_t *pud,
		1202	unsigned long address)
		1203	{
		1204	return pmd_alloc_with_mask(mm, pud, address, GFP_KERNEL);
		1205	}
1190	#endif /* CONFIG_MMU && !__ARCH_HAS_4LEVEL_HACK */	1206	#endif /* CONFIG_MMU && !__ARCH_HAS_4LEVEL_HACK */
1191		1207
1192	#if USE_SPLIT_PTLOCKS	1208	#if USE_SPLIT_PTLOCKS
Lines 1247-1254 static inline void pgtable_page_dtor(struct page *page) Link Here
1247	pmd, address))? \	1263	pmd, address))? \
1248	NULL: pte_offset_map_lock(mm, pmd, address, ptlp))	1264	NULL: pte_offset_map_lock(mm, pmd, address, ptlp))
1249		1265
		1266	#define pte_alloc_kernel_with_mask(pmd, address, mask) \
		1267	((unlikely(pmd_none(*(pmd))) && __pte_alloc_kernel(pmd, address, mask))? \
		1268	NULL: pte_offset_kernel(pmd, address))
		1269
1250	#define pte_alloc_kernel(pmd, address) \	1270	#define pte_alloc_kernel(pmd, address) \
1251	((unlikely(pmd_none(*(pmd))) && __pte_alloc_kernel(pmd, address))? \	1271	((unlikely(pmd_none(*(pmd))) && __pte_alloc_kernel(pmd, address, GFP_KERNEL))? \
1252	NULL: pte_offset_kernel(pmd, address))	1272	NULL: pte_offset_kernel(pmd, address))
1253		1273
1254	extern void free_area_init(unsigned long * zones_size);	1274	extern void free_area_init(unsigned long * zones_size);

Lines 608-616 int __pte_alloc(struct mm_struct mm, struct vm_area_struct vma, Link Here

(-)a/mm/memory.c (-6 / +8 lines)
608	return 0;	608	return 0;
609	}	609	}
610		610
611	int __pte_alloc_kernel(pmd_t *pmd, unsigned long address)	611	int __pte_alloc_kernel(pmd_t *pmd, unsigned long address, gfp_t gfp_mask)
612	{	612	{
613	pte_t *new = pte_alloc_one_kernel(&init_mm, address);	613	pte_t *new = __pte_alloc_one_kernel(&init_mm, address, gfp_mask);
614	if (!new)	614	if (!new)
615	return -ENOMEM;	615	return -ENOMEM;
616		616
Lines 3548-3556 retry: Link Here
3548	* Allocate page upper directory.	3548	* Allocate page upper directory.
3549	* We've already handled the fast-path in-line.	3549	* We've already handled the fast-path in-line.
3550	*/	3550	*/
3551	int __pud_alloc(struct mm_struct mm, pgd_t pgd, unsigned long address)	3551	int __pud_alloc(struct mm_struct mm, pgd_t pgd, unsigned long address,
		3552	gfp_t gfp_mask)
3552	{	3553	{
3553	pud_t *new = pud_alloc_one(mm, address);	3554	pud_t *new = __pud_alloc_one(mm, address, gfp_mask);
3554	if (!new)	3555	if (!new)
3555	return -ENOMEM;	3556	return -ENOMEM;
3556		3557
Lines 3571-3579 int __pud_alloc(struct mm_struct mm, pgd_t pgd, unsigned long address) Link Here
3571	* Allocate page middle directory.	3572	* Allocate page middle directory.
3572	* We've already handled the fast-path in-line.	3573	* We've already handled the fast-path in-line.
3573	*/	3574	*/
3574	int __pmd_alloc(struct mm_struct mm, pud_t pud, unsigned long address)	3575	int __pmd_alloc(struct mm_struct mm, pud_t pud, unsigned long address,
		3576	gfp_t gfp_mask)
3575	{	3577	{
3576	pmd_t *new = pmd_alloc_one(mm, address);	3578	pmd_t *new = __pmd_alloc_one(mm, address, gfp_mask);
3577	if (!new)	3579	if (!new)
3578	return -ENOMEM;	3580	return -ENOMEM;
3579		3581

Lines 48-53 static inline void pud_populate(struct mm_struct mm, pud_t pud, pmd_t *pmd) Link Here

(-)a/arch/arm/include/asm/pgalloc.h (-2 / +9 lines)
48	/*	48	/*
49	* Since we have only two-level page tables, these are trivial	49	* Since we have only two-level page tables, these are trivial
50	*/	50	*/
		51	#define __pmd_alloc_one(mm,addr,mask) ({ BUG(); ((pmd_t *)2); })
51	#define pmd_alloc_one(mm,addr) ({ BUG(); ((pmd_t *)2); })	52	#define pmd_alloc_one(mm,addr) ({ BUG(); ((pmd_t *)2); })
52	#define pmd_free(mm, pmd) do { } while (0)	53	#define pmd_free(mm, pmd) do { } while (0)
53	#define pud_populate(mm,pmd,pte) BUG()	54	#define pud_populate(mm,pmd,pte) BUG()
Lines 81-97 static inline void clean_pte_table(pte_t *pte) Link Here
81	* +------------+	82	* +------------+
82	*/	83	*/
83	static inline pte_t *	84	static inline pte_t *
84	pte_alloc_one_kernel(struct mm_struct *mm, unsigned long addr)	85	__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long addr, gfp_t gfp_mask)
85	{	86	{
86	pte_t *pte;	87	pte_t *pte;
87		88
88	pte = (pte_t *)__get_free_page(PGALLOC_GFP);	89	pte = (pte_t *)__get_free_page(gfp_mask \| __GFP_NOTRACK \| __GFP_ZERO);
89	if (pte)	90	if (pte)
90	clean_pte_table(pte);	91	clean_pte_table(pte);
91		92
92	return pte;	93	return pte;
93	}	94	}
94		95
		96	static inline pte_t *
		97	pte_alloc_one_kernel(struct mm_struct *mm, unsigned long addr)
		98	{
		99	return __pte_alloc_one_kernel(mm, addr, GFP_KERNEL \| __GFP_REPEAT);
		100	}
		101
95	static inline pgtable_t	102	static inline pgtable_t
96	pte_alloc_one(struct mm_struct *mm, unsigned long addr)	103	pte_alloc_one(struct mm_struct *mm, unsigned long addr)
97	{	104	{

Lines 51-60 static inline void pgd_free(struct mm_struct mm, pgd_t pgd) Link Here

(-)a/arch/avr32/include/asm/pgalloc.h (-1 / +7 lines)
51	quicklist_free(QUICK_PGD, NULL, pgd);	51	quicklist_free(QUICK_PGD, NULL, pgd);
52	}	52	}
53		53
		54	static inline pte_t __pte_alloc_one_kernel(struct mm_struct mm,
		55	unsigned long address, gfp_t gfp_mask)
		56	{
		57	return quicklist_alloc(QUICK_PT, gfp_mask, NULL);
		58	}
		59
54	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,	60	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,
55	unsigned long address)	61	unsigned long address)
56	{	62	{
57	return quicklist_alloc(QUICK_PT, GFP_KERNEL \| __GFP_REPEAT, NULL);	63	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
58	}	64	}
59		65
60	static inline pgtable_t pte_alloc_one(struct mm_struct *mm,	66	static inline pgtable_t pte_alloc_one(struct mm_struct *mm,

Lines 22-31 static inline void pgd_free(struct mm_struct mm, pgd_t pgd) Link Here

(-)a/arch/cris/include/asm/pgalloc.h (-2 / +8 lines)
22	free_page((unsigned long)pgd);	22	free_page((unsigned long)pgd);
23	}	23	}
24		24
		25	static inline pte_t *
		26	__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address,
		27	gfp_t gfp_mask)
		28	{
		29	return (pte_t *) __get_free_page(gfp_mask \| __GFP_ZERO);
		30	}
		31
25	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long address)	32	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long address)
26	{	33	{
27	pte_t pte = (pte_t )__get_free_page(GFP_KERNEL\|__GFP_REPEAT\|__GFP_ZERO);	34	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
28	return pte;
29	}	35	}
30		36
31	static inline pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)	37	static inline pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)

Lines 35-42 extern pgd_t pgd_alloc(struct mm_struct ); Link Here

(-)a/arch/frv/include/asm/pgalloc.h (+3 lines)
35	extern void pgd_free(struct mm_struct mm, pgd_t );	35	extern void pgd_free(struct mm_struct mm, pgd_t );
36		36
37	extern pte_t pte_alloc_one_kernel(struct mm_struct , unsigned long);	37	extern pte_t pte_alloc_one_kernel(struct mm_struct , unsigned long);
		38	extern pte_t __pte_alloc_one_kernel(struct mm_struct , unsigned long, gfp_t);
38		39
39	extern pgtable_t pte_alloc_one(struct mm_struct *, unsigned long);	40	extern pgtable_t pte_alloc_one(struct mm_struct *, unsigned long);
		41	extern pgtable_t __pte_alloc_one(struct mm_struct *, unsigned long, gfp_t);
40		42
41	static inline void pte_free_kernel(struct mm_struct mm, pte_t pte)	43	static inline void pte_free_kernel(struct mm_struct mm, pte_t pte)
42	{	44	{
Lines 60-65 do { \ Link Here
60	* inside the pgd, so has no extra memory associated with it.	62	* inside the pgd, so has no extra memory associated with it.
61	* (In the PAE case we free the pmds as part of the pgd.)	63	* (In the PAE case we free the pmds as part of the pgd.)
62	*/	64	*/
		65	#define __pmd_alloc_one(mm, addr,mask) ({ BUG(); ((pmd_t *) 2); })
63	#define pmd_alloc_one(mm, addr) ({ BUG(); ((pmd_t *) 2); })	66	#define pmd_alloc_one(mm, addr) ({ BUG(); ((pmd_t *) 2); })
64	#define pmd_free(mm, x) do { } while (0)	67	#define pmd_free(mm, x) do { } while (0)
65	#define __pmd_free_tlb(tlb,x,a) do { } while (0)	68	#define __pmd_free_tlb(tlb,x,a) do { } while (0)

Lines 20-33 Link Here

(-)a/arch/frv/mm/pgalloc.c (-2 / +7 lines)
20		20
21	pgd_t swapper_pg_dir[PTRS_PER_PGD] __attribute__((aligned(PAGE_SIZE)));	21	pgd_t swapper_pg_dir[PTRS_PER_PGD] __attribute__((aligned(PAGE_SIZE)));
22		22
23	pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long address)	23	pte_t __pte_alloc_one_kernel(struct mm_struct mm, unsigned long address, gfp_t gfp_mask)
24	{	24	{
25	pte_t pte = (pte_t )__get_free_page(GFP_KERNEL\|__GFP_REPEAT);	25	pte_t pte = (pte_t )__get_free_page(gfp_mask);
26	if (pte)	26	if (pte)
27	clear_page(pte);	27	clear_page(pte);
28	return pte;	28	return pte;
29	}	29	}
30		30
		31	pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long address)
		32	{
		33	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
		34	}
		35
31	pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)	36	pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)
32	{	37	{
33	struct page *page;	38	struct page *page;

Lines 30-41 static inline void pgd_free(struct mm_struct mm, pgd_t pgd) Link Here

(-)a/arch/m32r/include/asm/pgalloc.h (-3 / +8 lines)
30	free_page((unsigned long)pgd);	30	free_page((unsigned long)pgd);
31	}	31	}
32		32
		33	static __inline__ pte_t __pte_alloc_one_kernel(struct mm_struct mm,
		34	unsigned long address, gfp_t gfp_mask)
		35	{
		36	return (pte_t *)__get_free_page(gfp_mask \| __GFP_ZERO);
		37	}
		38
33	static __inline__ pte_t pte_alloc_one_kernel(struct mm_struct mm,	39	static __inline__ pte_t pte_alloc_one_kernel(struct mm_struct mm,
34	unsigned long address)	40	unsigned long address)
35	{	41	{
36	pte_t pte = (pte_t )__get_free_page(GFP_KERNEL\|__GFP_ZERO);	42	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL);
37
38	return pte;
39	}	43	}
40		44
41	static __inline__ pgtable_t pte_alloc_one(struct mm_struct *mm,	45	static __inline__ pgtable_t pte_alloc_one(struct mm_struct *mm,
Lines 66-71 static inline void pte_free(struct mm_struct *mm, pgtable_t pte) Link Here
66	* (In the PAE case we free the pmds as part of the pgd.)	70	* (In the PAE case we free the pmds as part of the pgd.)
67	*/	71	*/
68		72
		73	#define __pmd_alloc_one(mm, addr,mask) ({ BUG(); ((pmd_t *)2); })
69	#define pmd_alloc_one(mm, addr) ({ BUG(); ((pmd_t *)2); })	74	#define pmd_alloc_one(mm, addr) ({ BUG(); ((pmd_t *)2); })
70	#define pmd_free(mm, x) do { } while (0)	75	#define pmd_free(mm, x) do { } while (0)
71	#define __pmd_free_tlb(tlb, x, addr) do { } while (0)	76	#define __pmd_free_tlb(tlb, x, addr) do { } while (0)

Lines 18-23 Link Here

(-)a/arch/m68k/include/asm/sun3_pgalloc.h (-3 / +11 lines)
18		18
19	extern const char bad_pmd_string[];	19	extern const char bad_pmd_string[];
20		20
		21	#define __pmd_alloc_one(mm,address,mask) ({ BUG(); ((pmd_t *)2); })
21	#define pmd_alloc_one(mm,address) ({ BUG(); ((pmd_t *)2); })	22	#define pmd_alloc_one(mm,address) ({ BUG(); ((pmd_t *)2); })
22		23
23		24
Lines 38-47 do { \ Link Here
38	tlb_remove_page((tlb), pte); \	39	tlb_remove_page((tlb), pte); \
39	} while (0)	40	} while (0)
40		41
41	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,	42	static inline pte_t *
42	unsigned long address)	43	__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address,
		44	gfp_t gfp_mask)
43	{	45	{
44	unsigned long page = __get_free_page(GFP_KERNEL\|__GFP_REPEAT);	46	unsigned long page = __get_free_page(gfp_mask);
45		47
46	if (!page)	48	if (!page)
47	return NULL;	49	return NULL;
Lines 50-55 static inline pte_t pte_alloc_one_kernel(struct mm_struct mm, Link Here
50	return (pte_t *) (page);	52	return (pte_t *) (page);
51	}	53	}
52		54
		55	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,
		56	unsigned long address)
		57	{
		58	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
		59	}
		60
53	static inline pgtable_t pte_alloc_one(struct mm_struct *mm,	61	static inline pgtable_t pte_alloc_one(struct mm_struct *mm,
54	unsigned long address)	62	unsigned long address)
55	{	63	{

Lines 106-114 extern inline void free_pgd_slow(pgd_t *pgd) Link Here

(-)a/arch/microblaze/include/asm/pgalloc.h (+3 lines)
106	* the pgd will always be present..	106	* the pgd will always be present..
107	*/	107	*/
108	#define pmd_alloc_one_fast(mm, address) ({ BUG(); ((pmd_t *)1); })	108	#define pmd_alloc_one_fast(mm, address) ({ BUG(); ((pmd_t *)1); })
		109	#define __pmd_alloc_one(mm, address,mask) ({ BUG(); ((pmd_t *)2); })
109	#define pmd_alloc_one(mm, address) ({ BUG(); ((pmd_t *)2); })	110	#define pmd_alloc_one(mm, address) ({ BUG(); ((pmd_t *)2); })
110		111
111	extern pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long addr);	112	extern pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long addr);
		113	extern pte_t __pte_alloc_one_kernel(struct mm_struct , unsigned long, gfp_t);
112		114
113	static inline struct page pte_alloc_one(struct mm_struct mm,	115	static inline struct page pte_alloc_one(struct mm_struct mm,
114	unsigned long address)	116	unsigned long address)
Lines 175-180 extern inline void pte_free(struct mm_struct mm, struct page ptepage) Link Here
175	* We don't have any real pmd's, and this code never triggers because	177	* We don't have any real pmd's, and this code never triggers because
176	* the pgd will always be present..	178	* the pgd will always be present..
177	*/	179	*/
		180	#define __pmd_alloc_one(mm, address,mask) ({ BUG(); ((pmd_t *)2); })
178	#define pmd_alloc_one(mm, address) ({ BUG(); ((pmd_t *)2); })	181	#define pmd_alloc_one(mm, address) ({ BUG(); ((pmd_t *)2); })
179	#define pmd_free(mm, x) do { } while (0)	182	#define pmd_free(mm, x) do { } while (0)
180	#define __pmd_free_tlb(tlb, x, addr) pmd_free((tlb)->mm, x)	183	#define __pmd_free_tlb(tlb, x, addr) pmd_free((tlb)->mm, x)

Lines 64-77 static inline void pgd_free(struct mm_struct mm, pgd_t pgd) Link Here

(-)a/arch/mips/include/asm/pgalloc.h (-7 / +15 lines)
64	free_pages((unsigned long)pgd, PGD_ORDER);	64	free_pages((unsigned long)pgd, PGD_ORDER);
65	}	65	}
66		66
		67	static inline pte_t __pte_alloc_one_kernel(struct mm_struct mm,
		68	unsigned long address, gfp_t gfp_mask)
		69	{
		70	return (pte_t *) __get_free_pages(gfp_mask \| __GFP_ZERO, PTE_ORDER);
		71	}
		72
67	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,	73	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,
68	unsigned long address)	74	unsigned long address)
69	{	75	{
70	pte_t *pte;	76	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
71
72	pte = (pte_t *) __get_free_pages(GFP_KERNEL\|__GFP_REPEAT\|__GFP_ZERO, PTE_ORDER);
73
74	return pte;
75	}	77	}
76		78
77	static inline struct page pte_alloc_one(struct mm_struct mm,	79	static inline struct page pte_alloc_one(struct mm_struct mm,
Lines 106-121 do { \ Link Here
106		108
107	#ifndef __PAGETABLE_PMD_FOLDED	109	#ifndef __PAGETABLE_PMD_FOLDED
108		110
109	static inline pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long address)	111	static inline pmd_t *
		112	__pmd_alloc_one(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
110	{	113	{
111	pmd_t *pmd;	114	pmd_t *pmd;
112		115
113	pmd = (pmd_t *) __get_free_pages(GFP_KERNEL\|__GFP_REPEAT, PMD_ORDER);	116	pmd = (pmd_t *) __get_free_pages(gfp_mask, PMD_ORDER);
114	if (pmd)	117	if (pmd)
115	pmd_init((unsigned long)pmd, (unsigned long)invalid_pte_table);	118	pmd_init((unsigned long)pmd, (unsigned long)invalid_pte_table);
116	return pmd;	119	return pmd;
117	}	120	}
118		121
		122	static inline pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long address)
		123	{
		124	return __pmd_alloc_one(mm, address, GFP_KERNEL \| __GFP_REPEAT);
		125	}
		126
119	static inline void pmd_free(struct mm_struct mm, pmd_t pmd)	127	static inline void pmd_free(struct mm_struct mm, pmd_t pmd)
120	{	128	{
121	free_pages((unsigned long)pmd, PMD_ORDER);	129	free_pages((unsigned long)pmd, PMD_ORDER);

Lines 61-74 void set_pmd_pfn(unsigned long vaddr, unsigned long pfn, pgprot_t flags) Link Here

(-)a/arch/mn10300/mm/pgtable.c (-2 / +8 lines)
61	local_flush_tlb_one(vaddr);	61	local_flush_tlb_one(vaddr);
62	}	62	}
63		63
64	pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long address)	64	pte_t __pte_alloc_one_kernel(struct mm_struct mm, unsigned long address,
		65	gfp_t gfp_mask)
65	{	66	{
66	pte_t pte = (pte_t )__get_free_page(GFP_KERNEL\|__GFP_REPEAT);	67	pte_t pte = (pte_t )__get_free_page(gfp_mask);
67	if (pte)	68	if (pte)
68	clear_page(pte);	69	clear_page(pte);
69	return pte;	70	return pte;
70	}	71	}
71		72
		73	pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long address)
		74	{
		75	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
		76	}
		77
72	struct page pte_alloc_one(struct mm_struct mm, unsigned long address)	78	struct page pte_alloc_one(struct mm_struct mm, unsigned long address)
73	{	79	{
74	struct page *pte;	80	struct page *pte;

Lines 61-75 static inline void pgd_populate(struct mm_struct mm, pgd_t pgd, pmd_t *pmd) Link Here

(-)a/arch/parisc/include/asm/pgalloc.h (-5 / +16 lines)
61	(__u32)(__pa((unsigned long)pmd) >> PxD_VALUE_SHIFT));	61	(__u32)(__pa((unsigned long)pmd) >> PxD_VALUE_SHIFT));
62	}	62	}
63		63
64	static inline pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long address)	64	static inline pmd_t *
		65	__pmd_alloc_one(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
65	{	66	{
66	pmd_t pmd = (pmd_t )__get_free_pages(GFP_KERNEL\|__GFP_REPEAT,	67	pmd_t pmd = (pmd_t )__get_free_pages(gfp_mask, PMD_ORDER);
67	PMD_ORDER);
68	if (pmd)	68	if (pmd)
69	memset(pmd, 0, PAGE_SIZE<<PMD_ORDER);	69	memset(pmd, 0, PAGE_SIZE<<PMD_ORDER);
70	return pmd;	70	return pmd;
71	}	71	}
72		72
		73	static inline pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long address)
		74	{
		75	return __pmd_alloc_one(mm, address, GFP_KERNEL \| __GFP_REPEAT);
		76	}
		77
73	static inline void pmd_free(struct mm_struct mm, pmd_t pmd)	78	static inline void pmd_free(struct mm_struct mm, pmd_t pmd)
74	{	79	{
75	#ifdef CONFIG_64BIT	80	#ifdef CONFIG_64BIT
Lines 90-95 static inline void pmd_free(struct mm_struct mm, pmd_t pmd) Link Here
90	* inside the pgd, so has no extra memory associated with it.	95	* inside the pgd, so has no extra memory associated with it.
91	*/	96	*/
92		97
		98	#define __pmd_alloc_one(mm, addr, mask) ({ BUG(); ((pmd_t *)2); })
93	#define pmd_alloc_one(mm, addr) ({ BUG(); ((pmd_t *)2); })	99	#define pmd_alloc_one(mm, addr) ({ BUG(); ((pmd_t *)2); })
94	#define pmd_free(mm, x) do { } while (0)	100	#define pmd_free(mm, x) do { } while (0)
95	#define pgd_populate(mm, pmd, pte) BUG()	101	#define pgd_populate(mm, pmd, pte) BUG()
Lines 127-136 pte_alloc_one(struct mm_struct *mm, unsigned long address) Link Here
127	}	133	}
128		134
129	static inline pte_t *	135	static inline pte_t *
		136	__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long addr, gfp_t gfp_mask)
		137	{
		138	return (pte_t *)__get_free_page(gfp_mask \| __GFP_ZERO);
		139	}
		140
		141	static inline pte_t *
130	pte_alloc_one_kernel(struct mm_struct *mm, unsigned long addr)	142	pte_alloc_one_kernel(struct mm_struct *mm, unsigned long addr)
131	{	143	{
132	pte_t pte = (pte_t )__get_free_page(GFP_KERNEL\|__GFP_REPEAT\|__GFP_ZERO);	144	return __pte_alloc_one_kernel(mm, addr, GFP_KERNEL \| __GFP_REPEAT);
133	return pte;
134	}	145	}
135		146
136	static inline void pte_free_kernel(struct mm_struct mm, pte_t pte)	147	static inline void pte_free_kernel(struct mm_struct mm, pte_t pte)

Lines 96-109 void pgd_free(struct mm_struct mm, pgd_t pgd) Link Here

(-)a/arch/powerpc/mm/pgtable_32.c (-2 / +8 lines)
96	#endif	96	#endif
97	}	97	}
98		98
99	__init_refok pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long address)	99	__init_refok pte_t *
		100	__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
100	{	101	{
101	pte_t *pte;	102	pte_t *pte;
102	extern int mem_init_done;	103	extern int mem_init_done;
103	extern void *early_get_page(void);	104	extern void *early_get_page(void);
104		105
105	if (mem_init_done) {	106	if (mem_init_done) {
106	pte = (pte_t *)__get_free_page(GFP_KERNEL\|__GFP_REPEAT\|__GFP_ZERO);	107	pte = (pte_t *)__get_free_page(gfp_mask \| __GFP_ZERO);
107	} else {	108	} else {
108	pte = (pte_t *)early_get_page();	109	pte = (pte_t *)early_get_page();
109	if (pte)	110	if (pte)
Lines 112-117 __init_refok pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long add Link Here
112	return pte;	113	return pte;
113	}	114	}
114		115
		116	__init_refok pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long address)
		117	{
		118	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
		119	}
		120
115	pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)	121	pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)
116	{	122	{
117	struct page *ptepage;	123	struct page *ptepage;

Lines 18-26 Link Here

(-)a/arch/s390/include/asm/pgalloc.h (-5 / +25 lines)
18	#include <linux/mm.h>	18	#include <linux/mm.h>
19		19
20	unsigned long crst_table_alloc(struct mm_struct );	20	unsigned long crst_table_alloc(struct mm_struct );
		21	unsigned long * __crst_table_alloc(struct mm_struct *, int , gfp_t);
21	void crst_table_free(struct mm_struct , unsigned long );	22	void crst_table_free(struct mm_struct , unsigned long );
22		23
23	unsigned long page_table_alloc(struct mm_struct , unsigned long);	24	unsigned long page_table_alloc(struct mm_struct , unsigned long);
		25	unsigned long __page_table_alloc(struct mm_struct , gfp_t);
24	void page_table_free(struct mm_struct , unsigned long );	26	void page_table_free(struct mm_struct , unsigned long );
25	void page_table_free_rcu(struct mmu_gather , unsigned long );	27	void page_table_free_rcu(struct mmu_gather , unsigned long );
26		28
Lines 55-63 static inline unsigned long pgd_entry_type(struct mm_struct *mm) Link Here
55	return _SEGMENT_ENTRY_EMPTY;	57	return _SEGMENT_ENTRY_EMPTY;
56	}	58	}
57		59
		60	#define __pud_alloc_one(mm,address,mask) ({ BUG(); ((pud_t *)2); })
58	#define pud_alloc_one(mm,address) ({ BUG(); ((pud_t *)2); })	61	#define pud_alloc_one(mm,address) ({ BUG(); ((pud_t *)2); })
59	#define pud_free(mm, x) do { } while (0)	62	#define pud_free(mm, x) do { } while (0)
60		63
		64	#define __pmd_alloc_one(mm,address,mask) ({ BUG(); ((pmd_t *)2); })
61	#define pmd_alloc_one(mm,address) ({ BUG(); ((pmd_t *)2); })	65	#define pmd_alloc_one(mm,address) ({ BUG(); ((pmd_t *)2); })
62	#define pmd_free(mm, x) do { } while (0)	66	#define pmd_free(mm, x) do { } while (0)
63		67
Lines 78-99 static inline unsigned long pgd_entry_type(struct mm_struct *mm) Link Here
78	int crst_table_upgrade(struct mm_struct *, unsigned long limit);	82	int crst_table_upgrade(struct mm_struct *, unsigned long limit);
79	void crst_table_downgrade(struct mm_struct *, unsigned long limit);	83	void crst_table_downgrade(struct mm_struct *, unsigned long limit);
80		84
81	static inline pud_t pud_alloc_one(struct mm_struct mm, unsigned long address)	85	static inline pud_t *
		86	__pud_alloc_one(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
82	{	87	{
83	unsigned long *table = crst_table_alloc(mm);	88	unsigned long *table = __crst_table_alloc(mm, mm->context.noexec, gfp_mask);
84	if (table)	89	if (table)
85	crst_table_init(table, _REGION3_ENTRY_EMPTY);	90	crst_table_init(table, _REGION3_ENTRY_EMPTY);
86	return (pud_t *) table;	91	return (pud_t *) table;
87	}	92	}
		93
		94	static inline pud_t pud_alloc_one(struct mm_struct mm, unsigned long address)
		95	{
		96	return __pud_alloc_one(mm, address, GFP_KERNEL);
		97	}
88	#define pud_free(mm, pud) crst_table_free(mm, (unsigned long *) pud)	98	#define pud_free(mm, pud) crst_table_free(mm, (unsigned long *) pud)
89		99
90	static inline pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long vmaddr)	100	static inline pmd_t *
		101	__pmd_alloc_one(struct mm_struct *mm, unsigned long vmaddr, gfp_t gfp_mask)
91	{	102	{
92	unsigned long *table = crst_table_alloc(mm);	103	unsigned long *table = __crst_table_alloc(mm, mm->context.noexec, gfp_mask);
93	if (table)	104	if (table)
94	crst_table_init(table, _SEGMENT_ENTRY_EMPTY);	105	crst_table_init(table, _SEGMENT_ENTRY_EMPTY);
95	return (pmd_t *) table;	106	return (pmd_t *) table;
96	}	107	}
		108
		109	static inline pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long vmaddr)
		110	{
		111	return __pmd_alloc_one(mm, vmaddr, GFP_KERNEL);
		112	}
97	#define pmd_free(mm, pmd) crst_table_free(mm, (unsigned long *) pmd)	113	#define pmd_free(mm, pmd) crst_table_free(mm, (unsigned long *) pmd)
98		114
99	static inline void pgd_populate(struct mm_struct mm, pgd_t pgd, pud_t *pud)	115	static inline void pgd_populate(struct mm_struct mm, pgd_t pgd, pud_t *pud)
Lines 131-137 static inline void pmd_populate(struct mm_struct *mm, Link Here
131	/*	147	/*
132	* page table entry allocation/free routines.	148	* page table entry allocation/free routines.
133	*/	149	*/
134	#define pte_alloc_one_kernel(mm, vmaddr) ((pte_t *) page_table_alloc(mm, vmaddr))	150	#define __pte_alloc_one_kernel(mm, vmaddr, mask) \
		151	((pte_t *) __page_table_alloc((mm), (mask)))
		152	#define pte_alloc_one_kernel(mm, vmaddr) \
		153	((pte_t *) __pte_alloc_one_kernel((mm), (vmaddr), GFP_KERNEL\|__GFP_REPEAT)
		154
135	#define pte_alloc_one(mm, vmaddr) ((pte_t *) page_table_alloc(mm, vmaddr))	155	#define pte_alloc_one(mm, vmaddr) ((pte_t *) page_table_alloc(mm, vmaddr))
136		156
137	#define pte_free_kernel(mm, pte) page_table_free(mm, (unsigned long *) pte)	157	#define pte_free_kernel(mm, pte) page_table_free(mm, (unsigned long *) pte)

Lines 33-47 Link Here

(-)a/arch/s390/mm/pgtable.c (-4 / +15 lines)
33	#endif	33	#endif
34		34
35		35
36	unsigned long crst_table_alloc(struct mm_struct mm)	36	unsigned long *
		37	__crst_table_alloc(struct mm_struct *mm, int noexec, gfp_t gfp_mask)
37	{	38	{
38	struct page *page = alloc_pages(GFP_KERNEL, ALLOC_ORDER);	39	struct page *page = alloc_pages(gfp_mask, ALLOC_ORDER);
39		40
40	if (!page)	41	if (!page)
41	return NULL;	42	return NULL;
42	return (unsigned long *) page_to_phys(page);	43	return (unsigned long *) page_to_phys(page);
43	}	44	}
44		45
		46	unsigned long crst_table_alloc(struct mm_struct mm, int noexec)
		47	{
		48	return __crst_table_alloc(mm, noexec, GFP_KERNEL);
		49	}
		50
45	void crst_table_free(struct mm_struct mm, unsigned long table)	51	void crst_table_free(struct mm_struct mm, unsigned long table)
46	{	52	{
47	free_pages((unsigned long) table, ALLOC_ORDER);	53	free_pages((unsigned long) table, ALLOC_ORDER);
Lines 612-618 static inline unsigned int atomic_xor_bits(atomic_t *v, unsigned int bits) Link Here
612	/*	618	/*
613	* page table entry allocation/free routines.	619	* page table entry allocation/free routines.
614	*/	620	*/
615	unsigned long page_table_alloc(struct mm_struct mm, unsigned long vmaddr)	621	unsigned long __page_table_alloc(struct mm_struct mm, gfp_t gfp_mask)
616	{	622	{
617	struct page *page;	623	struct page *page;
618	unsigned long *table;	624	unsigned long *table;
Lines 632-638 unsigned long page_table_alloc(struct mm_struct mm, unsigned long vmaddr) Link Here
632	}	638	}
633	if ((mask & FRAG_MASK) == FRAG_MASK) {	639	if ((mask & FRAG_MASK) == FRAG_MASK) {
634	spin_unlock_bh(&mm->context.list_lock);	640	spin_unlock_bh(&mm->context.list_lock);
635	page = alloc_page(GFP_KERNEL\|__GFP_REPEAT);	641	page = alloc_page(gfp_mask);
636	if (!page)	642	if (!page)
637	return NULL;	643	return NULL;
638	pgtable_page_ctor(page);	644	pgtable_page_ctor(page);
Lines 652-657 unsigned long page_table_alloc(struct mm_struct mm, unsigned long vmaddr) Link Here
652	return table;	658	return table;
653	}	659	}
654		660
		661	unsigned long page_table_alloc(struct mm_struct mm)
		662	{
		663	return __page_table_alloc(mm, GFP_KERNEL \| __GFP_REPEAT);
		664	}
		665
655	void page_table_free(struct mm_struct mm, unsigned long table)	666	void page_table_free(struct mm_struct mm, unsigned long table)
656	{	667	{
657	struct page *page;	668	struct page *page;

Lines 37-51 static inline void pgd_free(struct mm_struct mm, pgd_t pgd) Link Here

(-)a/arch/score/include/asm/pgalloc.h (-6 / +7 lines)
37	free_pages((unsigned long)pgd, PGD_ORDER);	37	free_pages((unsigned long)pgd, PGD_ORDER);
38	}	38	}
39		39
		40	static inline pte_t *
		41	__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
		42	{
		43	return (pte_t *) __get_free_pages(gfp_mask \| __GFP_ZERO, PTE_ORDER);
		44	}
		45
40	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,	46	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,
41	unsigned long address)	47	unsigned long address)
42	{	48	{
43	pte_t *pte;	49	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
44
45	pte = (pte_t *) __get_free_pages(GFP_KERNEL\|__GFP_REPEAT\|__GFP_ZERO,
46	PTE_ORDER);
47
48	return pte;
49	}	50	}
50		51
51	static inline struct page pte_alloc_one(struct mm_struct mm,	52	static inline struct page pte_alloc_one(struct mm_struct mm,

Lines 31-40 static inline void pmd_populate(struct mm_struct mm, pmd_t pmd, Link Here

(-)a/arch/sh/include/asm/pgalloc.h (-1 / +7 lines)
31	/*	31	/*
32	* Allocate and free page tables.	32	* Allocate and free page tables.
33	*/	33	*/
		34	static inline pte_t __pte_alloc_one_kernel(struct mm_struct mm,
		35	unsigned long address, gfp_t gfp_mask)
		36	{
		37	return quicklist_alloc(QUICK_PT, gfp_mask, NULL);
		38	}
		39
34	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,	40	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,
35	unsigned long address)	41	unsigned long address)
36	{	42	{
37	return quicklist_alloc(QUICK_PT, GFP_KERNEL \| __GFP_REPEAT, NULL);	43	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
38	}	44	}
39		45
40	static inline pgtable_t pte_alloc_one(struct mm_struct *mm,	46	static inline pgtable_t pte_alloc_one(struct mm_struct *mm,

Lines 86-94 static inline void pte_free(struct mm_struct mm, struct page pte) Link Here

(-)a/arch/tile/include/asm/pgalloc.h (-1 / +8 lines)
86	#define pmd_pgtable(pmd) pmd_page(pmd)	86	#define pmd_pgtable(pmd) pmd_page(pmd)
87		87
88	static inline pte_t *	88	static inline pte_t *
		89	__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address,
		90	gfp_t gfp_mask)
		91	{
		92	return pfn_to_kaddr(page_to_pfn(__pte_alloc_one(mm, address, gfp_mask)));
		93	}
		94
		95	static inline pte_t *
89	pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)	96	pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
90	{	97	{
91	return pfn_to_kaddr(page_to_pfn(pte_alloc_one(mm, address)));	98	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
92	}	99	}
93		100
94	static inline void pte_free_kernel(struct mm_struct mm, pte_t pte)	101	static inline void pte_free_kernel(struct mm_struct mm, pte_t pte)

Lines 286-297 void pgd_free(struct mm_struct mm, pgd_t pgd) Link Here

(-)a/arch/um/kernel/mem.c (-6 / +15 lines)
286	free_page((unsigned long) pgd);	286	free_page((unsigned long) pgd);
287	}	287	}
288		288
289	pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long address)	289	pte_t *
		290	__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
290	{	291	{
291	pte_t *pte;	292	return (pte_t *)__get_free_page(gfp_mask \| __GFP_ZERO);
		293	}
292		294
293	pte = (pte_t *)__get_free_page(GFP_KERNEL\|__GFP_REPEAT\|__GFP_ZERO);	295	pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long address)
294	return pte;	296	{
		297	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
295	}	298	}
296		299
297	pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)	300	pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)
Lines 305-319 pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address) Link Here
305	}	308	}
306		309
307	#ifdef CONFIG_3_LEVEL_PGTABLES	310	#ifdef CONFIG_3_LEVEL_PGTABLES
308	pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long address)	311	pmd_t *
		312	__pmd_alloc_one(struct mm_struct *mm, unsigned long address, gfp_t gfp_mask)
309	{	313	{
310	pmd_t pmd = (pmd_t ) __get_free_page(GFP_KERNEL);	314	pmd_t pmd = (pmd_t ) __get_free_page(gfp_mask);
311		315
312	if (pmd)	316	if (pmd)
313	memset(pmd, 0, PAGE_SIZE);	317	memset(pmd, 0, PAGE_SIZE);
314		318
315	return pmd;	319	return pmd;
316	}	320	}
		321
		322	pmd_t pmd_alloc_one(struct mm_struct mm, unsigned long address)
		323	{
		324	return __pmd_alloc_one(mm, address, GFP_KERNEL);
		325	}
317	#endif	326	#endif
318		327
319	void *uml_kmalloc(int size, int flags)	328	void *uml_kmalloc(int size, int flags)

Lines 42-51 static inline void pgd_free(struct mm_struct mm, pgd_t pgd) Link Here

(-)a/arch/xtensa/include/asm/pgalloc.h (-1 / +8 lines)
42		42
43	extern struct kmem_cache *pgtable_cache;	43	extern struct kmem_cache *pgtable_cache;
44		44
		45	static inline pte_t *
		46	__pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address,
		47	gfp_t gfp_mask)
		48	{
		49	return kmem_cache_alloc(pgtable_cache, gfp_mask);
		50	}
		51
45	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,	52	static inline pte_t pte_alloc_one_kernel(struct mm_struct mm,
46	unsigned long address)	53	unsigned long address)
47	{	54	{
48	return kmem_cache_alloc(pgtable_cache, GFP_KERNEL\|__GFP_REPEAT);	55	return __pte_alloc_one_kernel(mm, address, GFP_KERNEL \| __GFP_REPEAT);
49	}	56	}
50		57
51	static inline pgtable_t pte_alloc_one(struct mm_struct *mm,	58	static inline pgtable_t pte_alloc_one(struct mm_struct *mm,

Lines 87-94 static void vunmap_page_range(unsigned long addr, unsigned long end) Link Here

(-)a/mm/vmalloc.c (-19 / +38 lines)
87	} while (pgd++, addr = next, addr != end);	87	} while (pgd++, addr = next, addr != end);
88	}	88	}
89		89
90	static int vmap_pte_range(pmd_t *pmd, unsigned long addr,	90	static int vmap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
91	unsigned long end, pgprot_t prot, struct page *pages, int nr)	91	pgprot_t prot, struct page *pages, int nr, gfp_t gfp_mask)
92	{	92	{
93	pte_t *pte;	93	pte_t *pte;
94		94
Lines 97-103 static int vmap_pte_range(pmd_t *pmd, unsigned long addr, Link Here
97	* callers keep track of where we're up to.	97	* callers keep track of where we're up to.
98	*/	98	*/
99		99
100	pte = pte_alloc_kernel(pmd, addr);	100	pte = pte_alloc_kernel_with_mask(pmd, addr, gfp_mask);
101	if (!pte)	101	if (!pte)
102	return -ENOMEM;	102	return -ENOMEM;
103	do {	103	do {
Lines 114-147 static int vmap_pte_range(pmd_t *pmd, unsigned long addr, Link Here
114	}	114	}
115		115
116	static int vmap_pmd_range(pud_t *pud, unsigned long addr,	116	static int vmap_pmd_range(pud_t *pud, unsigned long addr,
117	unsigned long end, pgprot_t prot, struct page *pages, int nr)	117	unsigned long end, pgprot_t prot, struct page *pages, int nr, gfp_t gfp_mask)
118	{	118	{
119	pmd_t *pmd;	119	pmd_t *pmd;
120	unsigned long next;	120	unsigned long next;
121		121
122	pmd = pmd_alloc(&init_mm, pud, addr);	122	pmd = pmd_alloc_with_mask(&init_mm, pud, addr, gfp_mask);
123	if (!pmd)	123	if (!pmd)
124	return -ENOMEM;	124	return -ENOMEM;
125	do {	125	do {
126	next = pmd_addr_end(addr, end);	126	next = pmd_addr_end(addr, end);
127	if (vmap_pte_range(pmd, addr, next, prot, pages, nr))	127	if (vmap_pte_range(pmd, addr, next, prot, pages, nr, gfp_mask))
128	return -ENOMEM;	128	return -ENOMEM;
129	} while (pmd++, addr = next, addr != end);	129	} while (pmd++, addr = next, addr != end);
130	return 0;	130	return 0;
131	}	131	}
132		132
133	static int vmap_pud_range(pgd_t *pgd, unsigned long addr,	133	static int vmap_pud_range(pgd_t *pgd, unsigned long addr, unsigned long end,
134	unsigned long end, pgprot_t prot, struct page *pages, int nr)	134	pgprot_t prot, struct page *pages, int nr, gfp_t gfp_mask)
135	{	135	{
136	pud_t *pud;	136	pud_t *pud;
137	unsigned long next;	137	unsigned long next;
138		138
139	pud = pud_alloc(&init_mm, pgd, addr);	139	pud = pud_alloc_with_mask(&init_mm, pgd, addr, gfp_mask);
140	if (!pud)	140	if (!pud)
141	return -ENOMEM;	141	return -ENOMEM;
142	do {	142	do {
143	next = pud_addr_end(addr, end);	143	next = pud_addr_end(addr, end);
144	if (vmap_pmd_range(pud, addr, next, prot, pages, nr))	144	if (vmap_pmd_range(pud, addr, next, prot, pages, nr, gfp_mask))
145	return -ENOMEM;	145	return -ENOMEM;
146	} while (pud++, addr = next, addr != end);	146	} while (pud++, addr = next, addr != end);
147	return 0;	147	return 0;
Lines 153-160 static int vmap_pud_range(pgd_t *pgd, unsigned long addr, Link Here
153	*	153	*
154	* Ie. pte at addr+N*PAGE_SIZE shall point to pfn corresponding to pages[N]	154	* Ie. pte at addr+N*PAGE_SIZE shall point to pfn corresponding to pages[N]
155	*/	155	*/
156	static int vmap_page_range_noflush(unsigned long start, unsigned long end,	156	static int __vmap_page_range_noflush(unsigned long start, unsigned long end,
157	pgprot_t prot, struct page **pages)	157	pgprot_t prot, struct page **pages, gfp_t gfp_mask)
158	{	158	{
159	pgd_t *pgd;	159	pgd_t *pgd;
160	unsigned long next;	160	unsigned long next;
Lines 166-172 static int vmap_page_range_noflush(unsigned long start, unsigned long end, Link Here
166	pgd = pgd_offset_k(addr);	166	pgd = pgd_offset_k(addr);
167	do {	167	do {
168	next = pgd_addr_end(addr, end);	168	next = pgd_addr_end(addr, end);
169	err = vmap_pud_range(pgd, addr, next, prot, pages, &nr);	169	err = vmap_pud_range(pgd, addr, next, prot, pages, &nr, gfp_mask);
170	if (err)	170	if (err)
171	return err;	171	return err;
172	} while (pgd++, addr = next, addr != end);	172	} while (pgd++, addr = next, addr != end);
Lines 174-189 static int vmap_page_range_noflush(unsigned long start, unsigned long end, Link Here
174	return nr;	174	return nr;
175	}	175	}
176		176
177	static int vmap_page_range(unsigned long start, unsigned long end,	177
178	pgprot_t prot, struct page **pages)	178	static int vmap_page_range_noflush(unsigned long start, unsigned long end,
		179	pgprot_t prot, struct page **pages)
		180	{
		181	return __vmap_page_range_noflush(start, end, prot, pages, GFP_KERNEL);
		182	}
		183
		184	static int __vmap_page_range(unsigned long start, unsigned long end,
		185	pgprot_t prot, struct page **pages, gfp_t gfp_mask)
179	{	186	{
180	int ret;	187	int ret;
181		188
182	ret = vmap_page_range_noflush(start, end, prot, pages);	189	ret = __vmap_page_range_noflush(start, end, prot, pages, gfp_mask);
183	flush_cache_vmap(start, end);	190	flush_cache_vmap(start, end);
184	return ret;	191	return ret;
185	}	192	}
186		193
		194	static int vmap_page_range(unsigned long start, unsigned long end,
		195	pgprot_t prot, struct page **pages)
		196	{
		197	return __vmap_page_range(start, end, prot, pages, GFP_KERNEL);
		198	}
		199
187	int is_vmalloc_or_module_addr(const void *x)	200	int is_vmalloc_or_module_addr(const void *x)
188	{	201	{
189	/*	202	/*
Lines 1259-1271 void unmap_kernel_range(unsigned long addr, unsigned long size) Link Here
1259	flush_tlb_kernel_range(addr, end);	1272	flush_tlb_kernel_range(addr, end);
1260	}	1273	}
1261		1274
1262	int map_vm_area(struct vm_struct area, pgprot_t prot, struct page **pages)	1275	int __map_vm_area(struct vm_struct *area, pgprot_t prot,
		1276	struct page ***pages, gfp_t gfp_mask)
1263	{	1277	{
1264	unsigned long addr = (unsigned long)area->addr;	1278	unsigned long addr = (unsigned long)area->addr;
1265	unsigned long end = addr + area->size - PAGE_SIZE;	1279	unsigned long end = addr + area->size - PAGE_SIZE;
1266	int err;	1280	int err;
1267		1281
1268	err = vmap_page_range(addr, end, prot, *pages);	1282	err = __vmap_page_range(addr, end, prot, *pages, gfp_mask);
1269	if (err > 0) {	1283	if (err > 0) {
1270	*pages += err;	1284	*pages += err;
1271	err = 0;	1285	err = 0;
Lines 1273-1278 int map_vm_area(struct vm_struct area, pgprot_t prot, struct page **pages) Link Here
1273		1287
1274	return err;	1288	return err;
1275	}	1289	}
		1290
		1291	int map_vm_area(struct vm_struct area, pgprot_t prot, struct page **pages)
		1292	{
		1293	return __map_vm_area(area, prot, pages, GFP_KERNEL);
		1294	}
1276	EXPORT_SYMBOL_GPL(map_vm_area);	1295	EXPORT_SYMBOL_GPL(map_vm_area);
1277		1296
1278	/* Old vmalloc interfaces */	1297	/* Old vmalloc interfaces */
Lines 1614-1620 static void __vmalloc_area_node(struct vm_struct area, gfp_t gfp_mask, Link Here
1614	area->pages[i] = page;	1633	area->pages[i] = page;
1615	}	1634	}
1616		1635
1617	if (map_vm_area(area, prot, &pages))	1636	if (__map_vm_area(area, prot, &pages, gfp_mask))
1618	goto fail;	1637	goto fail;
1619	return area->addr;	1638	return area->addr;
1620		1639