sys/x86/x86/mp_x86.c

   1 /*-
   2  * Copyright (c) 1996, by Steve Passe
   3  * Copyright (c) 2003, by Peter Wemm
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. The name of the developer may NOT be used to endorse or promote products
  12  *    derived from this software without specific prior written permission.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #ifdef __i386__
  31 #include "opt_apic.h"
  32 #endif
  33 #include "opt_cpu.h"
  34 #include "opt_kstack_pages.h"
  35 #include "opt_pmap.h"
  36 #include "opt_sched.h"
  37 #include "opt_smp.h"
  38
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/bus.h>
  42 #include <sys/cons.h>   /* cngetc() */
  43 #include <sys/cpuset.h>
  44 #include <sys/csan.h>
  45 #ifdef GPROF
  46 #include <sys/gmon.h>
  47 #endif
  48 #include <sys/kdb.h>
  49 #include <sys/kernel.h>
  50 #include <sys/ktr.h>
  51 #include <sys/lock.h>
  52 #include <sys/malloc.h>
  53 #include <sys/memrange.h>
  54 #include <sys/mutex.h>
  55 #include <sys/pcpu.h>
  56 #include <sys/proc.h>
  57 #include <sys/sched.h>
  58 #include <sys/smp.h>
  59 #include <sys/sysctl.h>
  60
  61 #include <vm/vm.h>
  62 #include <vm/vm_param.h>
  63 #include <vm/pmap.h>
  64 #include <vm/vm_kern.h>
  65 #include <vm/vm_extern.h>
  66 #include <vm/vm_map.h>
  67
  68 #include <x86/apicreg.h>
  69 #include <machine/clock.h>
  70 #include <machine/cpu.h>
  71 #include <machine/cputypes.h>
  72 #include <x86/mca.h>
  73 #include <machine/md_var.h>
  74 #include <machine/pcb.h>
  75 #include <machine/psl.h>
  76 #include <machine/smp.h>
  77 #include <machine/specialreg.h>
  78 #include <x86/ucode.h>
  79
  80 static MALLOC_DEFINE(M_CPUS, "cpus", "CPU items");
  81
  82 /* lock region used by kernel profiling */
  83 int     mcount_lock;
  84
  85 int     mp_naps;                /* # of Applications processors */
  86 int     boot_cpu_id = -1;       /* designated BSP */
  87
  88 /* AP uses this during bootstrap.  Do not staticize.  */
  89 char *bootSTK;
  90 int bootAP;
  91
  92 /* Free these after use */
  93 void *bootstacks[MAXCPU];
  94 void *dpcpu;
  95
  96 struct pcb stoppcbs[MAXCPU];
  97 struct susppcb **susppcbs;
  98
  99 #ifdef COUNT_IPIS
 100 /* Interrupt counts. */
 101 static u_long *ipi_preempt_counts[MAXCPU];
 102 static u_long *ipi_ast_counts[MAXCPU];
 103 u_long *ipi_invltlb_counts[MAXCPU];
 104 u_long *ipi_invlrng_counts[MAXCPU];
 105 u_long *ipi_invlpg_counts[MAXCPU];
 106 u_long *ipi_invlcache_counts[MAXCPU];
 107 u_long *ipi_rendezvous_counts[MAXCPU];
 108 static u_long *ipi_hardclock_counts[MAXCPU];
 109 #endif
 110
 111 /* Default cpu_ops implementation. */
 112 struct cpu_ops cpu_ops;
 113
 114 /*
 115  * Local data and functions.
 116  */
 117
 118 static volatile cpuset_t ipi_stop_nmi_pending;
 119
 120 volatile cpuset_t resuming_cpus;
 121 volatile cpuset_t toresume_cpus;
 122
 123 /* used to hold the AP's until we are ready to release them */
 124 struct mtx ap_boot_mtx;
 125
 126 /* Set to 1 once we're ready to let the APs out of the pen. */
 127 volatile int aps_ready = 0;
 128
 129 /*
 130  * Store data from cpu_add() until later in the boot when we actually setup
 131  * the APs.
 132  */
 133 struct cpu_info *cpu_info;
 134 int *apic_cpuids;
 135 int cpu_apic_ids[MAXCPU];
 136 _Static_assert(MAXCPU <= MAX_APIC_ID,
 137     "MAXCPU cannot be larger that MAX_APIC_ID");
 138 _Static_assert(xAPIC_MAX_APIC_ID <= MAX_APIC_ID,
 139     "xAPIC_MAX_APIC_ID cannot be larger that MAX_APIC_ID");
 140
 141 static void     release_aps(void *dummy);
 142 static void     cpustop_handler_post(u_int cpu);
 143
 144 static int      hyperthreading_allowed = 1;
 145 SYSCTL_INT(_machdep, OID_AUTO, hyperthreading_allowed, CTLFLAG_RDTUN,
 146         &hyperthreading_allowed, 0, "Use Intel HTT logical CPUs");
 147
 148 static int      hyperthreading_intr_allowed = 0;
 149 SYSCTL_INT(_machdep, OID_AUTO, hyperthreading_intr_allowed, CTLFLAG_RDTUN,
 150         &hyperthreading_intr_allowed, 0,
 151         "Allow interrupts on HTT logical CPUs");
 152
 153 static struct topo_node topo_root;
 154
 155 static int pkg_id_shift;
 156 static int node_id_shift;
 157 static int core_id_shift;
 158 static int disabled_cpus;
 159
 160 struct cache_info {
 161         int     id_shift;
 162         int     present;
 163 } static caches[MAX_CACHE_LEVELS];
 164
 165 unsigned int boot_address;
 166
 167 static bool stop_mwait = false;
 168 SYSCTL_BOOL(_machdep, OID_AUTO, stop_mwait, CTLFLAG_RWTUN, &stop_mwait, 0,
 169     "Use MONITOR/MWAIT when stopping CPU, if available");
 170
 171 #define MiB(v)  (v ## ULL << 20)
 172
 173 void
 174 mem_range_AP_init(void)
 175 {
 176
 177         if (mem_range_softc.mr_op && mem_range_softc.mr_op->initAP)
 178                 mem_range_softc.mr_op->initAP(&mem_range_softc);
 179 }
 180
 181 /*
 182  * Round up to the next power of two, if necessary, and then
 183  * take log2.
 184  * Returns -1 if argument is zero.
 185  */
 186 static __inline int
 187 mask_width(u_int x)
 188 {
 189
 190         return (fls(x << (1 - powerof2(x))) - 1);
 191 }
 192
 193 /*
 194  * Add a cache level to the cache topology description.
 195  */
 196 static int
 197 add_deterministic_cache(int type, int level, int share_count)
 198 {
 199
 200         if (type == 0)
 201                 return (0);
 202         if (type > 3) {
 203                 printf("unexpected cache type %d\n", type);
 204                 return (1);
 205         }
 206         if (type == 2) /* ignore instruction cache */
 207                 return (1);
 208         if (level == 0 || level > MAX_CACHE_LEVELS) {
 209                 printf("unexpected cache level %d\n", type);
 210                 return (1);
 211         }
 212
 213         if (caches[level - 1].present) {
 214                 printf("WARNING: multiple entries for L%u data cache\n", level);
 215                 printf("%u => %u\n", caches[level - 1].id_shift,
 216                     mask_width(share_count));
 217         }
 218         caches[level - 1].id_shift = mask_width(share_count);
 219         caches[level - 1].present = 1;
 220
 221         if (caches[level - 1].id_shift > pkg_id_shift) {
 222                 printf("WARNING: L%u data cache covers more "
 223                     "APIC IDs than a package (%u > %u)\n", level,
 224                     caches[level - 1].id_shift, pkg_id_shift);
 225                 caches[level - 1].id_shift = pkg_id_shift;
 226         }
 227         if (caches[level - 1].id_shift < core_id_shift) {
 228                 printf("WARNING: L%u data cache covers fewer "
 229                     "APIC IDs than a core (%u < %u)\n", level,
 230                     caches[level - 1].id_shift, core_id_shift);
 231                 caches[level - 1].id_shift = core_id_shift;
 232         }
 233
 234         return (1);
 235 }
 236
 237 /*
 238  * Determine topology of processing units and caches for AMD CPUs.
 239  * See:
 240  *  - AMD CPUID Specification (Publication # 25481)
 241  *  - BKDG for AMD NPT Family 0Fh Processors (Publication # 32559)
 242  *  - BKDG For AMD Family 10h Processors (Publication # 31116)
 243  *  - BKDG For AMD Family 15h Models 00h-0Fh Processors (Publication # 42301)
 244  *  - BKDG For AMD Family 16h Models 00h-0Fh Processors (Publication # 48751)
 245  *  - PPR For AMD Family 17h Models 00h-0Fh Processors (Publication # 54945)
 246  */
 247 static void
 248 topo_probe_amd(void)
 249 {
 250         u_int p[4];
 251         uint64_t v;
 252         int level;
 253         int nodes_per_socket;
 254         int share_count;
 255         int type;
 256         int i;
 257
 258         /* No multi-core capability. */
 259         if ((amd_feature2 & AMDID2_CMP) == 0)
 260                 return;
 261
 262         /* For families 10h and newer. */
 263         pkg_id_shift = (cpu_procinfo2 & AMDID_COREID_SIZE) >>
 264             AMDID_COREID_SIZE_SHIFT;
 265
 266         /* For 0Fh family. */
 267         if (pkg_id_shift == 0)
 268                 pkg_id_shift =
 269                     mask_width((cpu_procinfo2 & AMDID_CMP_CORES) + 1);
 270
 271         /*
 272          * Families prior to 16h define the following value as
 273          * cores per compute unit and we don't really care about the AMD
 274          * compute units at the moment.  Perhaps we should treat them as
 275          * cores and cores within the compute units as hardware threads,
 276          * but that's up for debate.
 277          * Later families define the value as threads per compute unit,
 278          * so we are following AMD's nomenclature here.
 279          */
 280         if ((amd_feature2 & AMDID2_TOPOLOGY) != 0 &&
 281             CPUID_TO_FAMILY(cpu_id) >= 0x16) {
 282                 cpuid_count(0x8000001e, 0, p);
 283                 share_count = ((p[1] >> 8) & 0xff) + 1;
 284                 core_id_shift = mask_width(share_count);
 285
 286                 /*
 287                  * For Zen (17h), gather Nodes per Processor.  Each node is a
 288                  * Zeppelin die; TR and EPYC CPUs will have multiple dies per
 289                  * package.  Communication latency between dies is higher than
 290                  * within them.
 291                  */
 292                 nodes_per_socket = ((p[2] >> 8) & 0x7) + 1;
 293                 node_id_shift = pkg_id_shift - mask_width(nodes_per_socket);
 294         }
 295
 296         if ((amd_feature2 & AMDID2_TOPOLOGY) != 0) {
 297                 for (i = 0; ; i++) {
 298                         cpuid_count(0x8000001d, i, p);
 299                         type = p[0] & 0x1f;
 300                         level = (p[0] >> 5) & 0x7;
 301                         share_count = 1 + ((p[0] >> 14) & 0xfff);
 302
 303                         if (!add_deterministic_cache(type, level, share_count))
 304                                 break;
 305                 }
 306         } else {
 307                 if (cpu_exthigh >= 0x80000005) {
 308                         cpuid_count(0x80000005, 0, p);
 309                         if (((p[2] >> 24) & 0xff) != 0) {
 310                                 caches[0].id_shift = 0;
 311                                 caches[0].present = 1;
 312                         }
 313                 }
 314                 if (cpu_exthigh >= 0x80000006) {
 315                         cpuid_count(0x80000006, 0, p);
 316                         if (((p[2] >> 16) & 0xffff) != 0) {
 317                                 caches[1].id_shift = 0;
 318                                 caches[1].present = 1;
 319                         }
 320                         if (((p[3] >> 18) & 0x3fff) != 0) {
 321                                 nodes_per_socket = 1;
 322                                 if ((amd_feature2 & AMDID2_NODE_ID) != 0) {
 323                                         /*
 324                                          * Handle multi-node processors that
 325                                          * have multiple chips, each with its
 326                                          * own L3 cache, on the same die.
 327                                          */
 328                                         v = rdmsr(0xc001100c);
 329                                         nodes_per_socket = 1 + ((v >> 3) & 0x7);
 330                                 }
 331                                 caches[2].id_shift =
 332                                     pkg_id_shift - mask_width(nodes_per_socket);
 333                                 caches[2].present = 1;
 334                         }
 335                 }
 336         }
 337 }
 338
 339 /*
 340  * Determine topology of processing units for Intel CPUs
 341  * using CPUID Leaf 1 and Leaf 4, if supported.
 342  * See:
 343  *  - Intel 64 Architecture Processor Topology Enumeration
 344  *  - Intel 64 and IA-32 ArchitecturesSoftware Developer’s Manual,
 345  *    Volume 3A: System Programming Guide, PROGRAMMING CONSIDERATIONS
 346  *    FOR HARDWARE MULTI-THREADING CAPABLE PROCESSORS
 347  */
 348 static void
 349 topo_probe_intel_0x4(void)
 350 {
 351         u_int p[4];
 352         int max_cores;
 353         int max_logical;
 354
 355         /* Both zero and one here mean one logical processor per package. */
 356         max_logical = (cpu_feature & CPUID_HTT) != 0 ?
 357             (cpu_procinfo & CPUID_HTT_CORES) >> 16 : 1;
 358         if (max_logical <= 1)
 359                 return;
 360
 361         if (cpu_high >= 0x4) {
 362                 cpuid_count(0x04, 0, p);
 363                 max_cores = ((p[0] >> 26) & 0x3f) + 1;
 364         } else
 365                 max_cores = 1;
 366
 367         core_id_shift = mask_width(max_logical/max_cores);
 368         KASSERT(core_id_shift >= 0,
 369             ("intel topo: max_cores > max_logical\n"));
 370         pkg_id_shift = core_id_shift + mask_width(max_cores);
 371 }
 372
 373 /*
 374  * Determine topology of processing units for Intel CPUs
 375  * using CPUID Leaf 11, if supported.
 376  * See:
 377  *  - Intel 64 Architecture Processor Topology Enumeration
 378  *  - Intel 64 and IA-32 ArchitecturesSoftware Developer’s Manual,
 379  *    Volume 3A: System Programming Guide, PROGRAMMING CONSIDERATIONS
 380  *    FOR HARDWARE MULTI-THREADING CAPABLE PROCESSORS
 381  */
 382 static void
 383 topo_probe_intel_0xb(void)
 384 {
 385         u_int p[4];
 386         int bits;
 387         int type;
 388         int i;
 389
 390         /* Fall back if CPU leaf 11 doesn't really exist. */
 391         cpuid_count(0x0b, 0, p);
 392         if (p[1] == 0) {
 393                 topo_probe_intel_0x4();
 394                 return;
 395         }
 396
 397         /* We only support three levels for now. */
 398         for (i = 0; ; i++) {
 399                 cpuid_count(0x0b, i, p);
 400
 401                 bits = p[0] & 0x1f;
 402                 type = (p[2] >> 8) & 0xff;
 403
 404                 if (type == 0)
 405                         break;
 406
 407                 /* TODO: check for duplicate (re-)assignment */
 408                 if (type == CPUID_TYPE_SMT)
 409                         core_id_shift = bits;
 410                 else if (type == CPUID_TYPE_CORE)
 411                         pkg_id_shift = bits;
 412                 else
 413                         printf("unknown CPU level type %d\n", type);
 414         }
 415
 416         if (pkg_id_shift < core_id_shift) {
 417                 printf("WARNING: core covers more APIC IDs than a package\n");
 418                 core_id_shift = pkg_id_shift;
 419         }
 420 }
 421
 422 /*
 423  * Determine topology of caches for Intel CPUs.
 424  * See:
 425  *  - Intel 64 Architecture Processor Topology Enumeration
 426  *  - Intel 64 and IA-32 Architectures Software Developer’s Manual
 427  *    Volume 2A: Instruction Set Reference, A-M,
 428  *    CPUID instruction
 429  */
 430 static void
 431 topo_probe_intel_caches(void)
 432 {
 433         u_int p[4];
 434         int level;
 435         int share_count;
 436         int type;
 437         int i;
 438
 439         if (cpu_high < 0x4) {
 440                 /*
 441                  * Available cache level and sizes can be determined
 442                  * via CPUID leaf 2, but that requires a huge table of hardcoded
 443                  * values, so for now just assume L1 and L2 caches potentially
 444                  * shared only by HTT processing units, if HTT is present.
 445                  */
 446                 caches[0].id_shift = pkg_id_shift;
 447                 caches[0].present = 1;
 448                 caches[1].id_shift = pkg_id_shift;
 449                 caches[1].present = 1;
 450                 return;
 451         }
 452
 453         for (i = 0; ; i++) {
 454                 cpuid_count(0x4, i, p);
 455                 type = p[0] & 0x1f;
 456                 level = (p[0] >> 5) & 0x7;
 457                 share_count = 1 + ((p[0] >> 14) & 0xfff);
 458
 459                 if (!add_deterministic_cache(type, level, share_count))
 460                         break;
 461         }
 462 }
 463
 464 /*
 465  * Determine topology of processing units and caches for Intel CPUs.
 466  * See:
 467  *  - Intel 64 Architecture Processor Topology Enumeration
 468  */
 469 static void
 470 topo_probe_intel(void)
 471 {
 472
 473         /*
 474          * Note that 0x1 <= cpu_high < 4 case should be
 475          * compatible with topo_probe_intel_0x4() logic when
 476          * CPUID.1:EBX[23:16] > 0 (cpu_cores will be 1)
 477          * or it should trigger the fallback otherwise.
 478          */
 479         if (cpu_high >= 0xb)
 480                 topo_probe_intel_0xb();
 481         else if (cpu_high >= 0x1)
 482                 topo_probe_intel_0x4();
 483
 484         topo_probe_intel_caches();
 485 }
 486
 487 /*
 488  * Topology information is queried only on BSP, on which this
 489  * code runs and for which it can query CPUID information.
 490  * Then topology is extrapolated on all packages using an
 491  * assumption that APIC ID to hardware component ID mapping is
 492  * homogenious.
 493  * That doesn't necesserily imply that the topology is uniform.
 494  */
 495 void
 496 topo_probe(void)
 497 {
 498         static int cpu_topo_probed = 0;
 499         struct x86_topo_layer {
 500                 int type;
 501                 int subtype;
 502                 int id_shift;
 503         } topo_layers[MAX_CACHE_LEVELS + 4];
 504         struct topo_node *parent;
 505         struct topo_node *node;
 506         int layer;
 507         int nlayers;
 508         int node_id;
 509         int i;
 510
 511         if (cpu_topo_probed)
 512                 return;
 513
 514         CPU_ZERO(&logical_cpus_mask);
 515
 516         if (mp_ncpus <= 1)
 517                 ; /* nothing */
 518         else if (cpu_vendor_id == CPU_VENDOR_AMD)
 519                 topo_probe_amd();
 520         else if (cpu_vendor_id == CPU_VENDOR_INTEL)
 521                 topo_probe_intel();
 522
 523         KASSERT(pkg_id_shift >= core_id_shift,
 524             ("bug in APIC topology discovery"));
 525
 526         nlayers = 0;
 527         bzero(topo_layers, sizeof(topo_layers));
 528
 529         topo_layers[nlayers].type = TOPO_TYPE_PKG;
 530         topo_layers[nlayers].id_shift = pkg_id_shift;
 531         if (bootverbose)
 532                 printf("Package ID shift: %u\n", topo_layers[nlayers].id_shift);
 533         nlayers++;
 534
 535         if (pkg_id_shift > node_id_shift && node_id_shift != 0) {
 536                 topo_layers[nlayers].type = TOPO_TYPE_GROUP;
 537                 topo_layers[nlayers].id_shift = node_id_shift;
 538                 if (bootverbose)
 539                         printf("Node ID shift: %u\n",
 540                             topo_layers[nlayers].id_shift);
 541                 nlayers++;
 542         }
 543
 544         /*
 545          * Consider all caches to be within a package/chip
 546          * and "in front" of all sub-components like
 547          * cores and hardware threads.
 548          */
 549         for (i = MAX_CACHE_LEVELS - 1; i >= 0; --i) {
 550                 if (caches[i].present) {
 551                         if (node_id_shift != 0)
 552                                 KASSERT(caches[i].id_shift <= node_id_shift,
 553                                         ("bug in APIC topology discovery"));
 554                         KASSERT(caches[i].id_shift <= pkg_id_shift,
 555                                 ("bug in APIC topology discovery"));
 556                         KASSERT(caches[i].id_shift >= core_id_shift,
 557                                 ("bug in APIC topology discovery"));
 558
 559                         topo_layers[nlayers].type = TOPO_TYPE_CACHE;
 560                         topo_layers[nlayers].subtype = i + 1;
 561                         topo_layers[nlayers].id_shift = caches[i].id_shift;
 562                         if (bootverbose)
 563                                 printf("L%u cache ID shift: %u\n",
 564                                     topo_layers[nlayers].subtype,
 565                                     topo_layers[nlayers].id_shift);
 566                         nlayers++;
 567                 }
 568         }
 569
 570         if (pkg_id_shift > core_id_shift) {
 571                 topo_layers[nlayers].type = TOPO_TYPE_CORE;
 572                 topo_layers[nlayers].id_shift = core_id_shift;
 573                 if (bootverbose)
 574                         printf("Core ID shift: %u\n",
 575                             topo_layers[nlayers].id_shift);
 576                 nlayers++;
 577         }
 578
 579         topo_layers[nlayers].type = TOPO_TYPE_PU;
 580         topo_layers[nlayers].id_shift = 0;
 581         nlayers++;
 582
 583         topo_init_root(&topo_root);
 584         for (i = 0; i <= max_apic_id; ++i) {
 585                 if (!cpu_info[i].cpu_present)
 586                         continue;
 587
 588                 parent = &topo_root;
 589                 for (layer = 0; layer < nlayers; ++layer) {
 590                         node_id = i >> topo_layers[layer].id_shift;
 591                         parent = topo_add_node_by_hwid(parent, node_id,
 592                             topo_layers[layer].type,
 593                             topo_layers[layer].subtype);
 594                 }
 595         }
 596
 597         parent = &topo_root;
 598         for (layer = 0; layer < nlayers; ++layer) {
 599                 node_id = boot_cpu_id >> topo_layers[layer].id_shift;
 600                 node = topo_find_node_by_hwid(parent, node_id,
 601                     topo_layers[layer].type,
 602                     topo_layers[layer].subtype);
 603                 topo_promote_child(node);
 604                 parent = node;
 605         }
 606
 607         cpu_topo_probed = 1;
 608 }
 609
 610 /*
 611  * Assign logical CPU IDs to local APICs.
 612  */
 613 void
 614 assign_cpu_ids(void)
 615 {
 616         struct topo_node *node;
 617         u_int smt_mask;
 618         int nhyper;
 619
 620         smt_mask = (1u << core_id_shift) - 1;
 621
 622         /*
 623          * Assign CPU IDs to local APIC IDs and disable any CPUs
 624          * beyond MAXCPU.  CPU 0 is always assigned to the BSP.
 625          */
 626         mp_ncpus = 0;
 627         nhyper = 0;
 628         TOPO_FOREACH(node, &topo_root) {
 629                 if (node->type != TOPO_TYPE_PU)
 630                         continue;
 631
 632                 if ((node->hwid & smt_mask) != (boot_cpu_id & smt_mask))
 633                         cpu_info[node->hwid].cpu_hyperthread = 1;
 634
 635                 if (resource_disabled("lapic", node->hwid)) {
 636                         if (node->hwid != boot_cpu_id)
 637                                 cpu_info[node->hwid].cpu_disabled = 1;
 638                         else
 639                                 printf("Cannot disable BSP, APIC ID = %d\n",
 640                                     node->hwid);
 641                 }
 642
 643                 if (!hyperthreading_allowed &&
 644                     cpu_info[node->hwid].cpu_hyperthread)
 645                         cpu_info[node->hwid].cpu_disabled = 1;
 646
 647                 if (mp_ncpus >= MAXCPU)
 648                         cpu_info[node->hwid].cpu_disabled = 1;
 649
 650                 if (cpu_info[node->hwid].cpu_disabled) {
 651                         disabled_cpus++;
 652                         continue;
 653                 }
 654
 655                 if (cpu_info[node->hwid].cpu_hyperthread)
 656                         nhyper++;
 657
 658                 cpu_apic_ids[mp_ncpus] = node->hwid;
 659                 apic_cpuids[node->hwid] = mp_ncpus;
 660                 topo_set_pu_id(node, mp_ncpus);
 661                 mp_ncpus++;
 662         }
 663
 664         KASSERT(mp_maxid >= mp_ncpus - 1,
 665             ("%s: counters out of sync: max %d, count %d", __func__, mp_maxid,
 666             mp_ncpus));
 667
 668         mp_ncores = mp_ncpus - nhyper;
 669         smp_threads_per_core = mp_ncpus / mp_ncores;
 670 }
 671
 672 /*
 673  * Print various information about the SMP system hardware and setup.
 674  */
 675 void
 676 cpu_mp_announce(void)
 677 {
 678         struct topo_node *node;
 679         const char *hyperthread;
 680         struct topo_analysis topology;
 681
 682         printf("FreeBSD/SMP: ");
 683         if (topo_analyze(&topo_root, 1, &topology)) {
 684                 printf("%d package(s)", topology.entities[TOPO_LEVEL_PKG]);
 685                 if (topology.entities[TOPO_LEVEL_GROUP] > 1)
 686                         printf(" x %d groups",
 687                             topology.entities[TOPO_LEVEL_GROUP]);
 688                 if (topology.entities[TOPO_LEVEL_CACHEGROUP] > 1)
 689                         printf(" x %d cache groups",
 690                             topology.entities[TOPO_LEVEL_CACHEGROUP]);
 691                 if (topology.entities[TOPO_LEVEL_CORE] > 0)
 692                         printf(" x %d core(s)",
 693                             topology.entities[TOPO_LEVEL_CORE]);
 694                 if (topology.entities[TOPO_LEVEL_THREAD] > 1)
 695                         printf(" x %d hardware threads",
 696                             topology.entities[TOPO_LEVEL_THREAD]);
 697         } else {
 698                 printf("Non-uniform topology");
 699         }
 700         printf("\n");
 701
 702         if (disabled_cpus) {
 703                 printf("FreeBSD/SMP Online: ");
 704                 if (topo_analyze(&topo_root, 0, &topology)) {
 705                         printf("%d package(s)",
 706                             topology.entities[TOPO_LEVEL_PKG]);
 707                         if (topology.entities[TOPO_LEVEL_GROUP] > 1)
 708                                 printf(" x %d groups",
 709                                     topology.entities[TOPO_LEVEL_GROUP]);
 710                         if (topology.entities[TOPO_LEVEL_CACHEGROUP] > 1)
 711                                 printf(" x %d cache groups",
 712                                     topology.entities[TOPO_LEVEL_CACHEGROUP]);
 713                         if (topology.entities[TOPO_LEVEL_CORE] > 0)
 714                                 printf(" x %d core(s)",
 715                                     topology.entities[TOPO_LEVEL_CORE]);
 716                         if (topology.entities[TOPO_LEVEL_THREAD] > 1)
 717                                 printf(" x %d hardware threads",
 718                                     topology.entities[TOPO_LEVEL_THREAD]);
 719                 } else {
 720                         printf("Non-uniform topology");
 721                 }
 722                 printf("\n");
 723         }
 724
 725         if (!bootverbose)
 726                 return;
 727
 728         TOPO_FOREACH(node, &topo_root) {
 729                 switch (node->type) {
 730                 case TOPO_TYPE_PKG:
 731                         printf("Package HW ID = %u\n", node->hwid);
 732                         break;
 733                 case TOPO_TYPE_CORE:
 734                         printf("\tCore HW ID = %u\n", node->hwid);
 735                         break;
 736                 case TOPO_TYPE_PU:
 737                         if (cpu_info[node->hwid].cpu_hyperthread)
 738                                 hyperthread = "/HT";
 739                         else
 740                                 hyperthread = "";
 741
 742                         if (node->subtype == 0)
 743                                 printf("\t\tCPU (AP%s): APIC ID: %u"
 744                                     "(disabled)\n", hyperthread, node->hwid);
 745                         else if (node->id == 0)
 746                                 printf("\t\tCPU0 (BSP): APIC ID: %u\n",
 747                                     node->hwid);
 748                         else
 749                                 printf("\t\tCPU%u (AP%s): APIC ID: %u\n",
 750                                     node->id, hyperthread, node->hwid);
 751                         break;
 752                 default:
 753                         /* ignored */
 754                         break;
 755                 }
 756         }
 757 }
 758
 759 /*
 760  * Add a scheduling group, a group of logical processors sharing
 761  * a particular cache (and, thus having an affinity), to the scheduling
 762  * topology.
 763  * This function recursively works on lower level caches.
 764  */
 765 static void
 766 x86topo_add_sched_group(struct topo_node *root, struct cpu_group *cg_root)
 767 {
 768         struct topo_node *node;
 769         int nchildren;
 770         int ncores;
 771         int i;
 772
 773         KASSERT(root->type == TOPO_TYPE_SYSTEM || root->type == TOPO_TYPE_CACHE ||
 774             root->type == TOPO_TYPE_GROUP,
 775             ("x86topo_add_sched_group: bad type: %u", root->type));
 776         CPU_COPY(&root->cpuset, &cg_root->cg_mask);
 777         cg_root->cg_count = root->cpu_count;
 778         if (root->type == TOPO_TYPE_SYSTEM)
 779                 cg_root->cg_level = CG_SHARE_NONE;
 780         else
 781                 cg_root->cg_level = root->subtype;
 782
 783         /*
 784          * Check how many core nodes we have under the given root node.
 785          * If we have multiple logical processors, but not multiple
 786          * cores, then those processors must be hardware threads.
 787          */
 788         ncores = 0;
 789         node = root;
 790         while (node != NULL) {
 791                 if (node->type != TOPO_TYPE_CORE) {
 792                         node = topo_next_node(root, node);
 793                         continue;
 794                 }
 795
 796                 ncores++;
 797                 node = topo_next_nonchild_node(root, node);
 798         }
 799
 800         if (cg_root->cg_level != CG_SHARE_NONE &&
 801             root->cpu_count > 1 && ncores < 2)
 802                 cg_root->cg_flags = CG_FLAG_SMT;
 803
 804         /*
 805          * Find out how many cache nodes we have under the given root node.
 806          * We ignore cache nodes that cover all the same processors as the
 807          * root node.  Also, we do not descend below found cache nodes.
 808          * That is, we count top-level "non-redundant" caches under the root
 809          * node.
 810          */
 811         nchildren = 0;
 812         node = root;
 813         while (node != NULL) {
 814                 if ((node->type != TOPO_TYPE_GROUP &&
 815                     node->type != TOPO_TYPE_CACHE) ||
 816                     (root->type != TOPO_TYPE_SYSTEM &&
 817                     CPU_CMP(&node->cpuset, &root->cpuset) == 0)) {
 818                         node = topo_next_node(root, node);
 819                         continue;
 820                 }
 821                 nchildren++;
 822                 node = topo_next_nonchild_node(root, node);
 823         }
 824
 825         cg_root->cg_child = smp_topo_alloc(nchildren);
 826         cg_root->cg_children = nchildren;
 827
 828         /*
 829          * Now find again the same cache nodes as above and recursively
 830          * build scheduling topologies for them.
 831          */
 832         node = root;
 833         i = 0;
 834         while (node != NULL) {
 835                 if ((node->type != TOPO_TYPE_GROUP &&
 836                     node->type != TOPO_TYPE_CACHE) ||
 837                     (root->type != TOPO_TYPE_SYSTEM &&
 838                     CPU_CMP(&node->cpuset, &root->cpuset) == 0)) {
 839                         node = topo_next_node(root, node);
 840                         continue;
 841                 }
 842                 cg_root->cg_child[i].cg_parent = cg_root;
 843                 x86topo_add_sched_group(node, &cg_root->cg_child[i]);
 844                 i++;
 845                 node = topo_next_nonchild_node(root, node);
 846         }
 847 }
 848
 849 /*
 850  * Build the MI scheduling topology from the discovered hardware topology.
 851  */
 852 struct cpu_group *
 853 cpu_topo(void)
 854 {
 855         struct cpu_group *cg_root;
 856
 857         if (mp_ncpus <= 1)
 858                 return (smp_topo_none());
 859
 860         cg_root = smp_topo_alloc(1);
 861         x86topo_add_sched_group(&topo_root, cg_root);
 862         return (cg_root);
 863 }
 864
 865 static void
 866 cpu_alloc(void *dummy __unused)
 867 {
 868         /*
 869          * Dynamically allocate the arrays that depend on the
 870          * maximum APIC ID.
 871          */
 872         cpu_info = malloc(sizeof(*cpu_info) * (max_apic_id + 1), M_CPUS,
 873             M_WAITOK | M_ZERO);
 874         apic_cpuids = malloc(sizeof(*apic_cpuids) * (max_apic_id + 1), M_CPUS,
 875             M_WAITOK | M_ZERO);
 876 }
 877 SYSINIT(cpu_alloc, SI_SUB_CPU, SI_ORDER_FIRST, cpu_alloc, NULL);
 878
 879 /*
 880  * Add a logical CPU to the topology.
 881  */
 882 void
 883 cpu_add(u_int apic_id, char boot_cpu)
 884 {
 885
 886         if (apic_id > max_apic_id) {
 887                 panic("SMP: APIC ID %d too high", apic_id);
 888                 return;
 889         }
 890         KASSERT(cpu_info[apic_id].cpu_present == 0, ("CPU %u added twice",
 891             apic_id));
 892         cpu_info[apic_id].cpu_present = 1;
 893         if (boot_cpu) {
 894                 KASSERT(boot_cpu_id == -1,
 895                     ("CPU %u claims to be BSP, but CPU %u already is", apic_id,
 896                     boot_cpu_id));
 897                 boot_cpu_id = apic_id;
 898                 cpu_info[apic_id].cpu_bsp = 1;
 899         }
 900         if (bootverbose)
 901                 printf("SMP: Added CPU %u (%s)\n", apic_id, boot_cpu ? "BSP" :
 902                     "AP");
 903 }
 904
 905 void
 906 cpu_mp_setmaxid(void)
 907 {
 908
 909         /*
 910          * mp_ncpus and mp_maxid should be already set by calls to cpu_add().
 911          * If there were no calls to cpu_add() assume this is a UP system.
 912          */
 913         if (mp_ncpus == 0)
 914                 mp_ncpus = 1;
 915 }
 916
 917 int
 918 cpu_mp_probe(void)
 919 {
 920
 921         /*
 922          * Always record BSP in CPU map so that the mbuf init code works
 923          * correctly.
 924          */
 925         CPU_SETOF(0, &all_cpus);
 926         return (mp_ncpus > 1);
 927 }
 928
 929 /* Allocate memory for the AP trampoline. */
 930 void
 931 alloc_ap_trampoline(vm_paddr_t *physmap, unsigned int *physmap_idx)
 932 {
 933         unsigned int i;
 934         bool allocated;
 935
 936         allocated = false;
 937         for (i = *physmap_idx; i <= *physmap_idx; i -= 2) {
 938                 /*
 939                  * Find a memory region big enough and below the 1MB boundary
 940                  * for the trampoline code.
 941                  * NB: needs to be page aligned.
 942                  */
 943                 if (physmap[i] >= MiB(1) ||
 944                     (trunc_page(physmap[i + 1]) - round_page(physmap[i])) <
 945                     round_page(bootMP_size))
 946                         continue;
 947
 948                 allocated = true;
 949                 /*
 950                  * Try to steal from the end of the region to mimic previous
 951                  * behaviour, else fallback to steal from the start.
 952                  */
 953                 if (physmap[i + 1] < MiB(1)) {
 954                         boot_address = trunc_page(physmap[i + 1]);
 955                         if ((physmap[i + 1] - boot_address) < bootMP_size)
 956                                 boot_address -= round_page(bootMP_size);
 957                         physmap[i + 1] = boot_address;
 958                 } else {
 959                         boot_address = round_page(physmap[i]);
 960                         physmap[i] = boot_address + round_page(bootMP_size);
 961                 }
 962                 if (physmap[i] == physmap[i + 1] && *physmap_idx != 0) {
 963                         memmove(&physmap[i], &physmap[i + 2],
 964                             sizeof(*physmap) * (*physmap_idx - i + 2));
 965                         *physmap_idx -= 2;
 966                 }
 967                 break;
 968         }
 969
 970         if (!allocated) {
 971                 boot_address = basemem * 1024 - bootMP_size;
 972                 if (bootverbose)
 973                         printf(
 974 "Cannot find enough space for the boot trampoline, placing it at %#x",
 975                             boot_address);
 976         }
 977 }
 978
 979 /*
 980  * AP CPU's call this to initialize themselves.
 981  */
 982 void
 983 init_secondary_tail(void)
 984 {
 985         u_int cpuid;
 986
 987         pmap_activate_boot(vmspace_pmap(proc0.p_vmspace));
 988
 989         /*
 990          * On real hardware, switch to x2apic mode if possible.  Do it
 991          * after aps_ready was signalled, to avoid manipulating the
 992          * mode while BSP might still want to send some IPI to us
 993          * (second startup IPI is ignored on modern hardware etc).
 994          */
 995         lapic_xapic_mode();
 996
 997         /* Initialize the PAT MSR. */
 998         pmap_init_pat();
 999
1000         /* set up CPU registers and state */
1001         cpu_setregs();
1002
1003         /* set up SSE/NX */
1004         initializecpu();
1005
1006         /* set up FPU state on the AP */
1007 #ifdef __amd64__
1008         fpuinit();
1009 #else
1010         npxinit(false);
1011 #endif
1012
1013         if (cpu_ops.cpu_init)
1014                 cpu_ops.cpu_init();
1015
1016         /* A quick check from sanity claus */
1017         cpuid = PCPU_GET(cpuid);
1018         if (PCPU_GET(apic_id) != lapic_id()) {
1019                 printf("SMP: cpuid = %d\n", cpuid);
1020                 printf("SMP: actual apic_id = %d\n", lapic_id());
1021                 printf("SMP: correct apic_id = %d\n", PCPU_GET(apic_id));
1022                 panic("cpuid mismatch! boom!!");
1023         }
1024
1025         /* Initialize curthread. */
1026         KASSERT(PCPU_GET(idlethread) != NULL, ("no idle thread"));
1027         PCPU_SET(curthread, PCPU_GET(idlethread));
1028
1029         mtx_lock_spin(&ap_boot_mtx);
1030
1031         mca_init();
1032
1033         /* Init local apic for irq's */
1034         lapic_setup(1);
1035
1036         /* Set memory range attributes for this CPU to match the BSP */
1037         mem_range_AP_init();
1038
1039         smp_cpus++;
1040
1041         CTR1(KTR_SMP, "SMP: AP CPU #%d Launched", cpuid);
1042         if (bootverbose)
1043                 printf("SMP: AP CPU #%d Launched!\n", cpuid);
1044         else
1045                 printf("%s%d%s", smp_cpus == 2 ? "Launching APs: " : "",
1046                     cpuid, smp_cpus == mp_ncpus ? "\n" : " ");
1047
1048         /* Determine if we are a logical CPU. */
1049         if (cpu_info[PCPU_GET(apic_id)].cpu_hyperthread)
1050                 CPU_SET(cpuid, &logical_cpus_mask);
1051
1052         if (bootverbose)
1053                 lapic_dump("AP");
1054
1055         if (smp_cpus == mp_ncpus) {
1056                 /* enable IPI's, tlb shootdown, freezes etc */
1057                 atomic_store_rel_int(&smp_started, 1);
1058         }
1059
1060 #ifdef __amd64__
1061         /*
1062          * Enable global pages TLB extension
1063          * This also implicitly flushes the TLB
1064          */
1065         load_cr4(rcr4() | CR4_PGE);
1066         if (pmap_pcid_enabled)
1067                 load_cr4(rcr4() | CR4_PCIDE);
1068         load_ds(_udatasel);
1069         load_es(_udatasel);
1070         load_fs(_ufssel);
1071 #endif
1072
1073         mtx_unlock_spin(&ap_boot_mtx);
1074
1075         /* Wait until all the AP's are up. */
1076         while (atomic_load_acq_int(&smp_started) == 0)
1077                 ia32_pause();
1078
1079 #ifndef EARLY_AP_STARTUP
1080         /* Start per-CPU event timers. */
1081         cpu_initclocks_ap();
1082 #endif
1083
1084         kcsan_cpu_init(cpuid);
1085
1086         sched_throw(NULL);
1087
1088         panic("scheduler returned us to %s", __func__);
1089         /* NOTREACHED */
1090 }
1091
1092 static void
1093 smp_after_idle_runnable(void *arg __unused)
1094 {
1095         struct thread *idle_td;
1096         int cpu;
1097
1098         for (cpu = 1; cpu < mp_ncpus; cpu++) {
1099                 idle_td = pcpu_find(cpu)->pc_idlethread;
1100                 while (atomic_load_int(&idle_td->td_lastcpu) == NOCPU &&
1101                     atomic_load_int(&idle_td->td_oncpu) == NOCPU)
1102                         cpu_spinwait();
1103                 kmem_free((vm_offset_t)bootstacks[cpu], kstack_pages *
1104                     PAGE_SIZE);
1105         }
1106 }
1107 SYSINIT(smp_after_idle_runnable, SI_SUB_SMP, SI_ORDER_ANY,
1108     smp_after_idle_runnable, NULL);
1109
1110 /*
1111  * We tell the I/O APIC code about all the CPUs we want to receive
1112  * interrupts.  If we don't want certain CPUs to receive IRQs we
1113  * can simply not tell the I/O APIC code about them in this function.
1114  * We also do not tell it about the BSP since it tells itself about
1115  * the BSP internally to work with UP kernels and on UP machines.
1116  */
1117 void
1118 set_interrupt_apic_ids(void)
1119 {
1120         u_int i, apic_id;
1121
1122         for (i = 0; i < MAXCPU; i++) {
1123                 apic_id = cpu_apic_ids[i];
1124                 if (apic_id == -1)
1125                         continue;
1126                 if (cpu_info[apic_id].cpu_bsp)
1127                         continue;
1128                 if (cpu_info[apic_id].cpu_disabled)
1129                         continue;
1130
1131                 /* Don't let hyperthreads service interrupts. */
1132                 if (cpu_info[apic_id].cpu_hyperthread &&
1133                     !hyperthreading_intr_allowed)
1134                         continue;
1135
1136                 intr_add_cpu(i);
1137         }
1138 }
1139
1140
1141 #ifdef COUNT_XINVLTLB_HITS
1142 u_int xhits_gbl[MAXCPU];
1143 u_int xhits_pg[MAXCPU];
1144 u_int xhits_rng[MAXCPU];
1145 static SYSCTL_NODE(_debug, OID_AUTO, xhits, CTLFLAG_RW, 0, "");
1146 SYSCTL_OPAQUE(_debug_xhits, OID_AUTO, global, CTLFLAG_RW, &xhits_gbl,
1147     sizeof(xhits_gbl), "IU", "");
1148 SYSCTL_OPAQUE(_debug_xhits, OID_AUTO, page, CTLFLAG_RW, &xhits_pg,
1149     sizeof(xhits_pg), "IU", "");
1150 SYSCTL_OPAQUE(_debug_xhits, OID_AUTO, range, CTLFLAG_RW, &xhits_rng,
1151     sizeof(xhits_rng), "IU", "");
1152
1153 u_int ipi_global;
1154 u_int ipi_page;
1155 u_int ipi_range;
1156 u_int ipi_range_size;
1157 SYSCTL_INT(_debug_xhits, OID_AUTO, ipi_global, CTLFLAG_RW, &ipi_global, 0, "");
1158 SYSCTL_INT(_debug_xhits, OID_AUTO, ipi_page, CTLFLAG_RW, &ipi_page, 0, "");
1159 SYSCTL_INT(_debug_xhits, OID_AUTO, ipi_range, CTLFLAG_RW, &ipi_range, 0, "");
1160 SYSCTL_INT(_debug_xhits, OID_AUTO, ipi_range_size, CTLFLAG_RW, &ipi_range_size,
1161     0, "");
1162 #endif /* COUNT_XINVLTLB_HITS */
1163
1164 /*
1165  * Init and startup IPI.
1166  */
1167 void
1168 ipi_startup(int apic_id, int vector)
1169 {
1170
1171         /*
1172          * This attempts to follow the algorithm described in the
1173          * Intel Multiprocessor Specification v1.4 in section B.4.
1174          * For each IPI, we allow the local APIC ~20us to deliver the
1175          * IPI.  If that times out, we panic.
1176          */
1177
1178         /*
1179          * first we do an INIT IPI: this INIT IPI might be run, resetting
1180          * and running the target CPU. OR this INIT IPI might be latched (P5
1181          * bug), CPU waiting for STARTUP IPI. OR this INIT IPI might be
1182          * ignored.
1183          */
1184         lapic_ipi_raw(APIC_DEST_DESTFLD | APIC_TRIGMOD_LEVEL |
1185             APIC_LEVEL_ASSERT | APIC_DESTMODE_PHY | APIC_DELMODE_INIT, apic_id);
1186         lapic_ipi_wait(100);
1187
1188         /* Explicitly deassert the INIT IPI. */
1189         lapic_ipi_raw(APIC_DEST_DESTFLD | APIC_TRIGMOD_LEVEL |
1190             APIC_LEVEL_DEASSERT | APIC_DESTMODE_PHY | APIC_DELMODE_INIT,
1191             apic_id);
1192
1193         DELAY(10000);           /* wait ~10mS */
1194
1195         /*
1196          * next we do a STARTUP IPI: the previous INIT IPI might still be
1197          * latched, (P5 bug) this 1st STARTUP would then terminate
1198          * immediately, and the previously started INIT IPI would continue. OR
1199          * the previous INIT IPI has already run. and this STARTUP IPI will
1200          * run. OR the previous INIT IPI was ignored. and this STARTUP IPI
1201          * will run.
1202          */
1203         lapic_ipi_raw(APIC_DEST_DESTFLD | APIC_TRIGMOD_EDGE |
1204             APIC_LEVEL_ASSERT | APIC_DESTMODE_PHY | APIC_DELMODE_STARTUP |
1205             vector, apic_id);
1206         if (!lapic_ipi_wait(100))
1207                 panic("Failed to deliver first STARTUP IPI to APIC %d",
1208                     apic_id);
1209         DELAY(200);             /* wait ~200uS */
1210
1211         /*
1212          * finally we do a 2nd STARTUP IPI: this 2nd STARTUP IPI should run IF
1213          * the previous STARTUP IPI was cancelled by a latched INIT IPI. OR
1214          * this STARTUP IPI will be ignored, as only ONE STARTUP IPI is
1215          * recognized after hardware RESET or INIT IPI.
1216          */
1217         lapic_ipi_raw(APIC_DEST_DESTFLD | APIC_TRIGMOD_EDGE |
1218             APIC_LEVEL_ASSERT | APIC_DESTMODE_PHY | APIC_DELMODE_STARTUP |
1219             vector, apic_id);
1220         if (!lapic_ipi_wait(100))
1221                 panic("Failed to deliver second STARTUP IPI to APIC %d",
1222                     apic_id);
1223
1224         DELAY(200);             /* wait ~200uS */
1225 }
1226
1227 /*
1228  * Send an IPI to specified CPU handling the bitmap logic.
1229  */
1230 void
1231 ipi_send_cpu(int cpu, u_int ipi)
1232 {
1233         u_int bitmap, old, new;
1234         u_int *cpu_bitmap;
1235
1236         KASSERT(cpu_apic_ids[cpu] != -1, ("IPI to non-existent CPU %d", cpu));
1237
1238         if (IPI_IS_BITMAPED(ipi)) {
1239                 bitmap = 1 << ipi;
1240                 ipi = IPI_BITMAP_VECTOR;
1241                 cpu_bitmap = &cpuid_to_pcpu[cpu]->pc_ipi_bitmap;
1242                 old = *cpu_bitmap;
1243                 for (;;) {
1244                         if ((old & bitmap) == bitmap)
1245                                 break;
1246                         new = old | bitmap;
1247                         if (atomic_fcmpset_int(cpu_bitmap, &old, new))
1248                                 break;
1249                 }
1250                 if (old)
1251                         return;
1252         }
1253         lapic_ipi_vectored(ipi, cpu_apic_ids[cpu]);
1254 }
1255
1256 void
1257 ipi_bitmap_handler(struct trapframe frame)
1258 {
1259         struct trapframe *oldframe;
1260         struct thread *td;
1261         int cpu = PCPU_GET(cpuid);
1262         u_int ipi_bitmap;
1263
1264         td = curthread;
1265         td->td_intr_nesting_level++;
1266         oldframe = td->td_intr_frame;
1267         td->td_intr_frame = &frame;
1268         ipi_bitmap = atomic_readandclear_int(&cpuid_to_pcpu[cpu]->pc_ipi_bitmap);
1269         if (ipi_bitmap & (1 << IPI_AST)) {
1270 #ifdef COUNT_IPIS
1271                 (*ipi_ast_counts[cpu])++;
1272 #endif
1273                 /* Nothing to do for AST */
1274         }
1275         if (ipi_bitmap & (1 << IPI_HARDCLOCK)) {
1276                 critical_enter();
1277 #ifdef COUNT_IPIS
1278                 (*ipi_hardclock_counts[cpu])++;
1279 #endif
1280                 hardclockintr();
1281                 critical_exit();
1282         }
1283
1284         /* Run preempt after clock handlers since it may switch. */
1285         if (ipi_bitmap & (1 << IPI_PREEMPT)) {
1286 #ifdef COUNT_IPIS
1287                 (*ipi_preempt_counts[cpu])++;
1288 #endif
1289                 sched_preempt(td);
1290         }
1291         td->td_intr_frame = oldframe;
1292         td->td_intr_nesting_level--;
1293 }
1294
1295 /*
1296  * send an IPI to a set of cpus.
1297  */
1298 void
1299 ipi_selected(cpuset_t cpus, u_int ipi)
1300 {
1301         int cpu;
1302
1303         /*
1304          * IPI_STOP_HARD maps to a NMI and the trap handler needs a bit
1305          * of help in order to understand what is the source.
1306          * Set the mask of receiving CPUs for this purpose.
1307          */
1308         if (ipi == IPI_STOP_HARD)
1309                 CPU_OR_ATOMIC(&ipi_stop_nmi_pending, &cpus);
1310
1311         while ((cpu = CPU_FFS(&cpus)) != 0) {
1312                 cpu--;
1313                 CPU_CLR(cpu, &cpus);
1314                 CTR3(KTR_SMP, "%s: cpu: %d ipi: %x", __func__, cpu, ipi);
1315                 ipi_send_cpu(cpu, ipi);
1316         }
1317 }
1318
1319 /*
1320  * send an IPI to a specific CPU.
1321  */
1322 void
1323 ipi_cpu(int cpu, u_int ipi)
1324 {
1325
1326         /*
1327          * IPI_STOP_HARD maps to a NMI and the trap handler needs a bit
1328          * of help in order to understand what is the source.
1329          * Set the mask of receiving CPUs for this purpose.
1330          */
1331         if (ipi == IPI_STOP_HARD)
1332                 CPU_SET_ATOMIC(cpu, &ipi_stop_nmi_pending);
1333
1334         CTR3(KTR_SMP, "%s: cpu: %d ipi: %x", __func__, cpu, ipi);
1335         ipi_send_cpu(cpu, ipi);
1336 }
1337
1338 /*
1339  * send an IPI to all CPUs EXCEPT myself
1340  */
1341 void
1342 ipi_all_but_self(u_int ipi)
1343 {
1344         cpuset_t other_cpus;
1345
1346         other_cpus = all_cpus;
1347         CPU_CLR(PCPU_GET(cpuid), &other_cpus);
1348         if (IPI_IS_BITMAPED(ipi)) {
1349                 ipi_selected(other_cpus, ipi);
1350                 return;
1351         }
1352
1353         /*
1354          * IPI_STOP_HARD maps to a NMI and the trap handler needs a bit
1355          * of help in order to understand what is the source.
1356          * Set the mask of receiving CPUs for this purpose.
1357          */
1358         if (ipi == IPI_STOP_HARD)
1359                 CPU_OR_ATOMIC(&ipi_stop_nmi_pending, &other_cpus);
1360
1361         CTR2(KTR_SMP, "%s: ipi: %x", __func__, ipi);
1362         lapic_ipi_vectored(ipi, APIC_IPI_DEST_OTHERS);
1363 }
1364
1365 int
1366 ipi_nmi_handler(void)
1367 {
1368         u_int cpuid;
1369
1370         /*
1371          * As long as there is not a simple way to know about a NMI's
1372          * source, if the bitmask for the current CPU is present in
1373          * the global pending bitword an IPI_STOP_HARD has been issued
1374          * and should be handled.
1375          */
1376         cpuid = PCPU_GET(cpuid);
1377         if (!CPU_ISSET(cpuid, &ipi_stop_nmi_pending))
1378                 return (1);
1379
1380         CPU_CLR_ATOMIC(cpuid, &ipi_stop_nmi_pending);
1381         cpustop_handler();
1382         return (0);
1383 }
1384
1385 int nmi_kdb_lock;
1386
1387 void
1388 nmi_call_kdb_smp(u_int type, struct trapframe *frame)
1389 {
1390         int cpu;
1391         bool call_post;
1392
1393         cpu = PCPU_GET(cpuid);
1394         if (atomic_cmpset_acq_int(&nmi_kdb_lock, 0, 1)) {
1395                 nmi_call_kdb(cpu, type, frame);
1396                 call_post = false;
1397         } else {
1398                 savectx(&stoppcbs[cpu]);
1399                 CPU_SET_ATOMIC(cpu, &stopped_cpus);
1400                 while (!atomic_cmpset_acq_int(&nmi_kdb_lock, 0, 1))
1401                         ia32_pause();
1402                 call_post = true;
1403         }
1404         atomic_store_rel_int(&nmi_kdb_lock, 0);
1405         if (call_post)
1406                 cpustop_handler_post(cpu);
1407 }
1408
1409 /*
1410  * Handle an IPI_STOP by saving our current context and spinning (or mwaiting,
1411  * if available) until we are resumed.
1412  */
1413 void
1414 cpustop_handler(void)
1415 {
1416         struct monitorbuf *mb;
1417         u_int cpu;
1418         bool use_mwait;
1419
1420         cpu = PCPU_GET(cpuid);
1421
1422         savectx(&stoppcbs[cpu]);
1423
1424         use_mwait = (stop_mwait && (cpu_feature2 & CPUID2_MON) != 0 &&
1425             !mwait_cpustop_broken);
1426         if (use_mwait) {
1427                 mb = PCPU_PTR(monitorbuf);
1428                 atomic_store_int(&mb->stop_state,
1429                     MONITOR_STOPSTATE_STOPPED);
1430         }
1431
1432         /* Indicate that we are stopped */
1433         CPU_SET_ATOMIC(cpu, &stopped_cpus);
1434
1435         /* Wait for restart */
1436         while (!CPU_ISSET(cpu, &started_cpus)) {
1437                 if (use_mwait) {
1438                         cpu_monitor(mb, 0, 0);
1439                         if (atomic_load_int(&mb->stop_state) ==
1440                             MONITOR_STOPSTATE_STOPPED)
1441                                 cpu_mwait(0, MWAIT_C1);
1442                         continue;
1443                 }
1444
1445                 ia32_pause();
1446
1447                 /*
1448                  * Halt non-BSP CPUs on panic -- we're never going to need them
1449                  * again, and might as well save power / release resources
1450                  * (e.g., overprovisioned VM infrastructure).
1451                  */
1452                 while (__predict_false(!IS_BSP() && panicstr != NULL))
1453                         halt();
1454         }
1455
1456         cpustop_handler_post(cpu);
1457 }
1458
1459 static void
1460 cpustop_handler_post(u_int cpu)
1461 {
1462
1463         CPU_CLR_ATOMIC(cpu, &started_cpus);
1464         CPU_CLR_ATOMIC(cpu, &stopped_cpus);
1465
1466         /*
1467          * We don't broadcast TLB invalidations to other CPUs when they are
1468          * stopped. Hence, we clear the TLB before resuming.
1469          */
1470         invltlb_glob();
1471
1472 #if defined(__amd64__) && defined(DDB)
1473         amd64_db_resume_dbreg();
1474 #endif
1475
1476         if (cpu == 0 && cpustop_restartfunc != NULL) {
1477                 cpustop_restartfunc();
1478                 cpustop_restartfunc = NULL;
1479         }
1480 }
1481
1482 /*
1483  * Handle an IPI_SUSPEND by saving our current context and spinning until we
1484  * are resumed.
1485  */
1486 void
1487 cpususpend_handler(void)
1488 {
1489         u_int cpu;
1490
1491         mtx_assert(&smp_ipi_mtx, MA_NOTOWNED);
1492
1493         cpu = PCPU_GET(cpuid);
1494         if (savectx(&susppcbs[cpu]->sp_pcb)) {
1495 #ifdef __amd64__
1496                 fpususpend(susppcbs[cpu]->sp_fpususpend);
1497 #else
1498                 npxsuspend(susppcbs[cpu]->sp_fpususpend);
1499 #endif
1500                 /*
1501                  * suspended_cpus is cleared shortly after each AP is restarted
1502                  * by a Startup IPI, so that the BSP can proceed to restarting
1503                  * the next AP.
1504                  *
1505                  * resuming_cpus gets cleared when the AP completes
1506                  * initialization after having been released by the BSP.
1507                  * resuming_cpus is probably not the best name for the
1508                  * variable, because it is actually a set of processors that
1509                  * haven't resumed yet and haven't necessarily started resuming.
1510                  *
1511                  * Note that suspended_cpus is meaningful only for ACPI suspend
1512                  * as it's not really used for Xen suspend since the APs are
1513                  * automatically restored to the running state and the correct
1514                  * context.  For the same reason resumectx is never called in
1515                  * that case.
1516                  */
1517                 CPU_SET_ATOMIC(cpu, &suspended_cpus);
1518                 CPU_SET_ATOMIC(cpu, &resuming_cpus);
1519
1520                 /*
1521                  * Invalidate the cache after setting the global status bits.
1522                  * The last AP to set its bit may end up being an Owner of the
1523                  * corresponding cache line in MOESI protocol.  The AP may be
1524                  * stopped before the cache line is written to the main memory.
1525                  */
1526                 wbinvd();
1527         } else {
1528 #ifdef __amd64__
1529                 fpuresume(susppcbs[cpu]->sp_fpususpend);
1530 #else
1531                 npxresume(susppcbs[cpu]->sp_fpususpend);
1532 #endif
1533                 pmap_init_pat();
1534                 initializecpu();
1535                 PCPU_SET(switchtime, 0);
1536                 PCPU_SET(switchticks, ticks);
1537
1538                 /* Indicate that we have restarted and restored the context. */
1539                 CPU_CLR_ATOMIC(cpu, &suspended_cpus);
1540         }
1541
1542         /* Wait for resume directive */
1543         while (!CPU_ISSET(cpu, &toresume_cpus))
1544                 ia32_pause();
1545
1546         /* Re-apply microcode updates. */
1547         ucode_reload();
1548
1549 #ifdef __i386__
1550         /* Finish removing the identity mapping of low memory for this AP. */
1551         invltlb_glob();
1552 #endif
1553
1554         if (cpu_ops.cpu_resume)
1555                 cpu_ops.cpu_resume();
1556 #ifdef __amd64__
1557         if (vmm_resume_p)
1558                 vmm_resume_p();
1559 #endif
1560
1561         /* Resume MCA and local APIC */
1562         lapic_xapic_mode();
1563         mca_resume();
1564         lapic_setup(0);
1565
1566         /* Indicate that we are resumed */
1567         CPU_CLR_ATOMIC(cpu, &resuming_cpus);
1568         CPU_CLR_ATOMIC(cpu, &suspended_cpus);
1569         CPU_CLR_ATOMIC(cpu, &toresume_cpus);
1570 }
1571
1572
1573 void
1574 invlcache_handler(void)
1575 {
1576         uint32_t generation;
1577
1578 #ifdef COUNT_IPIS
1579         (*ipi_invlcache_counts[PCPU_GET(cpuid)])++;
1580 #endif /* COUNT_IPIS */
1581
1582         /*
1583          * Reading the generation here allows greater parallelism
1584          * since wbinvd is a serializing instruction.  Without the
1585          * temporary, we'd wait for wbinvd to complete, then the read
1586          * would execute, then the dependent write, which must then
1587          * complete before return from interrupt.
1588          */
1589         generation = smp_tlb_generation;
1590         wbinvd();
1591         PCPU_SET(smp_tlb_done, generation);
1592 }
1593
1594 /*
1595  * This is called once the rest of the system is up and running and we're
1596  * ready to let the AP's out of the pen.
1597  */
1598 static void
1599 release_aps(void *dummy __unused)
1600 {
1601
1602         if (mp_ncpus == 1)
1603                 return;
1604         atomic_store_rel_int(&aps_ready, 1);
1605         while (smp_started == 0)
1606                 ia32_pause();
1607 }
1608 SYSINIT(start_aps, SI_SUB_SMP, SI_ORDER_FIRST, release_aps, NULL);
1609
1610 #ifdef COUNT_IPIS
1611 /*
1612  * Setup interrupt counters for IPI handlers.
1613  */
1614 static void
1615 mp_ipi_intrcnt(void *dummy)
1616 {
1617         char buf[64];
1618         int i;
1619
1620         CPU_FOREACH(i) {
1621                 snprintf(buf, sizeof(buf), "cpu%d:invltlb", i);
1622                 intrcnt_add(buf, &ipi_invltlb_counts[i]);
1623                 snprintf(buf, sizeof(buf), "cpu%d:invlrng", i);
1624                 intrcnt_add(buf, &ipi_invlrng_counts[i]);
1625                 snprintf(buf, sizeof(buf), "cpu%d:invlpg", i);
1626                 intrcnt_add(buf, &ipi_invlpg_counts[i]);
1627                 snprintf(buf, sizeof(buf), "cpu%d:invlcache", i);
1628                 intrcnt_add(buf, &ipi_invlcache_counts[i]);
1629                 snprintf(buf, sizeof(buf), "cpu%d:preempt", i);
1630                 intrcnt_add(buf, &ipi_preempt_counts[i]);
1631                 snprintf(buf, sizeof(buf), "cpu%d:ast", i);
1632                 intrcnt_add(buf, &ipi_ast_counts[i]);
1633                 snprintf(buf, sizeof(buf), "cpu%d:rendezvous", i);
1634                 intrcnt_add(buf, &ipi_rendezvous_counts[i]);
1635                 snprintf(buf, sizeof(buf), "cpu%d:hardclock", i);
1636                 intrcnt_add(buf, &ipi_hardclock_counts[i]);
1637         }
1638 }
1639 SYSINIT(mp_ipi_intrcnt, SI_SUB_INTR, SI_ORDER_MIDDLE, mp_ipi_intrcnt, NULL);
1640 #endif
1641
1642 /*
1643  * Flush the TLB on other CPU's
1644  */
1645
1646 /* Variables needed for SMP tlb shootdown. */
1647 vm_offset_t smp_tlb_addr1, smp_tlb_addr2;
1648 pmap_t smp_tlb_pmap;
1649 volatile uint32_t smp_tlb_generation;
1650
1651 #ifdef __amd64__
1652 #define read_eflags() read_rflags()
1653 #endif
1654
1655 static void
1656 smp_targeted_tlb_shootdown(cpuset_t mask, u_int vector, pmap_t pmap,
1657     vm_offset_t addr1, vm_offset_t addr2)
1658 {
1659         cpuset_t other_cpus;
1660         volatile uint32_t *p_cpudone;
1661         uint32_t generation;
1662         int cpu;
1663
1664         /* It is not necessary to signal other CPUs while in the debugger. */
1665         if (kdb_active || panicstr != NULL)
1666                 return;
1667
1668         /*
1669          * Check for other cpus.  Return if none.
1670          */
1671         if (CPU_ISFULLSET(&mask)) {
1672                 if (mp_ncpus <= 1)
1673                         return;
1674         } else {
1675                 CPU_CLR(PCPU_GET(cpuid), &mask);
1676                 if (CPU_EMPTY(&mask))
1677                         return;
1678         }
1679
1680         if (!(read_eflags() & PSL_I))
1681                 panic("%s: interrupts disabled", __func__);
1682         mtx_lock_spin(&smp_ipi_mtx);
1683         smp_tlb_addr1 = addr1;
1684         smp_tlb_addr2 = addr2;
1685         smp_tlb_pmap = pmap;
1686         generation = ++smp_tlb_generation;
1687         if (CPU_ISFULLSET(&mask)) {
1688                 ipi_all_but_self(vector);
1689                 other_cpus = all_cpus;
1690                 CPU_CLR(PCPU_GET(cpuid), &other_cpus);
1691         } else {
1692                 other_cpus = mask;
1693                 while ((cpu = CPU_FFS(&mask)) != 0) {
1694                         cpu--;
1695                         CPU_CLR(cpu, &mask);
1696                         CTR3(KTR_SMP, "%s: cpu: %d ipi: %x", __func__,
1697                             cpu, vector);
1698                         ipi_send_cpu(cpu, vector);
1699                 }
1700         }
1701         while ((cpu = CPU_FFS(&other_cpus)) != 0) {
1702                 cpu--;
1703                 CPU_CLR(cpu, &other_cpus);
1704                 p_cpudone = &cpuid_to_pcpu[cpu]->pc_smp_tlb_done;
1705                 while (*p_cpudone != generation)
1706                         ia32_pause();
1707         }
1708         mtx_unlock_spin(&smp_ipi_mtx);
1709 }
1710
1711 void
1712 smp_masked_invltlb(cpuset_t mask, pmap_t pmap)
1713 {
1714
1715         if (smp_started) {
1716                 smp_targeted_tlb_shootdown(mask, IPI_INVLTLB, pmap, 0, 0);
1717 #ifdef COUNT_XINVLTLB_HITS
1718                 ipi_global++;
1719 #endif
1720         }
1721 }
1722
1723 void
1724 smp_masked_invlpg(cpuset_t mask, vm_offset_t addr, pmap_t pmap)
1725 {
1726
1727         if (smp_started) {
1728                 smp_targeted_tlb_shootdown(mask, IPI_INVLPG, pmap, addr, 0);
1729 #ifdef COUNT_XINVLTLB_HITS
1730                 ipi_page++;
1731 #endif
1732         }
1733 }
1734
1735 void
1736 smp_masked_invlpg_range(cpuset_t mask, vm_offset_t addr1, vm_offset_t addr2,
1737     pmap_t pmap)
1738 {
1739
1740         if (smp_started) {
1741                 smp_targeted_tlb_shootdown(mask, IPI_INVLRNG, pmap,
1742                     addr1, addr2);
1743 #ifdef COUNT_XINVLTLB_HITS
1744                 ipi_range++;
1745                 ipi_range_size += (addr2 - addr1) / PAGE_SIZE;
1746 #endif
1747         }
1748 }
1749
1750 void
1751 smp_cache_flush(void)
1752 {
1753
1754         if (smp_started) {
1755                 smp_targeted_tlb_shootdown(all_cpus, IPI_INVLCACHE, NULL,
1756                     0, 0);
1757         }
1758 }
1759
1760 /*
1761  * Handlers for TLB related IPIs
1762  */
1763 void
1764 invltlb_handler(void)
1765 {
1766         uint32_t generation;
1767
1768 #ifdef COUNT_XINVLTLB_HITS
1769         xhits_gbl[PCPU_GET(cpuid)]++;
1770 #endif /* COUNT_XINVLTLB_HITS */
1771 #ifdef COUNT_IPIS
1772         (*ipi_invltlb_counts[PCPU_GET(cpuid)])++;
1773 #endif /* COUNT_IPIS */
1774
1775         /*
1776          * Reading the generation here allows greater parallelism
1777          * since invalidating the TLB is a serializing operation.
1778          */
1779         generation = smp_tlb_generation;
1780         if (smp_tlb_pmap == kernel_pmap)
1781                 invltlb_glob();
1782 #ifdef __amd64__
1783         else
1784                 invltlb();
1785 #endif
1786         PCPU_SET(smp_tlb_done, generation);
1787 }
1788
1789 void
1790 invlpg_handler(void)
1791 {
1792         uint32_t generation;
1793
1794 #ifdef COUNT_XINVLTLB_HITS
1795         xhits_pg[PCPU_GET(cpuid)]++;
1796 #endif /* COUNT_XINVLTLB_HITS */
1797 #ifdef COUNT_IPIS
1798         (*ipi_invlpg_counts[PCPU_GET(cpuid)])++;
1799 #endif /* COUNT_IPIS */
1800
1801         generation = smp_tlb_generation;        /* Overlap with serialization */
1802 #ifdef __i386__
1803         if (smp_tlb_pmap == kernel_pmap)
1804 #endif
1805                 invlpg(smp_tlb_addr1);
1806         PCPU_SET(smp_tlb_done, generation);
1807 }
1808
1809 void
1810 invlrng_handler(void)
1811 {
1812         vm_offset_t addr, addr2;
1813         uint32_t generation;
1814
1815 #ifdef COUNT_XINVLTLB_HITS
1816         xhits_rng[PCPU_GET(cpuid)]++;
1817 #endif /* COUNT_XINVLTLB_HITS */
1818 #ifdef COUNT_IPIS
1819         (*ipi_invlrng_counts[PCPU_GET(cpuid)])++;
1820 #endif /* COUNT_IPIS */
1821
1822         addr = smp_tlb_addr1;
1823         addr2 = smp_tlb_addr2;
1824         generation = smp_tlb_generation;        /* Overlap with serialization */
1825 #ifdef __i386__
1826         if (smp_tlb_pmap == kernel_pmap)
1827 #endif
1828                 do {
1829                         invlpg(addr);
1830                         addr += PAGE_SIZE;
1831                 } while (addr < addr2);
1832
1833         PCPU_SET(smp_tlb_done, generation);
1834 }