Merge tag 'pm-4.15-rc6' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
[muen/linux.git] / arch / x86 / include / asm / mmu_context.h
1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _ASM_X86_MMU_CONTEXT_H
3 #define _ASM_X86_MMU_CONTEXT_H
4
5 #include <asm/desc.h>
6 #include <linux/atomic.h>
7 #include <linux/mm_types.h>
8 #include <linux/pkeys.h>
9
10 #include <trace/events/tlb.h>
11
12 #include <asm/pgalloc.h>
13 #include <asm/tlbflush.h>
14 #include <asm/paravirt.h>
15 #include <asm/mpx.h>
16
17 extern atomic64_t last_mm_ctx_id;
18
19 #ifndef CONFIG_PARAVIRT
20 static inline void paravirt_activate_mm(struct mm_struct *prev,
21                                         struct mm_struct *next)
22 {
23 }
24 #endif  /* !CONFIG_PARAVIRT */
25
26 #ifdef CONFIG_PERF_EVENTS
27 extern struct static_key rdpmc_always_available;
28
29 static inline void load_mm_cr4(struct mm_struct *mm)
30 {
31         if (static_key_false(&rdpmc_always_available) ||
32             atomic_read(&mm->context.perf_rdpmc_allowed))
33                 cr4_set_bits(X86_CR4_PCE);
34         else
35                 cr4_clear_bits(X86_CR4_PCE);
36 }
37 #else
38 static inline void load_mm_cr4(struct mm_struct *mm) {}
39 #endif
40
41 #ifdef CONFIG_MODIFY_LDT_SYSCALL
42 /*
43  * ldt_structs can be allocated, used, and freed, but they are never
44  * modified while live.
45  */
46 struct ldt_struct {
47         /*
48          * Xen requires page-aligned LDTs with special permissions.  This is
49          * needed to prevent us from installing evil descriptors such as
50          * call gates.  On native, we could merge the ldt_struct and LDT
51          * allocations, but it's not worth trying to optimize.
52          */
53         struct desc_struct *entries;
54         unsigned int nr_entries;
55 };
56
57 /*
58  * Used for LDT copy/destruction.
59  */
60 static inline void init_new_context_ldt(struct mm_struct *mm)
61 {
62         mm->context.ldt = NULL;
63         init_rwsem(&mm->context.ldt_usr_sem);
64 }
65 int ldt_dup_context(struct mm_struct *oldmm, struct mm_struct *mm);
66 void destroy_context_ldt(struct mm_struct *mm);
67 #else   /* CONFIG_MODIFY_LDT_SYSCALL */
68 static inline void init_new_context_ldt(struct mm_struct *mm) { }
69 static inline int ldt_dup_context(struct mm_struct *oldmm,
70                                   struct mm_struct *mm)
71 {
72         return 0;
73 }
74 static inline void destroy_context_ldt(struct mm_struct *mm) {}
75 #endif
76
77 static inline void load_mm_ldt(struct mm_struct *mm)
78 {
79 #ifdef CONFIG_MODIFY_LDT_SYSCALL
80         struct ldt_struct *ldt;
81
82         /* READ_ONCE synchronizes with smp_store_release */
83         ldt = READ_ONCE(mm->context.ldt);
84
85         /*
86          * Any change to mm->context.ldt is followed by an IPI to all
87          * CPUs with the mm active.  The LDT will not be freed until
88          * after the IPI is handled by all such CPUs.  This means that,
89          * if the ldt_struct changes before we return, the values we see
90          * will be safe, and the new values will be loaded before we run
91          * any user code.
92          *
93          * NB: don't try to convert this to use RCU without extreme care.
94          * We would still need IRQs off, because we don't want to change
95          * the local LDT after an IPI loaded a newer value than the one
96          * that we can see.
97          */
98
99         if (unlikely(ldt))
100                 set_ldt(ldt->entries, ldt->nr_entries);
101         else
102                 clear_LDT();
103 #else
104         clear_LDT();
105 #endif
106 }
107
108 static inline void switch_ldt(struct mm_struct *prev, struct mm_struct *next)
109 {
110 #ifdef CONFIG_MODIFY_LDT_SYSCALL
111         /*
112          * Load the LDT if either the old or new mm had an LDT.
113          *
114          * An mm will never go from having an LDT to not having an LDT.  Two
115          * mms never share an LDT, so we don't gain anything by checking to
116          * see whether the LDT changed.  There's also no guarantee that
117          * prev->context.ldt actually matches LDTR, but, if LDTR is non-NULL,
118          * then prev->context.ldt will also be non-NULL.
119          *
120          * If we really cared, we could optimize the case where prev == next
121          * and we're exiting lazy mode.  Most of the time, if this happens,
122          * we don't actually need to reload LDTR, but modify_ldt() is mostly
123          * used by legacy code and emulators where we don't need this level of
124          * performance.
125          *
126          * This uses | instead of || because it generates better code.
127          */
128         if (unlikely((unsigned long)prev->context.ldt |
129                      (unsigned long)next->context.ldt))
130                 load_mm_ldt(next);
131 #endif
132
133         DEBUG_LOCKS_WARN_ON(preemptible());
134 }
135
136 void enter_lazy_tlb(struct mm_struct *mm, struct task_struct *tsk);
137
138 static inline int init_new_context(struct task_struct *tsk,
139                                    struct mm_struct *mm)
140 {
141         mutex_init(&mm->context.lock);
142
143         mm->context.ctx_id = atomic64_inc_return(&last_mm_ctx_id);
144         atomic64_set(&mm->context.tlb_gen, 0);
145
146 #ifdef CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS
147         if (cpu_feature_enabled(X86_FEATURE_OSPKE)) {
148                 /* pkey 0 is the default and always allocated */
149                 mm->context.pkey_allocation_map = 0x1;
150                 /* -1 means unallocated or invalid */
151                 mm->context.execute_only_pkey = -1;
152         }
153 #endif
154         init_new_context_ldt(mm);
155         return 0;
156 }
157 static inline void destroy_context(struct mm_struct *mm)
158 {
159         destroy_context_ldt(mm);
160 }
161
162 extern void switch_mm(struct mm_struct *prev, struct mm_struct *next,
163                       struct task_struct *tsk);
164
165 extern void switch_mm_irqs_off(struct mm_struct *prev, struct mm_struct *next,
166                                struct task_struct *tsk);
167 #define switch_mm_irqs_off switch_mm_irqs_off
168
169 #define activate_mm(prev, next)                 \
170 do {                                            \
171         paravirt_activate_mm((prev), (next));   \
172         switch_mm((prev), (next), NULL);        \
173 } while (0);
174
175 #ifdef CONFIG_X86_32
176 #define deactivate_mm(tsk, mm)                  \
177 do {                                            \
178         lazy_load_gs(0);                        \
179 } while (0)
180 #else
181 #define deactivate_mm(tsk, mm)                  \
182 do {                                            \
183         load_gs_index(0);                       \
184         loadsegment(fs, 0);                     \
185 } while (0)
186 #endif
187
188 static inline int arch_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
189 {
190         paravirt_arch_dup_mmap(oldmm, mm);
191         return ldt_dup_context(oldmm, mm);
192 }
193
194 static inline void arch_exit_mmap(struct mm_struct *mm)
195 {
196         paravirt_arch_exit_mmap(mm);
197 }
198
199 #ifdef CONFIG_X86_64
200 static inline bool is_64bit_mm(struct mm_struct *mm)
201 {
202         return  !IS_ENABLED(CONFIG_IA32_EMULATION) ||
203                 !(mm->context.ia32_compat == TIF_IA32);
204 }
205 #else
206 static inline bool is_64bit_mm(struct mm_struct *mm)
207 {
208         return false;
209 }
210 #endif
211
212 static inline void arch_bprm_mm_init(struct mm_struct *mm,
213                 struct vm_area_struct *vma)
214 {
215         mpx_mm_init(mm);
216 }
217
218 static inline void arch_unmap(struct mm_struct *mm, struct vm_area_struct *vma,
219                               unsigned long start, unsigned long end)
220 {
221         /*
222          * mpx_notify_unmap() goes and reads a rarely-hot
223          * cacheline in the mm_struct.  That can be expensive
224          * enough to be seen in profiles.
225          *
226          * The mpx_notify_unmap() call and its contents have been
227          * observed to affect munmap() performance on hardware
228          * where MPX is not present.
229          *
230          * The unlikely() optimizes for the fast case: no MPX
231          * in the CPU, or no MPX use in the process.  Even if
232          * we get this wrong (in the unlikely event that MPX
233          * is widely enabled on some system) the overhead of
234          * MPX itself (reading bounds tables) is expected to
235          * overwhelm the overhead of getting this unlikely()
236          * consistently wrong.
237          */
238         if (unlikely(cpu_feature_enabled(X86_FEATURE_MPX)))
239                 mpx_notify_unmap(mm, vma, start, end);
240 }
241
242 #ifdef CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS
243 static inline int vma_pkey(struct vm_area_struct *vma)
244 {
245         unsigned long vma_pkey_mask = VM_PKEY_BIT0 | VM_PKEY_BIT1 |
246                                       VM_PKEY_BIT2 | VM_PKEY_BIT3;
247
248         return (vma->vm_flags & vma_pkey_mask) >> VM_PKEY_SHIFT;
249 }
250 #else
251 static inline int vma_pkey(struct vm_area_struct *vma)
252 {
253         return 0;
254 }
255 #endif
256
257 /*
258  * We only want to enforce protection keys on the current process
259  * because we effectively have no access to PKRU for other
260  * processes or any way to tell *which * PKRU in a threaded
261  * process we could use.
262  *
263  * So do not enforce things if the VMA is not from the current
264  * mm, or if we are in a kernel thread.
265  */
266 static inline bool vma_is_foreign(struct vm_area_struct *vma)
267 {
268         if (!current->mm)
269                 return true;
270         /*
271          * Should PKRU be enforced on the access to this VMA?  If
272          * the VMA is from another process, then PKRU has no
273          * relevance and should not be enforced.
274          */
275         if (current->mm != vma->vm_mm)
276                 return true;
277
278         return false;
279 }
280
281 static inline bool arch_vma_access_permitted(struct vm_area_struct *vma,
282                 bool write, bool execute, bool foreign)
283 {
284         /* pkeys never affect instruction fetches */
285         if (execute)
286                 return true;
287         /* allow access if the VMA is not one from this process */
288         if (foreign || vma_is_foreign(vma))
289                 return true;
290         return __pkru_allows_pkey(vma_pkey(vma), write);
291 }
292
293 /*
294  * This can be used from process context to figure out what the value of
295  * CR3 is without needing to do a (slow) __read_cr3().
296  *
297  * It's intended to be used for code like KVM that sneakily changes CR3
298  * and needs to restore it.  It needs to be used very carefully.
299  */
300 static inline unsigned long __get_current_cr3_fast(void)
301 {
302         unsigned long cr3 = build_cr3(this_cpu_read(cpu_tlbstate.loaded_mm)->pgd,
303                 this_cpu_read(cpu_tlbstate.loaded_mm_asid));
304
305         /* For now, be very restrictive about when this can be called. */
306         VM_WARN_ON(in_nmi() || preemptible());
307
308         VM_BUG_ON(cr3 != __read_cr3());
309         return cr3;
310 }
311
312 #endif /* _ASM_X86_MMU_CONTEXT_H */