]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - sys/amd64/amd64/mp_machdep.c
Upgrade our copies of clang, llvm, lld, lldb, compiler-rt and libc++ to
[FreeBSD/FreeBSD.git] / sys / amd64 / amd64 / mp_machdep.c
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 1996, by Steve Passe
5  * Copyright (c) 2003, by Peter Wemm
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. The name of the developer may NOT be used to endorse or promote products
14  *    derived from this software without specific prior written permission.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  */
28
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31
32 #include "opt_cpu.h"
33 #include "opt_ddb.h"
34 #include "opt_kstack_pages.h"
35 #include "opt_sched.h"
36 #include "opt_smp.h"
37
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/bus.h>
41 #include <sys/cpuset.h>
42 #ifdef GPROF 
43 #include <sys/gmon.h>
44 #endif
45 #include <sys/kernel.h>
46 #include <sys/ktr.h>
47 #include <sys/lock.h>
48 #include <sys/malloc.h>
49 #include <sys/memrange.h>
50 #include <sys/mutex.h>
51 #include <sys/pcpu.h>
52 #include <sys/proc.h>
53 #include <sys/sched.h>
54 #include <sys/smp.h>
55 #include <sys/sysctl.h>
56
57 #include <vm/vm.h>
58 #include <vm/vm_param.h>
59 #include <vm/pmap.h>
60 #include <vm/vm_kern.h>
61 #include <vm/vm_extern.h>
62
63 #include <x86/apicreg.h>
64 #include <machine/clock.h>
65 #include <machine/cputypes.h>
66 #include <machine/cpufunc.h>
67 #include <x86/mca.h>
68 #include <machine/md_var.h>
69 #include <machine/pcb.h>
70 #include <machine/psl.h>
71 #include <machine/smp.h>
72 #include <machine/specialreg.h>
73 #include <machine/tss.h>
74 #include <machine/cpu.h>
75 #include <x86/init.h>
76
77 #define WARMBOOT_TARGET         0
78 #define WARMBOOT_OFF            (KERNBASE + 0x0467)
79 #define WARMBOOT_SEG            (KERNBASE + 0x0469)
80
81 #define CMOS_REG                (0x70)
82 #define CMOS_DATA               (0x71)
83 #define BIOS_RESET              (0x0f)
84 #define BIOS_WARM               (0x0a)
85
86 #define GiB(v)                  (v ## ULL << 30)
87
88 extern  struct pcpu __pcpu[];
89
90 /* Temporary variables for init_secondary()  */
91 char *doublefault_stack;
92 char *mce_stack;
93 char *nmi_stack;
94 char *dbg_stack;
95
96 /*
97  * Local data and functions.
98  */
99
100 static int      start_ap(int apic_id);
101
102 /*
103  * Calculate usable address in base memory for AP trampoline code.
104  */
105 void
106 mp_bootaddress(vm_paddr_t *physmap, unsigned int *physmap_idx)
107 {
108         unsigned int i;
109         bool allocated;
110
111         alloc_ap_trampoline(physmap, physmap_idx);
112
113         allocated = false;
114         for (i = *physmap_idx; i <= *physmap_idx; i -= 2) {
115                 /*
116                  * Find a memory region big enough below the 4GB
117                  * boundary to store the initial page tables.  Region
118                  * must be mapped by the direct map.
119                  *
120                  * Note that it needs to be aligned to a page
121                  * boundary.
122                  */
123                 if (physmap[i] >= GiB(4) || physmap[i + 1] -
124                     round_page(physmap[i]) < PAGE_SIZE * 3 ||
125                     atop(physmap[i + 1]) > Maxmem)
126                         continue;
127
128                 allocated = true;
129                 mptramp_pagetables = round_page(physmap[i]);
130                 physmap[i] = round_page(physmap[i]) + (PAGE_SIZE * 3);
131                 if (physmap[i] == physmap[i + 1] && *physmap_idx != 0) {
132                         memmove(&physmap[i], &physmap[i + 2],
133                             sizeof(*physmap) * (*physmap_idx - i + 2));
134                         *physmap_idx -= 2;
135                 }
136                 break;
137         }
138
139         if (!allocated) {
140                 mptramp_pagetables = trunc_page(boot_address) - (PAGE_SIZE * 3);
141                 if (bootverbose)
142                         printf(
143 "Cannot find enough space for the initial AP page tables, placing them at %#x",
144                             mptramp_pagetables);
145         }
146 }
147
148 /*
149  * Initialize the IPI handlers and start up the AP's.
150  */
151 void
152 cpu_mp_start(void)
153 {
154         int i;
155
156         /* Initialize the logical ID to APIC ID table. */
157         for (i = 0; i < MAXCPU; i++) {
158                 cpu_apic_ids[i] = -1;
159                 cpu_ipi_pending[i] = 0;
160         }
161
162         /* Install an inter-CPU IPI for TLB invalidation */
163         if (pmap_pcid_enabled) {
164                 if (invpcid_works) {
165                         setidt(IPI_INVLTLB, pti ?
166                             IDTVEC(invltlb_invpcid_pti_pti) :
167                             IDTVEC(invltlb_invpcid_nopti), SDT_SYSIGT,
168                             SEL_KPL, 0);
169                         setidt(IPI_INVLPG, pti ? IDTVEC(invlpg_invpcid_pti) :
170                             IDTVEC(invlpg_invpcid), SDT_SYSIGT, SEL_KPL, 0);
171                         setidt(IPI_INVLRNG, pti ? IDTVEC(invlrng_invpcid_pti) :
172                             IDTVEC(invlrng_invpcid), SDT_SYSIGT, SEL_KPL, 0);
173                 } else {
174                         setidt(IPI_INVLTLB, pti ? IDTVEC(invltlb_pcid_pti) :
175                             IDTVEC(invltlb_pcid), SDT_SYSIGT, SEL_KPL, 0);
176                         setidt(IPI_INVLPG, pti ? IDTVEC(invlpg_pcid_pti) :
177                             IDTVEC(invlpg_pcid), SDT_SYSIGT, SEL_KPL, 0);
178                         setidt(IPI_INVLRNG, pti ? IDTVEC(invlrng_pcid_pti) :
179                             IDTVEC(invlrng_pcid), SDT_SYSIGT, SEL_KPL, 0);
180                 }
181         } else {
182                 setidt(IPI_INVLTLB, pti ? IDTVEC(invltlb_pti) : IDTVEC(invltlb),
183                     SDT_SYSIGT, SEL_KPL, 0);
184                 setidt(IPI_INVLPG, pti ? IDTVEC(invlpg_pti) : IDTVEC(invlpg),
185                     SDT_SYSIGT, SEL_KPL, 0);
186                 setidt(IPI_INVLRNG, pti ? IDTVEC(invlrng_pti) : IDTVEC(invlrng),
187                     SDT_SYSIGT, SEL_KPL, 0);
188         }
189
190         /* Install an inter-CPU IPI for cache invalidation. */
191         setidt(IPI_INVLCACHE, pti ? IDTVEC(invlcache_pti) : IDTVEC(invlcache),
192             SDT_SYSIGT, SEL_KPL, 0);
193
194         /* Install an inter-CPU IPI for all-CPU rendezvous */
195         setidt(IPI_RENDEZVOUS, pti ? IDTVEC(rendezvous_pti) :
196             IDTVEC(rendezvous), SDT_SYSIGT, SEL_KPL, 0);
197
198         /* Install generic inter-CPU IPI handler */
199         setidt(IPI_BITMAP_VECTOR, pti ? IDTVEC(ipi_intr_bitmap_handler_pti) :
200             IDTVEC(ipi_intr_bitmap_handler), SDT_SYSIGT, SEL_KPL, 0);
201
202         /* Install an inter-CPU IPI for CPU stop/restart */
203         setidt(IPI_STOP, pti ? IDTVEC(cpustop_pti) : IDTVEC(cpustop),
204             SDT_SYSIGT, SEL_KPL, 0);
205
206         /* Install an inter-CPU IPI for CPU suspend/resume */
207         setidt(IPI_SUSPEND, pti ? IDTVEC(cpususpend_pti) : IDTVEC(cpususpend),
208             SDT_SYSIGT, SEL_KPL, 0);
209
210         /* Set boot_cpu_id if needed. */
211         if (boot_cpu_id == -1) {
212                 boot_cpu_id = PCPU_GET(apic_id);
213                 cpu_info[boot_cpu_id].cpu_bsp = 1;
214         } else
215                 KASSERT(boot_cpu_id == PCPU_GET(apic_id),
216                     ("BSP's APIC ID doesn't match boot_cpu_id"));
217
218         /* Probe logical/physical core configuration. */
219         topo_probe();
220
221         assign_cpu_ids();
222
223         /* Start each Application Processor */
224         init_ops.start_all_aps();
225
226         set_interrupt_apic_ids();
227 }
228
229
230 /*
231  * AP CPU's call this to initialize themselves.
232  */
233 void
234 init_secondary(void)
235 {
236         struct pcpu *pc;
237         struct nmi_pcpu *np;
238         u_int64_t cr0;
239         int cpu, gsel_tss, x;
240         struct region_descriptor ap_gdt;
241
242         /* Set by the startup code for us to use */
243         cpu = bootAP;
244
245         /* Init tss */
246         common_tss[cpu] = common_tss[0];
247         common_tss[cpu].tss_iobase = sizeof(struct amd64tss) +
248             IOPERM_BITMAP_SIZE;
249         common_tss[cpu].tss_ist1 = (long)&doublefault_stack[PAGE_SIZE];
250
251         /* The NMI stack runs on IST2. */
252         np = ((struct nmi_pcpu *) &nmi_stack[PAGE_SIZE]) - 1;
253         common_tss[cpu].tss_ist2 = (long) np;
254
255         /* The MC# stack runs on IST3. */
256         np = ((struct nmi_pcpu *) &mce_stack[PAGE_SIZE]) - 1;
257         common_tss[cpu].tss_ist3 = (long) np;
258
259         /* The DB# stack runs on IST4. */
260         np = ((struct nmi_pcpu *) &dbg_stack[PAGE_SIZE]) - 1;
261         common_tss[cpu].tss_ist4 = (long) np;
262
263         /* Prepare private GDT */
264         gdt_segs[GPROC0_SEL].ssd_base = (long) &common_tss[cpu];
265         for (x = 0; x < NGDT; x++) {
266                 if (x != GPROC0_SEL && x != (GPROC0_SEL + 1) &&
267                     x != GUSERLDT_SEL && x != (GUSERLDT_SEL + 1))
268                         ssdtosd(&gdt_segs[x], &gdt[NGDT * cpu + x]);
269         }
270         ssdtosyssd(&gdt_segs[GPROC0_SEL],
271             (struct system_segment_descriptor *)&gdt[NGDT * cpu + GPROC0_SEL]);
272         ap_gdt.rd_limit = NGDT * sizeof(gdt[0]) - 1;
273         ap_gdt.rd_base =  (long) &gdt[NGDT * cpu];
274         lgdt(&ap_gdt);                  /* does magic intra-segment return */
275
276         /* Get per-cpu data */
277         pc = &__pcpu[cpu];
278
279         /* prime data page for it to use */
280         pcpu_init(pc, cpu, sizeof(struct pcpu));
281         dpcpu_init(dpcpu, cpu);
282         pc->pc_apic_id = cpu_apic_ids[cpu];
283         pc->pc_prvspace = pc;
284         pc->pc_curthread = 0;
285         pc->pc_tssp = &common_tss[cpu];
286         pc->pc_commontssp = &common_tss[cpu];
287         pc->pc_rsp0 = 0;
288         pc->pc_pti_rsp0 = (((vm_offset_t)&pc->pc_pti_stack +
289             PC_PTI_STACK_SZ * sizeof(uint64_t)) & ~0xful);
290         pc->pc_tss = (struct system_segment_descriptor *)&gdt[NGDT * cpu +
291             GPROC0_SEL];
292         pc->pc_fs32p = &gdt[NGDT * cpu + GUFS32_SEL];
293         pc->pc_gs32p = &gdt[NGDT * cpu + GUGS32_SEL];
294         pc->pc_ldt = (struct system_segment_descriptor *)&gdt[NGDT * cpu +
295             GUSERLDT_SEL];
296         pc->pc_curpmap = kernel_pmap;
297         pc->pc_pcid_gen = 1;
298         pc->pc_pcid_next = PMAP_PCID_KERN + 1;
299         common_tss[cpu].tss_rsp0 = 0;
300
301         /* Save the per-cpu pointer for use by the NMI handler. */
302         np = ((struct nmi_pcpu *) &nmi_stack[PAGE_SIZE]) - 1;
303         np->np_pcpu = (register_t) pc;
304
305         /* Save the per-cpu pointer for use by the MC# handler. */
306         np = ((struct nmi_pcpu *) &mce_stack[PAGE_SIZE]) - 1;
307         np->np_pcpu = (register_t) pc;
308
309         /* Save the per-cpu pointer for use by the DB# handler. */
310         np = ((struct nmi_pcpu *) &dbg_stack[PAGE_SIZE]) - 1;
311         np->np_pcpu = (register_t) pc;
312
313         wrmsr(MSR_FSBASE, 0);           /* User value */
314         wrmsr(MSR_GSBASE, (u_int64_t)pc);
315         wrmsr(MSR_KGSBASE, (u_int64_t)pc);      /* XXX User value while we're in the kernel */
316         fix_cpuid();
317
318         lidt(&r_idt);
319
320         gsel_tss = GSEL(GPROC0_SEL, SEL_KPL);
321         ltr(gsel_tss);
322
323         /*
324          * Set to a known state:
325          * Set by mpboot.s: CR0_PG, CR0_PE
326          * Set by cpu_setregs: CR0_NE, CR0_MP, CR0_TS, CR0_WP, CR0_AM
327          */
328         cr0 = rcr0();
329         cr0 &= ~(CR0_CD | CR0_NW | CR0_EM);
330         load_cr0(cr0);
331
332         amd64_conf_fast_syscall();
333
334         /* signal our startup to the BSP. */
335         mp_naps++;
336
337         /* Spin until the BSP releases the AP's. */
338         while (atomic_load_acq_int(&aps_ready) == 0)
339                 ia32_pause();
340
341         init_secondary_tail();
342 }
343
344 /*******************************************************************
345  * local functions and data
346  */
347
348 /*
349  * start each AP in our list
350  */
351 int
352 native_start_all_aps(void)
353 {
354         u_int64_t *pt4, *pt3, *pt2;
355         u_int32_t mpbioswarmvec;
356         int apic_id, cpu, i;
357         u_char mpbiosreason;
358
359         mtx_init(&ap_boot_mtx, "ap boot", NULL, MTX_SPIN);
360
361         /* copy the AP 1st level boot code */
362         bcopy(mptramp_start, (void *)PHYS_TO_DMAP(boot_address), bootMP_size);
363
364         /* Locate the page tables, they'll be below the trampoline */
365         pt4 = (uint64_t *)PHYS_TO_DMAP(mptramp_pagetables);
366         pt3 = pt4 + (PAGE_SIZE) / sizeof(u_int64_t);
367         pt2 = pt3 + (PAGE_SIZE) / sizeof(u_int64_t);
368
369         /* Create the initial 1GB replicated page tables */
370         for (i = 0; i < 512; i++) {
371                 /* Each slot of the level 4 pages points to the same level 3 page */
372                 pt4[i] = (u_int64_t)(uintptr_t)(mptramp_pagetables + PAGE_SIZE);
373                 pt4[i] |= PG_V | PG_RW | PG_U;
374
375                 /* Each slot of the level 3 pages points to the same level 2 page */
376                 pt3[i] = (u_int64_t)(uintptr_t)(mptramp_pagetables + (2 * PAGE_SIZE));
377                 pt3[i] |= PG_V | PG_RW | PG_U;
378
379                 /* The level 2 page slots are mapped with 2MB pages for 1GB. */
380                 pt2[i] = i * (2 * 1024 * 1024);
381                 pt2[i] |= PG_V | PG_RW | PG_PS | PG_U;
382         }
383
384         /* save the current value of the warm-start vector */
385         mpbioswarmvec = *((u_int32_t *) WARMBOOT_OFF);
386         outb(CMOS_REG, BIOS_RESET);
387         mpbiosreason = inb(CMOS_DATA);
388
389         /* setup a vector to our boot code */
390         *((volatile u_short *) WARMBOOT_OFF) = WARMBOOT_TARGET;
391         *((volatile u_short *) WARMBOOT_SEG) = (boot_address >> 4);
392         outb(CMOS_REG, BIOS_RESET);
393         outb(CMOS_DATA, BIOS_WARM);     /* 'warm-start' */
394
395         /* start each AP */
396         for (cpu = 1; cpu < mp_ncpus; cpu++) {
397                 apic_id = cpu_apic_ids[cpu];
398
399                 /* allocate and set up an idle stack data page */
400                 bootstacks[cpu] = (void *)kmem_malloc(kernel_arena,
401                     kstack_pages * PAGE_SIZE, M_WAITOK | M_ZERO);
402                 doublefault_stack = (char *)kmem_malloc(kernel_arena,
403                     PAGE_SIZE, M_WAITOK | M_ZERO);
404                 mce_stack = (char *)kmem_malloc(kernel_arena, PAGE_SIZE,
405                     M_WAITOK | M_ZERO);
406                 nmi_stack = (char *)kmem_malloc(kernel_arena, PAGE_SIZE,
407                     M_WAITOK | M_ZERO);
408                 dbg_stack = (char *)kmem_malloc(kernel_arena, PAGE_SIZE,
409                     M_WAITOK | M_ZERO);
410                 dpcpu = (void *)kmem_malloc(kernel_arena, DPCPU_SIZE,
411                     M_WAITOK | M_ZERO);
412
413                 bootSTK = (char *)bootstacks[cpu] + kstack_pages * PAGE_SIZE - 8;
414                 bootAP = cpu;
415
416                 /* attempt to start the Application Processor */
417                 if (!start_ap(apic_id)) {
418                         /* restore the warmstart vector */
419                         *(u_int32_t *) WARMBOOT_OFF = mpbioswarmvec;
420                         panic("AP #%d (PHY# %d) failed!", cpu, apic_id);
421                 }
422
423                 CPU_SET(cpu, &all_cpus);        /* record AP in CPU map */
424         }
425
426         /* restore the warmstart vector */
427         *(u_int32_t *) WARMBOOT_OFF = mpbioswarmvec;
428
429         outb(CMOS_REG, BIOS_RESET);
430         outb(CMOS_DATA, mpbiosreason);
431
432         /* number of APs actually started */
433         return mp_naps;
434 }
435
436
437 /*
438  * This function starts the AP (application processor) identified
439  * by the APIC ID 'physicalCpu'.  It does quite a "song and dance"
440  * to accomplish this.  This is necessary because of the nuances
441  * of the different hardware we might encounter.  It isn't pretty,
442  * but it seems to work.
443  */
444 static int
445 start_ap(int apic_id)
446 {
447         int vector, ms;
448         int cpus;
449
450         /* calculate the vector */
451         vector = (boot_address >> 12) & 0xff;
452
453         /* used as a watchpoint to signal AP startup */
454         cpus = mp_naps;
455
456         ipi_startup(apic_id, vector);
457
458         /* Wait up to 5 seconds for it to start. */
459         for (ms = 0; ms < 5000; ms++) {
460                 if (mp_naps > cpus)
461                         return 1;       /* return SUCCESS */
462                 DELAY(1000);
463         }
464         return 0;               /* return FAILURE */
465 }
466
467 void
468 invltlb_invpcid_handler(void)
469 {
470         struct invpcid_descr d;
471         uint32_t generation;
472
473 #ifdef COUNT_XINVLTLB_HITS
474         xhits_gbl[PCPU_GET(cpuid)]++;
475 #endif /* COUNT_XINVLTLB_HITS */
476 #ifdef COUNT_IPIS
477         (*ipi_invltlb_counts[PCPU_GET(cpuid)])++;
478 #endif /* COUNT_IPIS */
479
480         generation = smp_tlb_generation;
481         d.pcid = smp_tlb_pmap->pm_pcids[PCPU_GET(cpuid)].pm_pcid;
482         d.pad = 0;
483         d.addr = 0;
484         invpcid(&d, smp_tlb_pmap == kernel_pmap ? INVPCID_CTXGLOB :
485             INVPCID_CTX);
486         PCPU_SET(smp_tlb_done, generation);
487 }
488
489 void
490 invltlb_invpcid_pti_handler(void)
491 {
492         struct invpcid_descr d;
493         uint32_t generation;
494
495 #ifdef COUNT_XINVLTLB_HITS
496         xhits_gbl[PCPU_GET(cpuid)]++;
497 #endif /* COUNT_XINVLTLB_HITS */
498 #ifdef COUNT_IPIS
499         (*ipi_invltlb_counts[PCPU_GET(cpuid)])++;
500 #endif /* COUNT_IPIS */
501
502         generation = smp_tlb_generation;
503         d.pcid = smp_tlb_pmap->pm_pcids[PCPU_GET(cpuid)].pm_pcid;
504         d.pad = 0;
505         d.addr = 0;
506         if (smp_tlb_pmap == kernel_pmap) {
507                 /*
508                  * This invalidation actually needs to clear kernel
509                  * mappings from the TLB in the current pmap, but
510                  * since we were asked for the flush in the kernel
511                  * pmap, achieve it by performing global flush.
512                  */
513                 invpcid(&d, INVPCID_CTXGLOB);
514         } else {
515                 invpcid(&d, INVPCID_CTX);
516                 d.pcid |= PMAP_PCID_USER_PT;
517                 invpcid(&d, INVPCID_CTX);
518         }
519         PCPU_SET(smp_tlb_done, generation);
520 }
521
522 void
523 invltlb_pcid_handler(void)
524 {
525         uint64_t kcr3, ucr3;
526         uint32_t generation, pcid;
527   
528 #ifdef COUNT_XINVLTLB_HITS
529         xhits_gbl[PCPU_GET(cpuid)]++;
530 #endif /* COUNT_XINVLTLB_HITS */
531 #ifdef COUNT_IPIS
532         (*ipi_invltlb_counts[PCPU_GET(cpuid)])++;
533 #endif /* COUNT_IPIS */
534
535         generation = smp_tlb_generation;        /* Overlap with serialization */
536         if (smp_tlb_pmap == kernel_pmap) {
537                 invltlb_glob();
538         } else {
539                 /*
540                  * The current pmap might not be equal to
541                  * smp_tlb_pmap.  The clearing of the pm_gen in
542                  * pmap_invalidate_all() takes care of TLB
543                  * invalidation when switching to the pmap on this
544                  * CPU.
545                  */
546                 if (PCPU_GET(curpmap) == smp_tlb_pmap) {
547                         pcid = smp_tlb_pmap->pm_pcids[PCPU_GET(cpuid)].pm_pcid;
548                         kcr3 = smp_tlb_pmap->pm_cr3 | pcid;
549                         ucr3 = smp_tlb_pmap->pm_ucr3;
550                         if (ucr3 != PMAP_NO_CR3) {
551                                 ucr3 |= PMAP_PCID_USER_PT | pcid;
552                                 pmap_pti_pcid_invalidate(ucr3, kcr3);
553                         } else
554                                 load_cr3(kcr3);
555                 }
556         }
557         PCPU_SET(smp_tlb_done, generation);
558 }
559
560 void
561 invlpg_invpcid_handler(void)
562 {
563         struct invpcid_descr d;
564         uint32_t generation;
565
566 #ifdef COUNT_XINVLTLB_HITS
567         xhits_pg[PCPU_GET(cpuid)]++;
568 #endif /* COUNT_XINVLTLB_HITS */
569 #ifdef COUNT_IPIS
570         (*ipi_invlpg_counts[PCPU_GET(cpuid)])++;
571 #endif /* COUNT_IPIS */
572
573         generation = smp_tlb_generation;        /* Overlap with serialization */
574         invlpg(smp_tlb_addr1);
575         if (smp_tlb_pmap->pm_ucr3 != PMAP_NO_CR3) {
576                 d.pcid = smp_tlb_pmap->pm_pcids[PCPU_GET(cpuid)].pm_pcid |
577                     PMAP_PCID_USER_PT;
578                 d.pad = 0;
579                 d.addr = smp_tlb_addr1;
580                 invpcid(&d, INVPCID_ADDR);
581         }
582         PCPU_SET(smp_tlb_done, generation);
583 }
584
585 void
586 invlpg_pcid_handler(void)
587 {
588         uint64_t kcr3, ucr3;
589         uint32_t generation;
590         uint32_t pcid;
591
592 #ifdef COUNT_XINVLTLB_HITS
593         xhits_pg[PCPU_GET(cpuid)]++;
594 #endif /* COUNT_XINVLTLB_HITS */
595 #ifdef COUNT_IPIS
596         (*ipi_invlpg_counts[PCPU_GET(cpuid)])++;
597 #endif /* COUNT_IPIS */
598
599         generation = smp_tlb_generation;        /* Overlap with serialization */
600         invlpg(smp_tlb_addr1);
601         if (smp_tlb_pmap == PCPU_GET(curpmap) &&
602             (ucr3 = smp_tlb_pmap->pm_ucr3) != PMAP_NO_CR3) {
603                 pcid = smp_tlb_pmap->pm_pcids[PCPU_GET(cpuid)].pm_pcid;
604                 kcr3 = smp_tlb_pmap->pm_cr3 | pcid | CR3_PCID_SAVE;
605                 ucr3 |= pcid | PMAP_PCID_USER_PT | CR3_PCID_SAVE;
606                 pmap_pti_pcid_invlpg(ucr3, kcr3, smp_tlb_addr1);
607         }
608         PCPU_SET(smp_tlb_done, generation);
609 }
610
611 void
612 invlrng_invpcid_handler(void)
613 {
614         struct invpcid_descr d;
615         vm_offset_t addr, addr2;
616         uint32_t generation;
617
618 #ifdef COUNT_XINVLTLB_HITS
619         xhits_rng[PCPU_GET(cpuid)]++;
620 #endif /* COUNT_XINVLTLB_HITS */
621 #ifdef COUNT_IPIS
622         (*ipi_invlrng_counts[PCPU_GET(cpuid)])++;
623 #endif /* COUNT_IPIS */
624
625         addr = smp_tlb_addr1;
626         addr2 = smp_tlb_addr2;
627         generation = smp_tlb_generation;        /* Overlap with serialization */
628         do {
629                 invlpg(addr);
630                 addr += PAGE_SIZE;
631         } while (addr < addr2);
632         if (smp_tlb_pmap->pm_ucr3 != PMAP_NO_CR3) {
633                 d.pcid = smp_tlb_pmap->pm_pcids[PCPU_GET(cpuid)].pm_pcid |
634                     PMAP_PCID_USER_PT;
635                 d.pad = 0;
636                 d.addr = smp_tlb_addr1;
637                 do {
638                         invpcid(&d, INVPCID_ADDR);
639                         d.addr += PAGE_SIZE;
640                 } while (d.addr < addr2);
641         }
642         PCPU_SET(smp_tlb_done, generation);
643 }
644
645 void
646 invlrng_pcid_handler(void)
647 {
648         vm_offset_t addr, addr2;
649         uint64_t kcr3, ucr3;
650         uint32_t generation;
651         uint32_t pcid;
652
653 #ifdef COUNT_XINVLTLB_HITS
654         xhits_rng[PCPU_GET(cpuid)]++;
655 #endif /* COUNT_XINVLTLB_HITS */
656 #ifdef COUNT_IPIS
657         (*ipi_invlrng_counts[PCPU_GET(cpuid)])++;
658 #endif /* COUNT_IPIS */
659
660         addr = smp_tlb_addr1;
661         addr2 = smp_tlb_addr2;
662         generation = smp_tlb_generation;        /* Overlap with serialization */
663         do {
664                 invlpg(addr);
665                 addr += PAGE_SIZE;
666         } while (addr < addr2);
667         if (smp_tlb_pmap == PCPU_GET(curpmap) &&
668             (ucr3 = smp_tlb_pmap->pm_ucr3) != PMAP_NO_CR3) {
669                 pcid = smp_tlb_pmap->pm_pcids[PCPU_GET(cpuid)].pm_pcid;
670                 kcr3 = smp_tlb_pmap->pm_cr3 | pcid | CR3_PCID_SAVE;
671                 ucr3 |= pcid | PMAP_PCID_USER_PT | CR3_PCID_SAVE;
672                 pmap_pti_pcid_invlrng(ucr3, kcr3, smp_tlb_addr1, addr2);
673         }
674         PCPU_SET(smp_tlb_done, generation);
675 }