Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 7ef939054139ef857cebbec07cbd12d7cf7beedd

Authored by Jeff Dike 2005-09-04 06:57:52 +0800

Committed by Linus Torvalds 2005-09-05 15:06:24 +0800

Exists in master and in 7 other branches

[PATCH] uml: fix x86_64 page leak

We were leaking pmd pages when 3_LEVEL_PGTABLES was enabled.  This fixes that.

Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

Showing 4 changed files with 22 additions and 12 deletions Inline Diff

arch/um/kernel/skas/include/mmu-skas.h
arch/um/kernel/skas/mmu.c
include/asm-um/pgalloc.h
include/asm-um/pgtable-3level.h

arch/um/kernel/skas/include/mmu-skas.h

Diff comments View file @ 7ef9390

 /*
  * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
 #ifndef __SKAS_MMU_H
 #define __SKAS_MMU_H
+#include "linux/config.h"
 #include "mm_id.h"
 struct mmu_context_skas {
 	struct mm_id id;
         unsigned long last_page_table;
+#ifdef CONFIG_3_LEVEL_PGTABLES
+        unsigned long last_pmd;
+#endif
 };
 extern void switch_mm_skas(struct mm_id * mm_idp);
 #endif
 /*
  * Overrides for Emacs so that we follow Linus's tabbing style.
  * Emacs will notice this stuff at the end of the file and automatically
  * adjust the settings for this buffer only.  This must remain at the end
  * of the file.
  * ---------------------------------------------------------------------------
  * Local variables:
  * c-file-style: "linux"
  * End:
  */

arch/um/kernel/skas/mmu.c

Diff comments View file @ 7ef9390

 /*
  * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
 #include "linux/config.h"
 #include "linux/sched.h"
 #include "linux/list.h"
 #include "linux/spinlock.h"
 #include "linux/slab.h"
 #include "linux/errno.h"
 #include "linux/mm.h"
 #include "asm/current.h"
 #include "asm/segment.h"
 #include "asm/mmu.h"
 #include "asm/pgalloc.h"
 #include "asm/pgtable.h"
 #include "os.h"
 #include "skas.h"
 extern int __syscall_stub_start;
 static int init_stub_pte(struct mm_struct *mm, unsigned long proc,
 			 unsigned long kernel)
 {
 	pgd_t *pgd;
 	pud_t *pud;
 	pmd_t *pmd;
 	pte_t *pte;
 	spin_lock(&mm->page_table_lock);
 	pgd = pgd_offset(mm, proc);
 	pud = pud_alloc(mm, pgd, proc);
 	if (!pud)
 		goto out;
 	pmd = pmd_alloc(mm, pud, proc);
 	if (!pmd)
 		goto out_pmd;
 	pte = pte_alloc_map(mm, pmd, proc);
 	if (!pte)
 		goto out_pte;
 	/* There's an interaction between the skas0 stub pages, stack
 	 * randomization, and the BUG at the end of exit_mmap.  exit_mmap
          * checks that the number of page tables freed is the same as had
          * been allocated.  If the stack is on the last page table page,
 	 * then the stack pte page will be freed, and if not, it won't.  To
 	 * avoid having to know where the stack is, or if the process mapped
 	 * something at the top of its address space for some other reason,
 	 * we set TASK_SIZE to end at the start of the last page table.
 	 * This keeps exit_mmap off the last page, but introduces a leak
 	 * of that page.  So, we hang onto it here and free it in
 	 * destroy_context_skas.
 	 */
         mm->context.skas.last_page_table = pmd_page_kernel(*pmd);
+#ifdef CONFIG_3_LEVEL_PGTABLES
+        mm->context.skas.last_pmd = (unsigned long) __va(pud_val(*pud));
+#endif
 	*pte = mk_pte(virt_to_page(kernel), __pgprot(_PAGE_PRESENT));
 	*pte = pte_mkexec(*pte);
 	*pte = pte_wrprotect(*pte);
 	spin_unlock(&mm->page_table_lock);
 	return(0);
  out_pmd:
 	pud_free(pud);
  out_pte:
 	pmd_free(pmd);
  out:
 	spin_unlock(&mm->page_table_lock);
 	return(-ENOMEM);
 }
 int init_new_context_skas(struct task_struct *task, struct mm_struct *mm)
 {
 	struct mm_struct *cur_mm = current->mm;
 	struct mm_id *cur_mm_id = &cur_mm->context.skas.id;
 	struct mm_id *mm_id = &mm->context.skas.id;
 	unsigned long stack = 0;
 	int from, ret = -ENOMEM;
 	if(!proc_mm || !ptrace_faultinfo){
 		stack = get_zeroed_page(GFP_KERNEL);
 		if(stack == 0)
 			goto out;
 		/* This zeros the entry that pgd_alloc didn't, needed since
 		 * we are about to reinitialize it, and want mm.nr_ptes to
 		 * be accurate.
 		 */
 		mm->pgd[USER_PTRS_PER_PGD] = __pgd(0);
 		ret = init_stub_pte(mm, CONFIG_STUB_CODE,
 				    (unsigned long) &__syscall_stub_start);
 		if(ret)
 			goto out_free;
 		ret = init_stub_pte(mm, CONFIG_STUB_DATA, stack);
 		if(ret)
 			goto out_free;
 		mm->nr_ptes--;
 	}
 	mm_id->stack = stack;
 	if(proc_mm){
 		if((cur_mm != NULL) && (cur_mm != &init_mm))
 			from = cur_mm_id->u.mm_fd;
 		else from = -1;
 		ret = new_mm(from, stack);
 		if(ret < 0){
 			printk("init_new_context_skas - new_mm failed, "
 			       "errno = %d\n", ret);
 			goto out_free;
 		}
 		mm_id->u.mm_fd = ret;
 	}
 	else {
 		if((cur_mm != NULL) && (cur_mm != &init_mm))
 			mm_id->u.pid = copy_context_skas0(stack,
 							  cur_mm_id->u.pid);
 		else mm_id->u.pid = start_userspace(stack);
 	}
 	return 0;
  out_free:
 	if(mm_id->stack != 0)
 		free_page(mm_id->stack);
  out:
 	return ret;
 }
 void destroy_context_skas(struct mm_struct *mm)
 {
 	struct mmu_context_skas *mmu = &mm->context.skas;
 	if(proc_mm)
 		os_close_file(mmu->id.u.mm_fd);
 	else
 		os_kill_ptraced_process(mmu->id.u.pid, 1);
 	if(!proc_mm || !ptrace_faultinfo){
 		free_page(mmu->id.stack);
-		free_page(mmu->last_page_table);
+		pte_free_kernel((pte_t *) mmu->last_page_table);
+                dec_page_state(nr_page_table_pages);
+#ifdef CONFIG_3_LEVEL_PGTABLES
+		pmd_free((pmd_t *) mmu->last_pmd);
+#endif
 	}
 }

include/asm-um/pgalloc.h

Diff comments View file @ 7ef9390

1	/*	1	/*
2	* Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)	2	* Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
3	* Copyright 2003 PathScale, Inc.	3	* Copyright 2003 PathScale, Inc.
4	* Derived from include/asm-i386/pgalloc.h and include/asm-i386/pgtable.h	4	* Derived from include/asm-i386/pgalloc.h and include/asm-i386/pgtable.h
5	* Licensed under the GPL	5	* Licensed under the GPL
6	*/	6	*/
7		7
8	#ifndef __UM_PGALLOC_H	8	#ifndef __UM_PGALLOC_H
9	#define __UM_PGALLOC_H	9	#define __UM_PGALLOC_H
10		10
11	#include "linux/config.h"	11	#include "linux/config.h"
12	#include "linux/mm.h"	12	#include "linux/mm.h"
13	#include "asm/fixmap.h"	13	#include "asm/fixmap.h"
14		14
15	#define pmd_populate_kernel(mm, pmd, pte) \	15	#define pmd_populate_kernel(mm, pmd, pte) \
16	set_pmd(pmd, __pmd(_PAGE_TABLE + (unsigned long) __pa(pte)))	16	set_pmd(pmd, __pmd(_PAGE_TABLE + (unsigned long) __pa(pte)))
17		17
18	#define pmd_populate(mm, pmd, pte) \	18	#define pmd_populate(mm, pmd, pte) \
19	set_pmd(pmd, __pmd(_PAGE_TABLE + \	19	set_pmd(pmd, __pmd(_PAGE_TABLE + \
20	((unsigned long long)page_to_pfn(pte) << \	20	((unsigned long long)page_to_pfn(pte) << \
21	(unsigned long long) PAGE_SHIFT)))	21	(unsigned long long) PAGE_SHIFT)))
22		22
23	/*	23	/*
24	* Allocate and free page tables.	24	* Allocate and free page tables.
25	*/	25	*/
26	extern pgd_t pgd_alloc(struct mm_struct );	26	extern pgd_t pgd_alloc(struct mm_struct );
27	extern void pgd_free(pgd_t *pgd);	27	extern void pgd_free(pgd_t *pgd);
28		28
29	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);
30	extern struct page pte_alloc_one(struct mm_struct , unsigned long);	30	extern struct page pte_alloc_one(struct mm_struct , unsigned long);
31		31
32	static inline void pte_free_kernel(pte_t *pte)	32	static inline void pte_free_kernel(pte_t *pte)
33	{	33	{
34	free_page((unsigned long) pte);	34	free_page((unsigned long) pte);
35	}	35	}
36		36
37	static inline void pte_free(struct page *pte)	37	static inline void pte_free(struct page *pte)
38	{	38	{
39	__free_page(pte);	39	__free_page(pte);
40	}	40	}
41		41
42	#define __pte_free_tlb(tlb,pte) tlb_remove_page((tlb),(pte))	42	#define __pte_free_tlb(tlb,pte) tlb_remove_page((tlb),(pte))
43		43
44	#ifdef CONFIG_3_LEVEL_PGTABLES	44	#ifdef CONFIG_3_LEVEL_PGTABLES
45	/*	45
46	* In the 3-level case we free the pmds as part of the pgd.	46	extern __inline__ void pmd_free(pmd_t *pmd)
47	*/	47	{
48	#define pmd_free(x) do { } while (0)	48	free_page((unsigned long)pmd);
49	#define __pmd_free_tlb(tlb,x) do { } while (0)	49	}
		50
		51	#define __pmd_free_tlb(tlb,x) tlb_remove_page((tlb),virt_to_page(x))
50	#endif	52	#endif
51		53
52	#define check_pgt_cache() do { } while (0)	54	#define check_pgt_cache() do { } while (0)
53		55
54	#endif	56	#endif
55		57
56	/*	58	/*
57	* Overrides for Emacs so that we follow Linus's tabbing style.	59	* Overrides for Emacs so that we follow Linus's tabbing style.
58	* Emacs will notice this stuff at the end of the file and automatically	60	* Emacs will notice this stuff at the end of the file and automatically
59	* adjust the settings for this buffer only. This must remain at the end	61	* adjust the settings for this buffer only. This must remain at the end
60	* of the file.	62	* of the file.
61	* ---------------------------------------------------------------------------	63	* ---------------------------------------------------------------------------
62	* Local variables:	64	* Local variables:
63	* c-file-style: "linux"	65	* c-file-style: "linux"
64	* End:	66	* End:
65	*/	67	*/
66		68

include/asm-um/pgtable-3level.h

Diff comments View file @ 7ef9390

 /*
  * Copyright 2003 PathScale Inc
  * Derived from include/asm-i386/pgtable.h
  * Licensed under the GPL
  */
 #ifndef __UM_PGTABLE_3LEVEL_H
 #define __UM_PGTABLE_3LEVEL_H
 #include <asm-generic/pgtable-nopud.h>
 /* PGDIR_SHIFT determines what a third-level page table entry can map */
 #define PGDIR_SHIFT	30
 #define PGDIR_SIZE	(1UL << PGDIR_SHIFT)
 #define PGDIR_MASK	(~(PGDIR_SIZE-1))
 /* PMD_SHIFT determines the size of the area a second-level page table can
  * map
  */
 #define PMD_SHIFT	21
 #define PMD_SIZE	(1UL << PMD_SHIFT)
 #define PMD_MASK	(~(PMD_SIZE-1))
 /*
  * entries per page directory level
  */
 #define PTRS_PER_PTE 512
 #define PTRS_PER_PMD 512
 #define USER_PTRS_PER_PGD ((TASK_SIZE + (PGDIR_SIZE - 1)) / PGDIR_SIZE)
 #define PTRS_PER_PGD 512
 #define FIRST_USER_ADDRESS	0
 #define pte_ERROR(e) \
         printk("%s:%d: bad pte %p(%016lx).\n", __FILE__, __LINE__, &(e), \
 	       pte_val(e))
 #define pmd_ERROR(e) \
         printk("%s:%d: bad pmd %p(%016lx).\n", __FILE__, __LINE__, &(e), \
 	       pmd_val(e))
 #define pgd_ERROR(e) \
         printk("%s:%d: bad pgd %p(%016lx).\n", __FILE__, __LINE__, &(e), \
 	       pgd_val(e))
 #define pud_none(x)	(!(pud_val(x) & ~_PAGE_NEWPAGE))
 #define	pud_bad(x)	((pud_val(x) & (~PAGE_MASK & ~_PAGE_USER)) != _KERNPG_TABLE)
 #define pud_present(x)	(pud_val(x) & _PAGE_PRESENT)
 #define pud_populate(mm, pud, pmd) \
 	set_pud(pud, __pud(_PAGE_TABLE + __pa(pmd)))
 #define set_pud(pudptr, pudval) set_64bit((phys_t *) (pudptr), pud_val(pudval))
 static inline int pgd_newpage(pgd_t pgd)
 {
 	return(pgd_val(pgd) & _PAGE_NEWPAGE);
 }
 static inline void pgd_mkuptodate(pgd_t pgd) { pgd_val(pgd) &= ~_PAGE_NEWPAGE; }
 #define set_pmd(pmdptr, pmdval) set_64bit((phys_t *) (pmdptr), pmd_val(pmdval))
 static inline pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address)
 {
         pmd_t *pmd = (pmd_t *) __get_free_page(GFP_KERNEL);
         if(pmd)
                 memset(pmd, 0, PAGE_SIZE);
         return pmd;
 }
-static inline void pmd_free(pmd_t *pmd){
+extern inline void pud_clear (pud_t *pud)
-	free_page((unsigned long) pmd);
+{
+        set_pud(pud, __pud(0));
 }
-#define __pmd_free_tlb(tlb,x)   do { } while (0)
-static inline void pud_clear (pud_t * pud) { }
 #define pud_page(pud) \
 	((struct page *) __va(pud_val(pud) & PAGE_MASK))
 /* Find an entry in the second-level page table.. */
 #define pmd_offset(pud, address) ((pmd_t *) pud_page(*(pud)) + \
 			pmd_index(address))
 static inline unsigned long pte_pfn(pte_t pte)
 {
 	return phys_to_pfn(pte_val(pte));
 }
 static inline pte_t pfn_pte(pfn_t page_nr, pgprot_t pgprot)
 {
 	pte_t pte;
 	phys_t phys = pfn_to_phys(page_nr);
 	pte_set_val(pte, phys, pgprot);
 	return pte;
 }
 static inline pmd_t pfn_pmd(pfn_t page_nr, pgprot_t pgprot)
 {
 	return __pmd((page_nr << PAGE_SHIFT) | pgprot_val(pgprot));
 }
 /*
  * Bits 0 through 3 are taken in the low part of the pte,
  * put the 32 bits of offset into the high part.
  */
 #define PTE_FILE_MAX_BITS	32
 #ifdef CONFIG_64BIT
 #define pte_to_pgoff(p) ((p).pte >> 32)
 #define pgoff_to_pte(off) ((pte_t) { ((off) << 32) | _PAGE_FILE })
 #else
 #define pte_to_pgoff(pte) ((pte).pte_high)
 #define pgoff_to_pte(off) ((pte_t) { _PAGE_FILE, (off) })
 #endif
 #endif
 /*
  * Overrides for Emacs so that we follow Linus's tabbing style.
  * Emacs will notice this stuff at the end of the file and automatically
  * adjust the settings for this buffer only.  This must remain at the end
  * of the file.
  * ---------------------------------------------------------------------------
  * Local variables:
  * c-file-style: "linux"
  * End:
  */