[kernel] Start all other processors in the system

This very large commit is mainly focused on getting the APs started and
to a state where they're waiting to have work scheduled. (Actually
scheduling on them is for another commit.)

To do this, a bunch of major changes were needed:

- Moving a lot of the CPU initialization (including for the BSP) to
  init_cpu(). This includes setting up IST stacks, writing MSRs, and
  creating the cpu_data structure. For the APs, this also creates and
  installs the GDT and TSS, and installs the global IDT.

- Creating the AP startup code, which tries to be as position
  independent as possible. It's copied from its location to 0x8000 for
  AP startup, and some of it is fixed at that address. The AP startup
  code jumps from real mode to long mode with paging in one swell foop.

- Adding limited IPI capability to the lapic class. This will need to
  improve.

- Renaming cpu/cpu.* to cpu/cpu_id.* because it was just annoying in GDB
  and really isn't anything but cpu_id anymore.

- Moved all the GDT, TSS, and IDT code into their own files and made
  them classes instead of a mess of free functions.

- Got rid of bsp_cpu_data everywhere. Now always call the new
  current_cpu() to get the current CPU's cpu_data.

- Device manager keeps a list of APIC ids now. This should go somewhere
  else eventually, device_manager needs to be refactored away.

- Moved some more things (notably the g_kernel_stacks vma) to the
  pre-constructor setup in memory_bootstrap. That whole file is in bad
  need of a refactor.

src/libraries/cpu/cpu_id.cpp

@@ -0,0 +1,106 @@
+#include <stdint.h>
+#include "cpu/cpu_id.h"
+
+namespace cpu {
+
+inline static void
+__cpuid(
+	uint32_t leaf,
+	uint32_t subleaf,
+	uint32_t *eax,
+	uint32_t *ebx = nullptr,
+	uint32_t *ecx = nullptr,
+	uint32_t *edx = nullptr)
+{
+	uint32_t a, b, c, d;
+	__asm__ __volatile__ ( "cpuid"
+			: "=a"(a), "=b"(b), "=c"(c), "=d"(d)
+			: "a"(leaf), "c"(subleaf)
+			);
+	if (eax) *eax = a;
+	if (ebx) *ebx = b;
+	if (ecx) *ecx = c;
+	if (edx) *edx = d;
+}
+
+cpu_id::cpu_id() :
+	m_features {0},
+	m_missing {0}
+{
+	__cpuid(0, 0,
+		&m_high_basic,
+		reinterpret_cast<uint32_t *>(&m_vendor_id[0]),
+		reinterpret_cast<uint32_t *>(&m_vendor_id[8]),
+		reinterpret_cast<uint32_t *>(&m_vendor_id[4]));
+
+	__cpuid(cpuid_extended, 0, &m_high_ext);
+
+	if (m_high_ext >= cpuid_extended + 4) {
+		__cpuid(cpuid_extended + 2, 0,
+			reinterpret_cast<uint32_t *>(&m_brand_name[0]),
+			reinterpret_cast<uint32_t *>(&m_brand_name[4]),
+			reinterpret_cast<uint32_t *>(&m_brand_name[8]),
+			reinterpret_cast<uint32_t *>(&m_brand_name[12]));
+		__cpuid(cpuid_extended + 3, 0,
+			reinterpret_cast<uint32_t *>(&m_brand_name[16]),
+			reinterpret_cast<uint32_t *>(&m_brand_name[20]),
+			reinterpret_cast<uint32_t *>(&m_brand_name[24]),
+			reinterpret_cast<uint32_t *>(&m_brand_name[28]));
+		__cpuid(cpuid_extended + 4, 0,
+			reinterpret_cast<uint32_t *>(&m_brand_name[32]),
+			reinterpret_cast<uint32_t *>(&m_brand_name[36]),
+			reinterpret_cast<uint32_t *>(&m_brand_name[40]),
+			reinterpret_cast<uint32_t *>(&m_brand_name[44]));
+	} else {
+		m_brand_name[0] = 0;
+	}
+
+	uint32_t leaf = -1u;
+	uint32_t sub = -1u;
+	regs r;
+#define CPU_FEATURE_OPT(name, feat_leaf, feat_sub, regname, bit) \
+	if (leaf != feat_leaf || sub != feat_sub) { \
+		leaf = feat_leaf; sub = feat_sub; r = get(leaf, sub); \
+	} \
+	if (r.regname & (1ull << bit)) \
+		m_features |= (1ull << static_cast<uint64_t>(feature::name)); \
+
+#define CPU_FEATURE_REQ(name, feat_leaf, feat_sub, regname, bit) \
+	CPU_FEATURE_OPT(name, feat_leaf, feat_sub, regname, bit); \
+	if ((r.regname & (1ull << bit)) == 0) { \
+		m_missing |= (1ull << static_cast<uint64_t>(feature::name)); \
+	}
+
+#include "cpu/features.inc"
+#undef CPU_FEATURE_OPT
+#undef CPU_FEATURE_REQ
+}
+
+cpu_id::regs
+cpu_id::get(uint32_t leaf, uint32_t sub) const
+{
+	regs ret {0, 0, 0, 0};
+
+	if ((leaf & cpuid_extended) == 0 && leaf > m_high_basic) return ret;
+	if ((leaf & cpuid_extended) != 0 && leaf > m_high_ext) return ret;
+
+	__cpuid(leaf, sub, &ret.eax, &ret.ebx, &ret.ecx, &ret.edx);
+	return ret;
+}
+
+bool
+cpu_id::has_feature(feature feat)
+{
+	return (m_features & (1 << static_cast<uint64_t>(feat))) != 0;
+}
+
+uint8_t
+cpu_id::local_apic_id() const
+{
+	uint32_t eax_unused;
+	uint32_t ebx;
+	__cpuid(1, 0, &eax_unused, &ebx);
+	return static_cast<uint8_t>(ebx >> 24);
+}
+
+}