Blame view

kernel/linux-rt-4.4.41/arch/mn10300/mm/pgtable.c 4.61 KB
5113f6f70   김현기   kernel add
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
  /* MN10300 Page table management
   *
   * Copyright (C) 2007 Matsushita Electric Industrial Co., Ltd.
   * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
   * Modified by David Howells (dhowells@redhat.com)
   *
   * This program is free software; you can redistribute it and/or
   * modify it under the terms of the GNU General Public Licence
   * as published by the Free Software Foundation; either version
   * 2 of the Licence, or (at your option) any later version.
   */
  #include <linux/sched.h>
  #include <linux/kernel.h>
  #include <linux/errno.h>
  #include <linux/gfp.h>
  #include <linux/mm.h>
  #include <linux/swap.h>
  #include <linux/smp.h>
  #include <linux/highmem.h>
  #include <linux/pagemap.h>
  #include <linux/spinlock.h>
  #include <linux/quicklist.h>
  
  #include <asm/pgtable.h>
  #include <asm/pgalloc.h>
  #include <asm/tlb.h>
  #include <asm/tlbflush.h>
  
  /*
   * Associate a large virtual page frame with a given physical page frame
   * and protection flags for that frame. pfn is for the base of the page,
   * vaddr is what the page gets mapped to - both must be properly aligned.
   * The pmd must already be instantiated. Assumes PAE mode.
   */
  void set_pmd_pfn(unsigned long vaddr, unsigned long pfn, pgprot_t flags)
  {
  	pgd_t *pgd;
  	pud_t *pud;
  	pmd_t *pmd;
  
  	if (vaddr & (PMD_SIZE-1)) {		/* vaddr is misaligned */
  		printk(KERN_ERR "set_pmd_pfn: vaddr misaligned
  ");
  		return; /* BUG(); */
  	}
  	if (pfn & (PTRS_PER_PTE-1)) {		/* pfn is misaligned */
  		printk(KERN_ERR "set_pmd_pfn: pfn misaligned
  ");
  		return; /* BUG(); */
  	}
  	pgd = swapper_pg_dir + pgd_index(vaddr);
  	if (pgd_none(*pgd)) {
  		printk(KERN_ERR "set_pmd_pfn: pgd_none
  ");
  		return; /* BUG(); */
  	}
  	pud = pud_offset(pgd, vaddr);
  	pmd = pmd_offset(pud, vaddr);
  	set_pmd(pmd, pfn_pmd(pfn, flags));
  	/*
  	 * It's enough to flush this one mapping.
  	 * (PGE mappings get flushed as well)
  	 */
  	local_flush_tlb_one(vaddr);
  }
  
  pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
  {
  	pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT);
  	if (pte)
  		clear_page(pte);
  	return pte;
  }
  
  struct page *pte_alloc_one(struct mm_struct *mm, unsigned long address)
  {
  	struct page *pte;
  
  #ifdef CONFIG_HIGHPTE
  	pte = alloc_pages(GFP_KERNEL|__GFP_HIGHMEM|__GFP_REPEAT, 0);
  #else
  	pte = alloc_pages(GFP_KERNEL|__GFP_REPEAT, 0);
  #endif
  	if (!pte)
  		return NULL;
  	clear_highpage(pte);
  	if (!pgtable_page_ctor(pte)) {
  		__free_page(pte);
  		return NULL;
  	}
  	return pte;
  }
  
  /*
   * List of all pgd's needed for non-PAE so it can invalidate entries
   * in both cached and uncached pgd's; not needed for PAE since the
   * kernel pmd is shared. If PAE were not to share the pmd a similar
   * tactic would be needed. This is essentially codepath-based locking
   * against pageattr.c; it is the unique case in which a valid change
   * of kernel pagetables can't be lazily synchronized by vmalloc faults.
   * vmalloc faults work because attached pagetables are never freed.
   * If the locking proves to be non-performant, a ticketing scheme with
   * checks at dup_mmap(), exec(), and other mmlist addition points
   * could be used. The locking scheme was chosen on the basis of
   * manfred's recommendations and having no core impact whatsoever.
   * -- nyc
   */
  DEFINE_SPINLOCK(pgd_lock);
  struct page *pgd_list;
  
  static inline void pgd_list_add(pgd_t *pgd)
  {
  	struct page *page = virt_to_page(pgd);
  	page->index = (unsigned long) pgd_list;
  	if (pgd_list)
  		set_page_private(pgd_list, (unsigned long) &page->index);
  	pgd_list = page;
  	set_page_private(page, (unsigned long) &pgd_list);
  }
  
  static inline void pgd_list_del(pgd_t *pgd)
  {
  	struct page *next, **pprev, *page = virt_to_page(pgd);
  	next = (struct page *) page->index;
  	pprev = (struct page **) page_private(page);
  	*pprev = next;
  	if (next)
  		set_page_private(next, (unsigned long) pprev);
  }
  
  void pgd_ctor(void *pgd)
  {
  	unsigned long flags;
  
  	if (PTRS_PER_PMD == 1)
  		spin_lock_irqsave(&pgd_lock, flags);
  
  	memcpy((pgd_t *)pgd + USER_PTRS_PER_PGD,
  			swapper_pg_dir + USER_PTRS_PER_PGD,
  			(PTRS_PER_PGD - USER_PTRS_PER_PGD) * sizeof(pgd_t));
  
  	if (PTRS_PER_PMD > 1)
  		return;
  
  	pgd_list_add(pgd);
  	spin_unlock_irqrestore(&pgd_lock, flags);
  	memset(pgd, 0, USER_PTRS_PER_PGD * sizeof(pgd_t));
  }
  
  /* never called when PTRS_PER_PMD > 1 */
  void pgd_dtor(void *pgd)
  {
  	unsigned long flags; /* can be called from interrupt context */
  
  	spin_lock_irqsave(&pgd_lock, flags);
  	pgd_list_del(pgd);
  	spin_unlock_irqrestore(&pgd_lock, flags);
  }
  
  pgd_t *pgd_alloc(struct mm_struct *mm)
  {
  	return quicklist_alloc(0, GFP_KERNEL, pgd_ctor);
  }
  
  void pgd_free(struct mm_struct *mm, pgd_t *pgd)
  {
  	quicklist_free(0, pgd_dtor, pgd);
  }
  
  void __init pgtable_cache_init(void)
  {
  }
  
  void check_pgt_cache(void)
  {
  	quicklist_trim(0, pgd_dtor, 25, 16);
  }