Merge tag 'drm-msm-fixes-2020-06-25' of https://gitlab.freedesktop.org/drm/msm into...
[linux-2.6-microblaze.git] / arch / x86 / mm / tlb.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 #include <linux/init.h>
3
4 #include <linux/mm.h>
5 #include <linux/spinlock.h>
6 #include <linux/smp.h>
7 #include <linux/interrupt.h>
8 #include <linux/export.h>
9 #include <linux/cpu.h>
10 #include <linux/debugfs.h>
11
12 #include <asm/tlbflush.h>
13 #include <asm/mmu_context.h>
14 #include <asm/nospec-branch.h>
15 #include <asm/cache.h>
16 #include <asm/apic.h>
17 #include <asm/uv/uv.h>
18
19 #include "mm_internal.h"
20
21 #ifdef CONFIG_PARAVIRT
22 # define STATIC_NOPV
23 #else
24 # define STATIC_NOPV                    static
25 # define __flush_tlb_local              native_flush_tlb_local
26 # define __flush_tlb_global             native_flush_tlb_global
27 # define __flush_tlb_one_user(addr)     native_flush_tlb_one_user(addr)
28 # define __flush_tlb_others(msk, info)  native_flush_tlb_others(msk, info)
29 #endif
30
31 /*
32  *      TLB flushing, formerly SMP-only
33  *              c/o Linus Torvalds.
34  *
35  *      These mean you can really definitely utterly forget about
36  *      writing to user space from interrupts. (Its not allowed anyway).
37  *
38  *      Optimizations Manfred Spraul <manfred@colorfullife.com>
39  *
40  *      More scalable flush, from Andi Kleen
41  *
42  *      Implement flush IPI by CALL_FUNCTION_VECTOR, Alex Shi
43  */
44
45 /*
46  * Use bit 0 to mangle the TIF_SPEC_IB state into the mm pointer which is
47  * stored in cpu_tlb_state.last_user_mm_ibpb.
48  */
49 #define LAST_USER_MM_IBPB       0x1UL
50
51 /*
52  * The x86 feature is called PCID (Process Context IDentifier). It is similar
53  * to what is traditionally called ASID on the RISC processors.
54  *
55  * We don't use the traditional ASID implementation, where each process/mm gets
56  * its own ASID and flush/restart when we run out of ASID space.
57  *
58  * Instead we have a small per-cpu array of ASIDs and cache the last few mm's
59  * that came by on this CPU, allowing cheaper switch_mm between processes on
60  * this CPU.
61  *
62  * We end up with different spaces for different things. To avoid confusion we
63  * use different names for each of them:
64  *
65  * ASID  - [0, TLB_NR_DYN_ASIDS-1]
66  *         the canonical identifier for an mm
67  *
68  * kPCID - [1, TLB_NR_DYN_ASIDS]
69  *         the value we write into the PCID part of CR3; corresponds to the
70  *         ASID+1, because PCID 0 is special.
71  *
72  * uPCID - [2048 + 1, 2048 + TLB_NR_DYN_ASIDS]
73  *         for KPTI each mm has two address spaces and thus needs two
74  *         PCID values, but we can still do with a single ASID denomination
75  *         for each mm. Corresponds to kPCID + 2048.
76  *
77  */
78
79 /* There are 12 bits of space for ASIDS in CR3 */
80 #define CR3_HW_ASID_BITS                12
81
82 /*
83  * When enabled, PAGE_TABLE_ISOLATION consumes a single bit for
84  * user/kernel switches
85  */
86 #ifdef CONFIG_PAGE_TABLE_ISOLATION
87 # define PTI_CONSUMED_PCID_BITS 1
88 #else
89 # define PTI_CONSUMED_PCID_BITS 0
90 #endif
91
92 #define CR3_AVAIL_PCID_BITS (X86_CR3_PCID_BITS - PTI_CONSUMED_PCID_BITS)
93
94 /*
95  * ASIDs are zero-based: 0->MAX_AVAIL_ASID are valid.  -1 below to account
96  * for them being zero-based.  Another -1 is because PCID 0 is reserved for
97  * use by non-PCID-aware users.
98  */
99 #define MAX_ASID_AVAILABLE ((1 << CR3_AVAIL_PCID_BITS) - 2)
100
101 /*
102  * Given @asid, compute kPCID
103  */
104 static inline u16 kern_pcid(u16 asid)
105 {
106         VM_WARN_ON_ONCE(asid > MAX_ASID_AVAILABLE);
107
108 #ifdef CONFIG_PAGE_TABLE_ISOLATION
109         /*
110          * Make sure that the dynamic ASID space does not confict with the
111          * bit we are using to switch between user and kernel ASIDs.
112          */
113         BUILD_BUG_ON(TLB_NR_DYN_ASIDS >= (1 << X86_CR3_PTI_PCID_USER_BIT));
114
115         /*
116          * The ASID being passed in here should have respected the
117          * MAX_ASID_AVAILABLE and thus never have the switch bit set.
118          */
119         VM_WARN_ON_ONCE(asid & (1 << X86_CR3_PTI_PCID_USER_BIT));
120 #endif
121         /*
122          * The dynamically-assigned ASIDs that get passed in are small
123          * (<TLB_NR_DYN_ASIDS).  They never have the high switch bit set,
124          * so do not bother to clear it.
125          *
126          * If PCID is on, ASID-aware code paths put the ASID+1 into the
127          * PCID bits.  This serves two purposes.  It prevents a nasty
128          * situation in which PCID-unaware code saves CR3, loads some other
129          * value (with PCID == 0), and then restores CR3, thus corrupting
130          * the TLB for ASID 0 if the saved ASID was nonzero.  It also means
131          * that any bugs involving loading a PCID-enabled CR3 with
132          * CR4.PCIDE off will trigger deterministically.
133          */
134         return asid + 1;
135 }
136
137 /*
138  * Given @asid, compute uPCID
139  */
140 static inline u16 user_pcid(u16 asid)
141 {
142         u16 ret = kern_pcid(asid);
143 #ifdef CONFIG_PAGE_TABLE_ISOLATION
144         ret |= 1 << X86_CR3_PTI_PCID_USER_BIT;
145 #endif
146         return ret;
147 }
148
149 static inline unsigned long build_cr3(pgd_t *pgd, u16 asid)
150 {
151         if (static_cpu_has(X86_FEATURE_PCID)) {
152                 return __sme_pa(pgd) | kern_pcid(asid);
153         } else {
154                 VM_WARN_ON_ONCE(asid != 0);
155                 return __sme_pa(pgd);
156         }
157 }
158
159 static inline unsigned long build_cr3_noflush(pgd_t *pgd, u16 asid)
160 {
161         VM_WARN_ON_ONCE(asid > MAX_ASID_AVAILABLE);
162         /*
163          * Use boot_cpu_has() instead of this_cpu_has() as this function
164          * might be called during early boot. This should work even after
165          * boot because all CPU's the have same capabilities:
166          */
167         VM_WARN_ON_ONCE(!boot_cpu_has(X86_FEATURE_PCID));
168         return __sme_pa(pgd) | kern_pcid(asid) | CR3_NOFLUSH;
169 }
170
171 /*
172  * We get here when we do something requiring a TLB invalidation
173  * but could not go invalidate all of the contexts.  We do the
174  * necessary invalidation by clearing out the 'ctx_id' which
175  * forces a TLB flush when the context is loaded.
176  */
177 static void clear_asid_other(void)
178 {
179         u16 asid;
180
181         /*
182          * This is only expected to be set if we have disabled
183          * kernel _PAGE_GLOBAL pages.
184          */
185         if (!static_cpu_has(X86_FEATURE_PTI)) {
186                 WARN_ON_ONCE(1);
187                 return;
188         }
189
190         for (asid = 0; asid < TLB_NR_DYN_ASIDS; asid++) {
191                 /* Do not need to flush the current asid */
192                 if (asid == this_cpu_read(cpu_tlbstate.loaded_mm_asid))
193                         continue;
194                 /*
195                  * Make sure the next time we go to switch to
196                  * this asid, we do a flush:
197                  */
198                 this_cpu_write(cpu_tlbstate.ctxs[asid].ctx_id, 0);
199         }
200         this_cpu_write(cpu_tlbstate.invalidate_other, false);
201 }
202
203 atomic64_t last_mm_ctx_id = ATOMIC64_INIT(1);
204
205
206 static void choose_new_asid(struct mm_struct *next, u64 next_tlb_gen,
207                             u16 *new_asid, bool *need_flush)
208 {
209         u16 asid;
210
211         if (!static_cpu_has(X86_FEATURE_PCID)) {
212                 *new_asid = 0;
213                 *need_flush = true;
214                 return;
215         }
216
217         if (this_cpu_read(cpu_tlbstate.invalidate_other))
218                 clear_asid_other();
219
220         for (asid = 0; asid < TLB_NR_DYN_ASIDS; asid++) {
221                 if (this_cpu_read(cpu_tlbstate.ctxs[asid].ctx_id) !=
222                     next->context.ctx_id)
223                         continue;
224
225                 *new_asid = asid;
226                 *need_flush = (this_cpu_read(cpu_tlbstate.ctxs[asid].tlb_gen) <
227                                next_tlb_gen);
228                 return;
229         }
230
231         /*
232          * We don't currently own an ASID slot on this CPU.
233          * Allocate a slot.
234          */
235         *new_asid = this_cpu_add_return(cpu_tlbstate.next_asid, 1) - 1;
236         if (*new_asid >= TLB_NR_DYN_ASIDS) {
237                 *new_asid = 0;
238                 this_cpu_write(cpu_tlbstate.next_asid, 1);
239         }
240         *need_flush = true;
241 }
242
243 /*
244  * Given an ASID, flush the corresponding user ASID.  We can delay this
245  * until the next time we switch to it.
246  *
247  * See SWITCH_TO_USER_CR3.
248  */
249 static inline void invalidate_user_asid(u16 asid)
250 {
251         /* There is no user ASID if address space separation is off */
252         if (!IS_ENABLED(CONFIG_PAGE_TABLE_ISOLATION))
253                 return;
254
255         /*
256          * We only have a single ASID if PCID is off and the CR3
257          * write will have flushed it.
258          */
259         if (!cpu_feature_enabled(X86_FEATURE_PCID))
260                 return;
261
262         if (!static_cpu_has(X86_FEATURE_PTI))
263                 return;
264
265         __set_bit(kern_pcid(asid),
266                   (unsigned long *)this_cpu_ptr(&cpu_tlbstate.user_pcid_flush_mask));
267 }
268
269 static void load_new_mm_cr3(pgd_t *pgdir, u16 new_asid, bool need_flush)
270 {
271         unsigned long new_mm_cr3;
272
273         if (need_flush) {
274                 invalidate_user_asid(new_asid);
275                 new_mm_cr3 = build_cr3(pgdir, new_asid);
276         } else {
277                 new_mm_cr3 = build_cr3_noflush(pgdir, new_asid);
278         }
279
280         /*
281          * Caution: many callers of this function expect
282          * that load_cr3() is serializing and orders TLB
283          * fills with respect to the mm_cpumask writes.
284          */
285         write_cr3(new_mm_cr3);
286 }
287
288 void leave_mm(int cpu)
289 {
290         struct mm_struct *loaded_mm = this_cpu_read(cpu_tlbstate.loaded_mm);
291
292         /*
293          * It's plausible that we're in lazy TLB mode while our mm is init_mm.
294          * If so, our callers still expect us to flush the TLB, but there
295          * aren't any user TLB entries in init_mm to worry about.
296          *
297          * This needs to happen before any other sanity checks due to
298          * intel_idle's shenanigans.
299          */
300         if (loaded_mm == &init_mm)
301                 return;
302
303         /* Warn if we're not lazy. */
304         WARN_ON(!this_cpu_read(cpu_tlbstate.is_lazy));
305
306         switch_mm(NULL, &init_mm, NULL);
307 }
308 EXPORT_SYMBOL_GPL(leave_mm);
309
310 void switch_mm(struct mm_struct *prev, struct mm_struct *next,
311                struct task_struct *tsk)
312 {
313         unsigned long flags;
314
315         local_irq_save(flags);
316         switch_mm_irqs_off(prev, next, tsk);
317         local_irq_restore(flags);
318 }
319
320 static inline unsigned long mm_mangle_tif_spec_ib(struct task_struct *next)
321 {
322         unsigned long next_tif = task_thread_info(next)->flags;
323         unsigned long ibpb = (next_tif >> TIF_SPEC_IB) & LAST_USER_MM_IBPB;
324
325         return (unsigned long)next->mm | ibpb;
326 }
327
328 static void cond_ibpb(struct task_struct *next)
329 {
330         if (!next || !next->mm)
331                 return;
332
333         /*
334          * Both, the conditional and the always IBPB mode use the mm
335          * pointer to avoid the IBPB when switching between tasks of the
336          * same process. Using the mm pointer instead of mm->context.ctx_id
337          * opens a hypothetical hole vs. mm_struct reuse, which is more or
338          * less impossible to control by an attacker. Aside of that it
339          * would only affect the first schedule so the theoretically
340          * exposed data is not really interesting.
341          */
342         if (static_branch_likely(&switch_mm_cond_ibpb)) {
343                 unsigned long prev_mm, next_mm;
344
345                 /*
346                  * This is a bit more complex than the always mode because
347                  * it has to handle two cases:
348                  *
349                  * 1) Switch from a user space task (potential attacker)
350                  *    which has TIF_SPEC_IB set to a user space task
351                  *    (potential victim) which has TIF_SPEC_IB not set.
352                  *
353                  * 2) Switch from a user space task (potential attacker)
354                  *    which has TIF_SPEC_IB not set to a user space task
355                  *    (potential victim) which has TIF_SPEC_IB set.
356                  *
357                  * This could be done by unconditionally issuing IBPB when
358                  * a task which has TIF_SPEC_IB set is either scheduled in
359                  * or out. Though that results in two flushes when:
360                  *
361                  * - the same user space task is scheduled out and later
362                  *   scheduled in again and only a kernel thread ran in
363                  *   between.
364                  *
365                  * - a user space task belonging to the same process is
366                  *   scheduled in after a kernel thread ran in between
367                  *
368                  * - a user space task belonging to the same process is
369                  *   scheduled in immediately.
370                  *
371                  * Optimize this with reasonably small overhead for the
372                  * above cases. Mangle the TIF_SPEC_IB bit into the mm
373                  * pointer of the incoming task which is stored in
374                  * cpu_tlbstate.last_user_mm_ibpb for comparison.
375                  */
376                 next_mm = mm_mangle_tif_spec_ib(next);
377                 prev_mm = this_cpu_read(cpu_tlbstate.last_user_mm_ibpb);
378
379                 /*
380                  * Issue IBPB only if the mm's are different and one or
381                  * both have the IBPB bit set.
382                  */
383                 if (next_mm != prev_mm &&
384                     (next_mm | prev_mm) & LAST_USER_MM_IBPB)
385                         indirect_branch_prediction_barrier();
386
387                 this_cpu_write(cpu_tlbstate.last_user_mm_ibpb, next_mm);
388         }
389
390         if (static_branch_unlikely(&switch_mm_always_ibpb)) {
391                 /*
392                  * Only flush when switching to a user space task with a
393                  * different context than the user space task which ran
394                  * last on this CPU.
395                  */
396                 if (this_cpu_read(cpu_tlbstate.last_user_mm) != next->mm) {
397                         indirect_branch_prediction_barrier();
398                         this_cpu_write(cpu_tlbstate.last_user_mm, next->mm);
399                 }
400         }
401 }
402
403 #ifdef CONFIG_PERF_EVENTS
404 static inline void cr4_update_pce_mm(struct mm_struct *mm)
405 {
406         if (static_branch_unlikely(&rdpmc_always_available_key) ||
407             (!static_branch_unlikely(&rdpmc_never_available_key) &&
408              atomic_read(&mm->context.perf_rdpmc_allowed)))
409                 cr4_set_bits_irqsoff(X86_CR4_PCE);
410         else
411                 cr4_clear_bits_irqsoff(X86_CR4_PCE);
412 }
413
414 void cr4_update_pce(void *ignored)
415 {
416         cr4_update_pce_mm(this_cpu_read(cpu_tlbstate.loaded_mm));
417 }
418
419 #else
420 static inline void cr4_update_pce_mm(struct mm_struct *mm) { }
421 #endif
422
423 void switch_mm_irqs_off(struct mm_struct *prev, struct mm_struct *next,
424                         struct task_struct *tsk)
425 {
426         struct mm_struct *real_prev = this_cpu_read(cpu_tlbstate.loaded_mm);
427         u16 prev_asid = this_cpu_read(cpu_tlbstate.loaded_mm_asid);
428         bool was_lazy = this_cpu_read(cpu_tlbstate.is_lazy);
429         unsigned cpu = smp_processor_id();
430         u64 next_tlb_gen;
431         bool need_flush;
432         u16 new_asid;
433
434         /*
435          * NB: The scheduler will call us with prev == next when switching
436          * from lazy TLB mode to normal mode if active_mm isn't changing.
437          * When this happens, we don't assume that CR3 (and hence
438          * cpu_tlbstate.loaded_mm) matches next.
439          *
440          * NB: leave_mm() calls us with prev == NULL and tsk == NULL.
441          */
442
443         /* We don't want flush_tlb_func_* to run concurrently with us. */
444         if (IS_ENABLED(CONFIG_PROVE_LOCKING))
445                 WARN_ON_ONCE(!irqs_disabled());
446
447         /*
448          * Verify that CR3 is what we think it is.  This will catch
449          * hypothetical buggy code that directly switches to swapper_pg_dir
450          * without going through leave_mm() / switch_mm_irqs_off() or that
451          * does something like write_cr3(read_cr3_pa()).
452          *
453          * Only do this check if CONFIG_DEBUG_VM=y because __read_cr3()
454          * isn't free.
455          */
456 #ifdef CONFIG_DEBUG_VM
457         if (WARN_ON_ONCE(__read_cr3() != build_cr3(real_prev->pgd, prev_asid))) {
458                 /*
459                  * If we were to BUG here, we'd be very likely to kill
460                  * the system so hard that we don't see the call trace.
461                  * Try to recover instead by ignoring the error and doing
462                  * a global flush to minimize the chance of corruption.
463                  *
464                  * (This is far from being a fully correct recovery.
465                  *  Architecturally, the CPU could prefetch something
466                  *  back into an incorrect ASID slot and leave it there
467                  *  to cause trouble down the road.  It's better than
468                  *  nothing, though.)
469                  */
470                 __flush_tlb_all();
471         }
472 #endif
473         this_cpu_write(cpu_tlbstate.is_lazy, false);
474
475         /*
476          * The membarrier system call requires a full memory barrier and
477          * core serialization before returning to user-space, after
478          * storing to rq->curr. Writing to CR3 provides that full
479          * memory barrier and core serializing instruction.
480          */
481         if (real_prev == next) {
482                 VM_WARN_ON(this_cpu_read(cpu_tlbstate.ctxs[prev_asid].ctx_id) !=
483                            next->context.ctx_id);
484
485                 /*
486                  * Even in lazy TLB mode, the CPU should stay set in the
487                  * mm_cpumask. The TLB shootdown code can figure out from
488                  * from cpu_tlbstate.is_lazy whether or not to send an IPI.
489                  */
490                 if (WARN_ON_ONCE(real_prev != &init_mm &&
491                                  !cpumask_test_cpu(cpu, mm_cpumask(next))))
492                         cpumask_set_cpu(cpu, mm_cpumask(next));
493
494                 /*
495                  * If the CPU is not in lazy TLB mode, we are just switching
496                  * from one thread in a process to another thread in the same
497                  * process. No TLB flush required.
498                  */
499                 if (!was_lazy)
500                         return;
501
502                 /*
503                  * Read the tlb_gen to check whether a flush is needed.
504                  * If the TLB is up to date, just use it.
505                  * The barrier synchronizes with the tlb_gen increment in
506                  * the TLB shootdown code.
507                  */
508                 smp_mb();
509                 next_tlb_gen = atomic64_read(&next->context.tlb_gen);
510                 if (this_cpu_read(cpu_tlbstate.ctxs[prev_asid].tlb_gen) ==
511                                 next_tlb_gen)
512                         return;
513
514                 /*
515                  * TLB contents went out of date while we were in lazy
516                  * mode. Fall through to the TLB switching code below.
517                  */
518                 new_asid = prev_asid;
519                 need_flush = true;
520         } else {
521                 /*
522                  * Avoid user/user BTB poisoning by flushing the branch
523                  * predictor when switching between processes. This stops
524                  * one process from doing Spectre-v2 attacks on another.
525                  */
526                 cond_ibpb(tsk);
527
528                 /*
529                  * Stop remote flushes for the previous mm.
530                  * Skip kernel threads; we never send init_mm TLB flushing IPIs,
531                  * but the bitmap manipulation can cause cache line contention.
532                  */
533                 if (real_prev != &init_mm) {
534                         VM_WARN_ON_ONCE(!cpumask_test_cpu(cpu,
535                                                 mm_cpumask(real_prev)));
536                         cpumask_clear_cpu(cpu, mm_cpumask(real_prev));
537                 }
538
539                 /*
540                  * Start remote flushes and then read tlb_gen.
541                  */
542                 if (next != &init_mm)
543                         cpumask_set_cpu(cpu, mm_cpumask(next));
544                 next_tlb_gen = atomic64_read(&next->context.tlb_gen);
545
546                 choose_new_asid(next, next_tlb_gen, &new_asid, &need_flush);
547
548                 /* Let nmi_uaccess_okay() know that we're changing CR3. */
549                 this_cpu_write(cpu_tlbstate.loaded_mm, LOADED_MM_SWITCHING);
550                 barrier();
551         }
552
553         if (need_flush) {
554                 this_cpu_write(cpu_tlbstate.ctxs[new_asid].ctx_id, next->context.ctx_id);
555                 this_cpu_write(cpu_tlbstate.ctxs[new_asid].tlb_gen, next_tlb_gen);
556                 load_new_mm_cr3(next->pgd, new_asid, true);
557
558                 /*
559                  * NB: This gets called via leave_mm() in the idle path
560                  * where RCU functions differently.  Tracing normally
561                  * uses RCU, so we need to use the _rcuidle variant.
562                  *
563                  * (There is no good reason for this.  The idle code should
564                  *  be rearranged to call this before rcu_idle_enter().)
565                  */
566                 trace_tlb_flush_rcuidle(TLB_FLUSH_ON_TASK_SWITCH, TLB_FLUSH_ALL);
567         } else {
568                 /* The new ASID is already up to date. */
569                 load_new_mm_cr3(next->pgd, new_asid, false);
570
571                 /* See above wrt _rcuidle. */
572                 trace_tlb_flush_rcuidle(TLB_FLUSH_ON_TASK_SWITCH, 0);
573         }
574
575         /* Make sure we write CR3 before loaded_mm. */
576         barrier();
577
578         this_cpu_write(cpu_tlbstate.loaded_mm, next);
579         this_cpu_write(cpu_tlbstate.loaded_mm_asid, new_asid);
580
581         if (next != real_prev) {
582                 cr4_update_pce_mm(next);
583                 switch_ldt(real_prev, next);
584         }
585 }
586
587 /*
588  * Please ignore the name of this function.  It should be called
589  * switch_to_kernel_thread().
590  *
591  * enter_lazy_tlb() is a hint from the scheduler that we are entering a
592  * kernel thread or other context without an mm.  Acceptable implementations
593  * include doing nothing whatsoever, switching to init_mm, or various clever
594  * lazy tricks to try to minimize TLB flushes.
595  *
596  * The scheduler reserves the right to call enter_lazy_tlb() several times
597  * in a row.  It will notify us that we're going back to a real mm by
598  * calling switch_mm_irqs_off().
599  */
600 void enter_lazy_tlb(struct mm_struct *mm, struct task_struct *tsk)
601 {
602         if (this_cpu_read(cpu_tlbstate.loaded_mm) == &init_mm)
603                 return;
604
605         this_cpu_write(cpu_tlbstate.is_lazy, true);
606 }
607
608 /*
609  * Call this when reinitializing a CPU.  It fixes the following potential
610  * problems:
611  *
612  * - The ASID changed from what cpu_tlbstate thinks it is (most likely
613  *   because the CPU was taken down and came back up with CR3's PCID
614  *   bits clear.  CPU hotplug can do this.
615  *
616  * - The TLB contains junk in slots corresponding to inactive ASIDs.
617  *
618  * - The CPU went so far out to lunch that it may have missed a TLB
619  *   flush.
620  */
621 void initialize_tlbstate_and_flush(void)
622 {
623         int i;
624         struct mm_struct *mm = this_cpu_read(cpu_tlbstate.loaded_mm);
625         u64 tlb_gen = atomic64_read(&init_mm.context.tlb_gen);
626         unsigned long cr3 = __read_cr3();
627
628         /* Assert that CR3 already references the right mm. */
629         WARN_ON((cr3 & CR3_ADDR_MASK) != __pa(mm->pgd));
630
631         /*
632          * Assert that CR4.PCIDE is set if needed.  (CR4.PCIDE initialization
633          * doesn't work like other CR4 bits because it can only be set from
634          * long mode.)
635          */
636         WARN_ON(boot_cpu_has(X86_FEATURE_PCID) &&
637                 !(cr4_read_shadow() & X86_CR4_PCIDE));
638
639         /* Force ASID 0 and force a TLB flush. */
640         write_cr3(build_cr3(mm->pgd, 0));
641
642         /* Reinitialize tlbstate. */
643         this_cpu_write(cpu_tlbstate.last_user_mm_ibpb, LAST_USER_MM_IBPB);
644         this_cpu_write(cpu_tlbstate.loaded_mm_asid, 0);
645         this_cpu_write(cpu_tlbstate.next_asid, 1);
646         this_cpu_write(cpu_tlbstate.ctxs[0].ctx_id, mm->context.ctx_id);
647         this_cpu_write(cpu_tlbstate.ctxs[0].tlb_gen, tlb_gen);
648
649         for (i = 1; i < TLB_NR_DYN_ASIDS; i++)
650                 this_cpu_write(cpu_tlbstate.ctxs[i].ctx_id, 0);
651 }
652
653 /*
654  * flush_tlb_func_common()'s memory ordering requirement is that any
655  * TLB fills that happen after we flush the TLB are ordered after we
656  * read active_mm's tlb_gen.  We don't need any explicit barriers
657  * because all x86 flush operations are serializing and the
658  * atomic64_read operation won't be reordered by the compiler.
659  */
660 static void flush_tlb_func_common(const struct flush_tlb_info *f,
661                                   bool local, enum tlb_flush_reason reason)
662 {
663         /*
664          * We have three different tlb_gen values in here.  They are:
665          *
666          * - mm_tlb_gen:     the latest generation.
667          * - local_tlb_gen:  the generation that this CPU has already caught
668          *                   up to.
669          * - f->new_tlb_gen: the generation that the requester of the flush
670          *                   wants us to catch up to.
671          */
672         struct mm_struct *loaded_mm = this_cpu_read(cpu_tlbstate.loaded_mm);
673         u32 loaded_mm_asid = this_cpu_read(cpu_tlbstate.loaded_mm_asid);
674         u64 mm_tlb_gen = atomic64_read(&loaded_mm->context.tlb_gen);
675         u64 local_tlb_gen = this_cpu_read(cpu_tlbstate.ctxs[loaded_mm_asid].tlb_gen);
676
677         /* This code cannot presently handle being reentered. */
678         VM_WARN_ON(!irqs_disabled());
679
680         if (unlikely(loaded_mm == &init_mm))
681                 return;
682
683         VM_WARN_ON(this_cpu_read(cpu_tlbstate.ctxs[loaded_mm_asid].ctx_id) !=
684                    loaded_mm->context.ctx_id);
685
686         if (this_cpu_read(cpu_tlbstate.is_lazy)) {
687                 /*
688                  * We're in lazy mode.  We need to at least flush our
689                  * paging-structure cache to avoid speculatively reading
690                  * garbage into our TLB.  Since switching to init_mm is barely
691                  * slower than a minimal flush, just switch to init_mm.
692                  *
693                  * This should be rare, with native_flush_tlb_others skipping
694                  * IPIs to lazy TLB mode CPUs.
695                  */
696                 switch_mm_irqs_off(NULL, &init_mm, NULL);
697                 return;
698         }
699
700         if (unlikely(local_tlb_gen == mm_tlb_gen)) {
701                 /*
702                  * There's nothing to do: we're already up to date.  This can
703                  * happen if two concurrent flushes happen -- the first flush to
704                  * be handled can catch us all the way up, leaving no work for
705                  * the second flush.
706                  */
707                 trace_tlb_flush(reason, 0);
708                 return;
709         }
710
711         WARN_ON_ONCE(local_tlb_gen > mm_tlb_gen);
712         WARN_ON_ONCE(f->new_tlb_gen > mm_tlb_gen);
713
714         /*
715          * If we get to this point, we know that our TLB is out of date.
716          * This does not strictly imply that we need to flush (it's
717          * possible that f->new_tlb_gen <= local_tlb_gen), but we're
718          * going to need to flush in the very near future, so we might
719          * as well get it over with.
720          *
721          * The only question is whether to do a full or partial flush.
722          *
723          * We do a partial flush if requested and two extra conditions
724          * are met:
725          *
726          * 1. f->new_tlb_gen == local_tlb_gen + 1.  We have an invariant that
727          *    we've always done all needed flushes to catch up to
728          *    local_tlb_gen.  If, for example, local_tlb_gen == 2 and
729          *    f->new_tlb_gen == 3, then we know that the flush needed to bring
730          *    us up to date for tlb_gen 3 is the partial flush we're
731          *    processing.
732          *
733          *    As an example of why this check is needed, suppose that there
734          *    are two concurrent flushes.  The first is a full flush that
735          *    changes context.tlb_gen from 1 to 2.  The second is a partial
736          *    flush that changes context.tlb_gen from 2 to 3.  If they get
737          *    processed on this CPU in reverse order, we'll see
738          *     local_tlb_gen == 1, mm_tlb_gen == 3, and end != TLB_FLUSH_ALL.
739          *    If we were to use __flush_tlb_one_user() and set local_tlb_gen to
740          *    3, we'd be break the invariant: we'd update local_tlb_gen above
741          *    1 without the full flush that's needed for tlb_gen 2.
742          *
743          * 2. f->new_tlb_gen == mm_tlb_gen.  This is purely an optimiation.
744          *    Partial TLB flushes are not all that much cheaper than full TLB
745          *    flushes, so it seems unlikely that it would be a performance win
746          *    to do a partial flush if that won't bring our TLB fully up to
747          *    date.  By doing a full flush instead, we can increase
748          *    local_tlb_gen all the way to mm_tlb_gen and we can probably
749          *    avoid another flush in the very near future.
750          */
751         if (f->end != TLB_FLUSH_ALL &&
752             f->new_tlb_gen == local_tlb_gen + 1 &&
753             f->new_tlb_gen == mm_tlb_gen) {
754                 /* Partial flush */
755                 unsigned long nr_invalidate = (f->end - f->start) >> f->stride_shift;
756                 unsigned long addr = f->start;
757
758                 while (addr < f->end) {
759                         flush_tlb_one_user(addr);
760                         addr += 1UL << f->stride_shift;
761                 }
762                 if (local)
763                         count_vm_tlb_events(NR_TLB_LOCAL_FLUSH_ONE, nr_invalidate);
764                 trace_tlb_flush(reason, nr_invalidate);
765         } else {
766                 /* Full flush. */
767                 flush_tlb_local();
768                 if (local)
769                         count_vm_tlb_event(NR_TLB_LOCAL_FLUSH_ALL);
770                 trace_tlb_flush(reason, TLB_FLUSH_ALL);
771         }
772
773         /* Both paths above update our state to mm_tlb_gen. */
774         this_cpu_write(cpu_tlbstate.ctxs[loaded_mm_asid].tlb_gen, mm_tlb_gen);
775 }
776
777 static void flush_tlb_func_local(const void *info, enum tlb_flush_reason reason)
778 {
779         const struct flush_tlb_info *f = info;
780
781         flush_tlb_func_common(f, true, reason);
782 }
783
784 static void flush_tlb_func_remote(void *info)
785 {
786         const struct flush_tlb_info *f = info;
787
788         inc_irq_stat(irq_tlb_count);
789
790         if (f->mm && f->mm != this_cpu_read(cpu_tlbstate.loaded_mm))
791                 return;
792
793         count_vm_tlb_event(NR_TLB_REMOTE_FLUSH_RECEIVED);
794         flush_tlb_func_common(f, false, TLB_REMOTE_SHOOTDOWN);
795 }
796
797 static bool tlb_is_not_lazy(int cpu, void *data)
798 {
799         return !per_cpu(cpu_tlbstate.is_lazy, cpu);
800 }
801
802 STATIC_NOPV void native_flush_tlb_others(const struct cpumask *cpumask,
803                                          const struct flush_tlb_info *info)
804 {
805         count_vm_tlb_event(NR_TLB_REMOTE_FLUSH);
806         if (info->end == TLB_FLUSH_ALL)
807                 trace_tlb_flush(TLB_REMOTE_SEND_IPI, TLB_FLUSH_ALL);
808         else
809                 trace_tlb_flush(TLB_REMOTE_SEND_IPI,
810                                 (info->end - info->start) >> PAGE_SHIFT);
811
812         if (is_uv_system()) {
813                 /*
814                  * This whole special case is confused.  UV has a "Broadcast
815                  * Assist Unit", which seems to be a fancy way to send IPIs.
816                  * Back when x86 used an explicit TLB flush IPI, UV was
817                  * optimized to use its own mechanism.  These days, x86 uses
818                  * smp_call_function_many(), but UV still uses a manual IPI,
819                  * and that IPI's action is out of date -- it does a manual
820                  * flush instead of calling flush_tlb_func_remote().  This
821                  * means that the percpu tlb_gen variables won't be updated
822                  * and we'll do pointless flushes on future context switches.
823                  *
824                  * Rather than hooking native_flush_tlb_others() here, I think
825                  * that UV should be updated so that smp_call_function_many(),
826                  * etc, are optimal on UV.
827                  */
828                 cpumask = uv_flush_tlb_others(cpumask, info);
829                 if (cpumask)
830                         smp_call_function_many(cpumask, flush_tlb_func_remote,
831                                                (void *)info, 1);
832                 return;
833         }
834
835         /*
836          * If no page tables were freed, we can skip sending IPIs to
837          * CPUs in lazy TLB mode. They will flush the CPU themselves
838          * at the next context switch.
839          *
840          * However, if page tables are getting freed, we need to send the
841          * IPI everywhere, to prevent CPUs in lazy TLB mode from tripping
842          * up on the new contents of what used to be page tables, while
843          * doing a speculative memory access.
844          */
845         if (info->freed_tables)
846                 smp_call_function_many(cpumask, flush_tlb_func_remote,
847                                (void *)info, 1);
848         else
849                 on_each_cpu_cond_mask(tlb_is_not_lazy, flush_tlb_func_remote,
850                                 (void *)info, 1, cpumask);
851 }
852
853 void flush_tlb_others(const struct cpumask *cpumask,
854                       const struct flush_tlb_info *info)
855 {
856         __flush_tlb_others(cpumask, info);
857 }
858
859 /*
860  * See Documentation/x86/tlb.rst for details.  We choose 33
861  * because it is large enough to cover the vast majority (at
862  * least 95%) of allocations, and is small enough that we are
863  * confident it will not cause too much overhead.  Each single
864  * flush is about 100 ns, so this caps the maximum overhead at
865  * _about_ 3,000 ns.
866  *
867  * This is in units of pages.
868  */
869 unsigned long tlb_single_page_flush_ceiling __read_mostly = 33;
870
871 static DEFINE_PER_CPU_SHARED_ALIGNED(struct flush_tlb_info, flush_tlb_info);
872
873 #ifdef CONFIG_DEBUG_VM
874 static DEFINE_PER_CPU(unsigned int, flush_tlb_info_idx);
875 #endif
876
877 static inline struct flush_tlb_info *get_flush_tlb_info(struct mm_struct *mm,
878                         unsigned long start, unsigned long end,
879                         unsigned int stride_shift, bool freed_tables,
880                         u64 new_tlb_gen)
881 {
882         struct flush_tlb_info *info = this_cpu_ptr(&flush_tlb_info);
883
884 #ifdef CONFIG_DEBUG_VM
885         /*
886          * Ensure that the following code is non-reentrant and flush_tlb_info
887          * is not overwritten. This means no TLB flushing is initiated by
888          * interrupt handlers and machine-check exception handlers.
889          */
890         BUG_ON(this_cpu_inc_return(flush_tlb_info_idx) != 1);
891 #endif
892
893         info->start             = start;
894         info->end               = end;
895         info->mm                = mm;
896         info->stride_shift      = stride_shift;
897         info->freed_tables      = freed_tables;
898         info->new_tlb_gen       = new_tlb_gen;
899
900         return info;
901 }
902
903 static inline void put_flush_tlb_info(void)
904 {
905 #ifdef CONFIG_DEBUG_VM
906         /* Complete reentrency prevention checks */
907         barrier();
908         this_cpu_dec(flush_tlb_info_idx);
909 #endif
910 }
911
912 void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start,
913                                 unsigned long end, unsigned int stride_shift,
914                                 bool freed_tables)
915 {
916         struct flush_tlb_info *info;
917         u64 new_tlb_gen;
918         int cpu;
919
920         cpu = get_cpu();
921
922         /* Should we flush just the requested range? */
923         if ((end == TLB_FLUSH_ALL) ||
924             ((end - start) >> stride_shift) > tlb_single_page_flush_ceiling) {
925                 start = 0;
926                 end = TLB_FLUSH_ALL;
927         }
928
929         /* This is also a barrier that synchronizes with switch_mm(). */
930         new_tlb_gen = inc_mm_tlb_gen(mm);
931
932         info = get_flush_tlb_info(mm, start, end, stride_shift, freed_tables,
933                                   new_tlb_gen);
934
935         if (mm == this_cpu_read(cpu_tlbstate.loaded_mm)) {
936                 lockdep_assert_irqs_enabled();
937                 local_irq_disable();
938                 flush_tlb_func_local(info, TLB_LOCAL_MM_SHOOTDOWN);
939                 local_irq_enable();
940         }
941
942         if (cpumask_any_but(mm_cpumask(mm), cpu) < nr_cpu_ids)
943                 flush_tlb_others(mm_cpumask(mm), info);
944
945         put_flush_tlb_info();
946         put_cpu();
947 }
948
949
950 static void do_flush_tlb_all(void *info)
951 {
952         count_vm_tlb_event(NR_TLB_REMOTE_FLUSH_RECEIVED);
953         __flush_tlb_all();
954 }
955
956 void flush_tlb_all(void)
957 {
958         count_vm_tlb_event(NR_TLB_REMOTE_FLUSH);
959         on_each_cpu(do_flush_tlb_all, NULL, 1);
960 }
961
962 static void do_kernel_range_flush(void *info)
963 {
964         struct flush_tlb_info *f = info;
965         unsigned long addr;
966
967         /* flush range by one by one 'invlpg' */
968         for (addr = f->start; addr < f->end; addr += PAGE_SIZE)
969                 flush_tlb_one_kernel(addr);
970 }
971
972 void flush_tlb_kernel_range(unsigned long start, unsigned long end)
973 {
974         /* Balance as user space task's flush, a bit conservative */
975         if (end == TLB_FLUSH_ALL ||
976             (end - start) > tlb_single_page_flush_ceiling << PAGE_SHIFT) {
977                 on_each_cpu(do_flush_tlb_all, NULL, 1);
978         } else {
979                 struct flush_tlb_info *info;
980
981                 preempt_disable();
982                 info = get_flush_tlb_info(NULL, start, end, 0, false, 0);
983
984                 on_each_cpu(do_kernel_range_flush, info, 1);
985
986                 put_flush_tlb_info();
987                 preempt_enable();
988         }
989 }
990
991 /*
992  * This can be used from process context to figure out what the value of
993  * CR3 is without needing to do a (slow) __read_cr3().
994  *
995  * It's intended to be used for code like KVM that sneakily changes CR3
996  * and needs to restore it.  It needs to be used very carefully.
997  */
998 unsigned long __get_current_cr3_fast(void)
999 {
1000         unsigned long cr3 = build_cr3(this_cpu_read(cpu_tlbstate.loaded_mm)->pgd,
1001                 this_cpu_read(cpu_tlbstate.loaded_mm_asid));
1002
1003         /* For now, be very restrictive about when this can be called. */
1004         VM_WARN_ON(in_nmi() || preemptible());
1005
1006         VM_BUG_ON(cr3 != __read_cr3());
1007         return cr3;
1008 }
1009 EXPORT_SYMBOL_GPL(__get_current_cr3_fast);
1010
1011 /*
1012  * Flush one page in the kernel mapping
1013  */
1014 void flush_tlb_one_kernel(unsigned long addr)
1015 {
1016         count_vm_tlb_event(NR_TLB_LOCAL_FLUSH_ONE);
1017
1018         /*
1019          * If PTI is off, then __flush_tlb_one_user() is just INVLPG or its
1020          * paravirt equivalent.  Even with PCID, this is sufficient: we only
1021          * use PCID if we also use global PTEs for the kernel mapping, and
1022          * INVLPG flushes global translations across all address spaces.
1023          *
1024          * If PTI is on, then the kernel is mapped with non-global PTEs, and
1025          * __flush_tlb_one_user() will flush the given address for the current
1026          * kernel address space and for its usermode counterpart, but it does
1027          * not flush it for other address spaces.
1028          */
1029         flush_tlb_one_user(addr);
1030
1031         if (!static_cpu_has(X86_FEATURE_PTI))
1032                 return;
1033
1034         /*
1035          * See above.  We need to propagate the flush to all other address
1036          * spaces.  In principle, we only need to propagate it to kernelmode
1037          * address spaces, but the extra bookkeeping we would need is not
1038          * worth it.
1039          */
1040         this_cpu_write(cpu_tlbstate.invalidate_other, true);
1041 }
1042
1043 /*
1044  * Flush one page in the user mapping
1045  */
1046 STATIC_NOPV void native_flush_tlb_one_user(unsigned long addr)
1047 {
1048         u32 loaded_mm_asid = this_cpu_read(cpu_tlbstate.loaded_mm_asid);
1049
1050         asm volatile("invlpg (%0)" ::"r" (addr) : "memory");
1051
1052         if (!static_cpu_has(X86_FEATURE_PTI))
1053                 return;
1054
1055         /*
1056          * Some platforms #GP if we call invpcid(type=1/2) before CR4.PCIDE=1.
1057          * Just use invalidate_user_asid() in case we are called early.
1058          */
1059         if (!this_cpu_has(X86_FEATURE_INVPCID_SINGLE))
1060                 invalidate_user_asid(loaded_mm_asid);
1061         else
1062                 invpcid_flush_one(user_pcid(loaded_mm_asid), addr);
1063 }
1064
1065 void flush_tlb_one_user(unsigned long addr)
1066 {
1067         __flush_tlb_one_user(addr);
1068 }
1069
1070 /*
1071  * Flush everything
1072  */
1073 STATIC_NOPV void native_flush_tlb_global(void)
1074 {
1075         unsigned long cr4, flags;
1076
1077         if (static_cpu_has(X86_FEATURE_INVPCID)) {
1078                 /*
1079                  * Using INVPCID is considerably faster than a pair of writes
1080                  * to CR4 sandwiched inside an IRQ flag save/restore.
1081                  *
1082                  * Note, this works with CR4.PCIDE=0 or 1.
1083                  */
1084                 invpcid_flush_all();
1085                 return;
1086         }
1087
1088         /*
1089          * Read-modify-write to CR4 - protect it from preemption and
1090          * from interrupts. (Use the raw variant because this code can
1091          * be called from deep inside debugging code.)
1092          */
1093         raw_local_irq_save(flags);
1094
1095         cr4 = this_cpu_read(cpu_tlbstate.cr4);
1096         /* toggle PGE */
1097         native_write_cr4(cr4 ^ X86_CR4_PGE);
1098         /* write old PGE again and flush TLBs */
1099         native_write_cr4(cr4);
1100
1101         raw_local_irq_restore(flags);
1102 }
1103
1104 /*
1105  * Flush the entire current user mapping
1106  */
1107 STATIC_NOPV void native_flush_tlb_local(void)
1108 {
1109         /*
1110          * Preemption or interrupts must be disabled to protect the access
1111          * to the per CPU variable and to prevent being preempted between
1112          * read_cr3() and write_cr3().
1113          */
1114         WARN_ON_ONCE(preemptible());
1115
1116         invalidate_user_asid(this_cpu_read(cpu_tlbstate.loaded_mm_asid));
1117
1118         /* If current->mm == NULL then the read_cr3() "borrows" an mm */
1119         native_write_cr3(__native_read_cr3());
1120 }
1121
1122 void flush_tlb_local(void)
1123 {
1124         __flush_tlb_local();
1125 }
1126
1127 /*
1128  * Flush everything
1129  */
1130 void __flush_tlb_all(void)
1131 {
1132         /*
1133          * This is to catch users with enabled preemption and the PGE feature
1134          * and don't trigger the warning in __native_flush_tlb().
1135          */
1136         VM_WARN_ON_ONCE(preemptible());
1137
1138         if (boot_cpu_has(X86_FEATURE_PGE)) {
1139                 __flush_tlb_global();
1140         } else {
1141                 /*
1142                  * !PGE -> !PCID (setup_pcid()), thus every flush is total.
1143                  */
1144                 flush_tlb_local();
1145         }
1146 }
1147 EXPORT_SYMBOL_GPL(__flush_tlb_all);
1148
1149 /*
1150  * arch_tlbbatch_flush() performs a full TLB flush regardless of the active mm.
1151  * This means that the 'struct flush_tlb_info' that describes which mappings to
1152  * flush is actually fixed. We therefore set a single fixed struct and use it in
1153  * arch_tlbbatch_flush().
1154  */
1155 static const struct flush_tlb_info full_flush_tlb_info = {
1156         .mm = NULL,
1157         .start = 0,
1158         .end = TLB_FLUSH_ALL,
1159 };
1160
1161 void arch_tlbbatch_flush(struct arch_tlbflush_unmap_batch *batch)
1162 {
1163         int cpu = get_cpu();
1164
1165         if (cpumask_test_cpu(cpu, &batch->cpumask)) {
1166                 lockdep_assert_irqs_enabled();
1167                 local_irq_disable();
1168                 flush_tlb_func_local(&full_flush_tlb_info, TLB_LOCAL_SHOOTDOWN);
1169                 local_irq_enable();
1170         }
1171
1172         if (cpumask_any_but(&batch->cpumask, cpu) < nr_cpu_ids)
1173                 flush_tlb_others(&batch->cpumask, &full_flush_tlb_info);
1174
1175         cpumask_clear(&batch->cpumask);
1176
1177         put_cpu();
1178 }
1179
1180 /*
1181  * Blindly accessing user memory from NMI context can be dangerous
1182  * if we're in the middle of switching the current user task or
1183  * switching the loaded mm.  It can also be dangerous if we
1184  * interrupted some kernel code that was temporarily using a
1185  * different mm.
1186  */
1187 bool nmi_uaccess_okay(void)
1188 {
1189         struct mm_struct *loaded_mm = this_cpu_read(cpu_tlbstate.loaded_mm);
1190         struct mm_struct *current_mm = current->mm;
1191
1192         VM_WARN_ON_ONCE(!loaded_mm);
1193
1194         /*
1195          * The condition we want to check is
1196          * current_mm->pgd == __va(read_cr3_pa()).  This may be slow, though,
1197          * if we're running in a VM with shadow paging, and nmi_uaccess_okay()
1198          * is supposed to be reasonably fast.
1199          *
1200          * Instead, we check the almost equivalent but somewhat conservative
1201          * condition below, and we rely on the fact that switch_mm_irqs_off()
1202          * sets loaded_mm to LOADED_MM_SWITCHING before writing to CR3.
1203          */
1204         if (loaded_mm != current_mm)
1205                 return false;
1206
1207         VM_WARN_ON_ONCE(current_mm->pgd != __va(read_cr3_pa()));
1208
1209         return true;
1210 }
1211
1212 static ssize_t tlbflush_read_file(struct file *file, char __user *user_buf,
1213                              size_t count, loff_t *ppos)
1214 {
1215         char buf[32];
1216         unsigned int len;
1217
1218         len = sprintf(buf, "%ld\n", tlb_single_page_flush_ceiling);
1219         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1220 }
1221
1222 static ssize_t tlbflush_write_file(struct file *file,
1223                  const char __user *user_buf, size_t count, loff_t *ppos)
1224 {
1225         char buf[32];
1226         ssize_t len;
1227         int ceiling;
1228
1229         len = min(count, sizeof(buf) - 1);
1230         if (copy_from_user(buf, user_buf, len))
1231                 return -EFAULT;
1232
1233         buf[len] = '\0';
1234         if (kstrtoint(buf, 0, &ceiling))
1235                 return -EINVAL;
1236
1237         if (ceiling < 0)
1238                 return -EINVAL;
1239
1240         tlb_single_page_flush_ceiling = ceiling;
1241         return count;
1242 }
1243
1244 static const struct file_operations fops_tlbflush = {
1245         .read = tlbflush_read_file,
1246         .write = tlbflush_write_file,
1247         .llseek = default_llseek,
1248 };
1249
1250 static int __init create_tlb_single_page_flush_ceiling(void)
1251 {
1252         debugfs_create_file("tlb_single_page_flush_ceiling", S_IRUSR | S_IWUSR,
1253                             arch_debugfs_dir, NULL, &fops_tlbflush);
1254         return 0;
1255 }
1256 late_initcall(create_tlb_single_page_flush_ceiling);