modeco80
/
singrdk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
singrdk/base/boot/Singldr/undump.cpp

1859 lines
54 KiB
C++
Raw Normal View History

RDK 1.1
2008-03-05 09:52:00 -05:00
//////////////////////////////////////////////////////////////////////////////
//
// undump.cpp - Minidump Kernel Expander
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
typedef int INT;
typedef char INT8, *PINT8;
typedef short INT16, *PINT16;
typedef long INT32, *PINT32;
typedef __int64 INT64, *PINT64;
typedef long LARGEST;
typedef char CHAR, *PCHAR;
typedef unsigned int UINT;
typedef unsigned char UINT8, *PUINT8;
typedef unsigned short UINT16, *PUINT16;
typedef unsigned long UINT32, *PUINT32;
typedef unsigned __int64 UINT64, *PUINT64;
typedef unsigned long ULARGEST;
typedef unsigned short WCHAR;
typedef unsigned char UCHAR;
typedef int BOOL;
typedef void *PVOID;
typedef UINT32 ULONG_PTR;
typedef UINT32 UINTPTR;
#define NULL 0
#define arrayof(a) (sizeof(a)/sizeof(a[0]))
#define offsetof(s,m) (size_t)&(((s *)0)->m)
#define DO_ACPI 1
//#define DEBUG 1
//////////////////////////////////////////////////////////////////////////////
//
/////////////////////////////////////////// Core types used by runtime system.
//
extern "C" ULONG_PTR _security_cookie = 0;
typedef __wchar_t bartok_char;
typedef signed char int8;
typedef signed short int16;
typedef signed int int32;
typedef __int64 int64;
typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned int uint32;
typedef unsigned __int64 uint64;
typedef float float32;
typedef double float64;
typedef int intptr;
typedef unsigned int uintptr;
struct uintPtr
{
uintptr value;
};
struct intPtr
{
intptr value;
};
typedef struct uintPtr *UIntPtr;
typedef struct intPtr *IntPtr;
/////////////////////////////////////////////////////////////// Static Assert.
//
// Compile-time (not run-time) assertion. Code will not compile if
// expr is false. Note: there is no non-debug version of this; we
// want this for all builds. The compiler optimizes the code away.
//
template <bool x> struct STATIC_ASSERT_FAILURE;
template <> struct STATIC_ASSERT_FAILURE<true> { };
template <int x> struct static_assert_test { };
#define STATIC_CAT_INNER(x,y) x##y
#define STATIC_CAT(x,y) STATIC_CAT_INNER(x,y)
#define STATIC_ASSERT(condition) \
typedef static_assert_test< \
sizeof(STATIC_ASSERT_FAILURE<(bool)(condition)>)> \
STATIC_CAT(__static_assert_typedef_, __COUNTER__)
//////////////////////////////////////////////////////////////////////////////
//
#define OFFSETOF(s,m) ((uintptr)&(((s *)0)->m))
//////////////////////////////////////////////////////////////////////////////
//
#pragma warning(disable: 4103)
#pragma pack(push, 4)
#include "halclass.h"
#pragma pack(pop)
#include "winctx.h"
#include "minidump.h"
//////////////////////////////////////////////////////////////////////////////
//
#define TEST 1
#if TEST
typedef unsigned int uint;
typedef unsigned int UINT;
typedef signed long LARGEST;
typedef unsigned long ULARGEST;
#include "printf.cpp"
#include "debug.cpp"
UINT64 __fastcall RDMSR(UINT32 msr)
{
__asm rdmsr;
}
void WRMSR(UINT32 msr, UINT64 value)
{
__asm {
lea ebx, value;
mov eax, [ebx+0];
mov edx, [ebx+4];
mov ecx, msr;
wrmsr;
}
}
// Routine to read Pentium time stamp counter
_inline _declspec( naked ) UINT64 RDTSC()
{
__asm {
rdtsc;
ret;
}
}
void CPUID(UINT32 feature, UINT32 *output)
{
__asm {
mov eax, feature;
cpuid;
mov edi, output;
mov [edi+0], eax;
mov [edi+4], ebx;
mov [edi+8], ecx;
mov [edi+12], edx;
}
}
void IoSpaceWrite8(UINT16 This, UINT8 Value)
{
__asm {
mov dx,This;
mov al,Value;
out dx,al;
}
}
UINT8 IoSpaceRead8(UINT16 Port)
{
UINT8 Value;
__asm {
mov dx, Port;
in al, dx;
mov Value, al;
}
return Value;
}
void FpuInit()
{
__asm fninit;
}
UINT8 Sum(UINT8 * pbData, int cbData)
{
UINT8 sum = 0;
while (cbData-- > 0) {
sum += *pbData++;
}
return sum;
}
int Checksum(UINT8 * pbData, int cbData)
{
return (Sum(pbData, cbData) == 0);
}
///////////////////////////////////////////////////////////// Screen Routines.
//
static UINT16 s_wAttr = 0x1f00;
void Dim()
{
s_wAttr = 0x1800;
}
void Yellow()
{
s_wAttr = 0x1e00;
}
void Green()
{
s_wAttr = 0x1a00;
}
void Red()
{
s_wAttr = 0x1c00;
}
void Normal()
{
s_wAttr = 0x1f00;
}
static UINT nCursor = 0;
void Halt()
{
Yellow();
printf("Halt.");
__asm hlt;
}
void Cls()
{
BdPrintString("-------------------------------------------------------------------------------\n", 80);
for (UINT16 n = 0; n < 4000; n++)
{
((UINT16*)0xb8000)[n] = s_wAttr | ' ';
}
nCursor = 0;
}
void __cdecl PutChar(char cOut)
{
if (cOut == '\r')
{
nCursor -= nCursor % 80;
}
else if (cOut == '\n')
{
do {
((UINT16*)0xb8000)[nCursor++] = s_wAttr | ' ';
} while ((nCursor % 80) != 0);
}
else
{
((UINT16*)0xb8000)[nCursor++] = (UINT16)(s_wAttr | cOut);
}
while (nCursor >= 4000)
{
UINT16 n = 0;
for (; n < 4000 - 80; n++)
{
((UINT16*)0xb8000)[n] = ((UINT16*)0xb8000)[n + 80];
}
for (; n < 4000; n++)
{
((UINT16*)0xb8000)[n] = s_wAttr | ' ';
}
nCursor -= 80;
}
IoSpaceWrite8(0x3d4, 0xe);
IoSpaceWrite8(0x3d5, (UINT8)(nCursor >> 8));
IoSpaceWrite8(0x3d4, 0xf);
IoSpaceWrite8(0x3d5, (UINT8)(nCursor & 0xff));
static CHAR szBuffer[256];
static INT nBuffer = 0;
szBuffer[nBuffer++] = cOut;
if (cOut == '\n' || nBuffer >= sizeof(szBuffer) - 1) {
BdPrintString(szBuffer, nBuffer);
nBuffer = 0;
}
}
void Probe(UINT8 * pbData, UINT cbData)
{
UINT8 b;
for (UINT i = 0; i < cbData; i++) {
b = pbData[i];
pbData[i] = b;
}
}
void Dump(UINT8 * pbData, UINT cbData)
{
for (UINT n = 0; n < cbData; n += 16) {
printf(" %08x:", pbData + n);
UINT o = n;
for (; o < n + 16; o++) {
if (o >= cbData) {
printf(" ");
}
else {
printf("%02x", pbData[o]);
}
if (o % 4 == 3) {
printf(" ");
}
}
printf(" ");
for (o = n; o < n + 16; o++) {
if (o >= cbData) {
printf(" ");
}
else {
if (pbData[o] >= ' ' && pbData[o] < 127) {
printf("%c", pbData[o]);
}
else {
printf(".");
}
}
}
printf("\n");
}
}
void Dump(UINT8 * pbData, UINT8 * pbLimit, UINT cbMax)
{
UINT cbData = (uint) (pbLimit - pbData);
if (cbData > cbMax) {
cbData = cbMax;
}
Dump(pbData, cbData);
}
#endif
static void CopyUp(UINT8 *pbDst, UINT8 *pbSrc, UINT32 cbSrc)
{
//!!! pbDst >= pbSrc
if (pbDst < pbSrc) {
printf("CopyUp(dst=%p < src=%p)\n", pbDst, pbSrc);
Halt();
}
INT32 nSrc = (cbSrc + 3) / 4;
UINT32 *pDst = ((UINT32*)pbDst) + nSrc;
UINT32 *pSrc = ((UINT32*)pbSrc) + nSrc;
while (nSrc-- > 0) {
*--pDst = *--pSrc;
}
}
static void CopyDown(UINT8 *pbDst, UINT8 *pbSrc, UINT32 cbSrc)
{
//!!! pbDst <= pbSrc
if (pbDst > pbSrc) {
printf("CopyDown(dst=%p > src=%p)\n", pbDst, pbSrc);
Halt();
}
INT32 nSrc = (cbSrc + 3) / 4;
volatile UINT32 *pDst = (UINT32*)pbDst;
volatile UINT32 *pSrc = (UINT32*)pbSrc;
while (nSrc-- > 0) {
*pDst = *pSrc;
if (*pDst != *pSrc) {
printf("CopyDown error at %p/%p : %08x != %08x\n",
pDst, pSrc, *pDst, *pSrc);
Halt();
}
pDst++;
pSrc++;
}
}
const char * SmapTypeToString(int type)
{
switch (type) {
case 1: return "RAM ";
case 2: return "Reserved";
case 3: return "ACPI RAM";
case 4: return "ACPI NVS";
default: return "Other ";
}
}
bool check(UINT8 *pbCache, UINT8 value, const char *pszDesc)
{
for (int i = 0; i < 16; i++) {
if (pbCache[i] == value) {
pbCache[i] = 0;
printf(" %s\n", pszDesc);
return 1;
}
}
return 0;
}
static int wcseq(UINT16 * pwzData, UINT16 * pwzKnown)
{
while (*pwzData && *pwzKnown && *pwzData == *pwzKnown) {
pwzData++;
pwzKnown++;
}
return (*pwzData == *pwzKnown);
}
static int wcslen(UINT16 *pwz)
{
int len = 0;
while (*pwz++) {
len++;
}
return len;
}
static int wcsfindcmd(UINT16 *pwzCmd, UINT16 *pwzKnown)
{
for (;;) {
int len = wcslen(pwzCmd);
if (len == 0) {
return 0;
}
if (wcseq(pwzCmd, pwzKnown) != 0) {
return 1;
}
pwzCmd += len + 1;
}
}
#if DO_ACPI
#include "acpi/acpi.cpp"
#endif
static void CheckPci(const Struct_Microsoft_Singularity_BootInfo *bi)
{
///////////////////////////////////////////////// Check for Compatibility.
//
if ((bi->PciBiosAX >> 8) != 0 || (bi->PciBiosEDX != 0x20494350)) {
Yellow();
printf("Hardware does not support PCI V2.x.\n");
printf("PCI V2.x: AX:%04x, BX:%04x, CX:%04x, EDX:%08x\n",
bi->PciBiosAX, bi->PciBiosBX, bi->PciBiosCX, bi->PciBiosEDX);
Halt();
}
if (!(bi->PciBiosAX & 0x01)) {
Yellow();
printf("Hardware does not support multiple PCI buses.\n");
printf("PCI V2.x: AX:%04x, BX:%04x, CX:%04x, EDX:%08x\n",
bi->PciBiosAX, bi->PciBiosBX, bi->PciBiosCX, bi->PciBiosEDX);
Halt();
}
}
static bool CheckSmapForRam(const Struct_Microsoft_Singularity_BootInfo *bi, UINT64 base, UINT64 size)
{
Struct_Microsoft_Singularity_SMAPINFO *sm = (Struct_Microsoft_Singularity_SMAPINFO *)bi->SmapData32;
for (UINT i = 0; i < bi->SmapCount; i++) {
if (sm[i].type == 1 &&
sm[i].addr <= base &&
sm[i].addr + sm[i].size >= base + size) {
return true;
}
}
return false;
}
static void CheckSmap(const Struct_Microsoft_Singularity_BootInfo *bi)
{
/////////////////////////////////////////////////////// System Memory Map.
//
printf(" Base Address Limit Address Type \n");
printf(" ================ ================ ==========\n");
Struct_Microsoft_Singularity_SMAPINFO *sm = (Struct_Microsoft_Singularity_SMAPINFO *)bi->SmapData32;
for (UINT i = 0; i < bi->SmapCount; i++) {
printf(" %16lx", (UINT64)sm[i].addr);
printf(" %16lx", (UINT64)sm[i].addr + (UINT64)sm[i].size);
printf(" %d:%s\n",
sm[i].type,
SmapTypeToString((int)sm[i].type));
}
printf("\n");
}
static void DumpFeatures(UINT32 features)
{
printf(" ");
if (features & 0x1) { printf("x87 "); }
if (features & 0x2) { printf("VME "); }
if (features & 0x4) { printf("DBG "); }
if (features & 0x8) { printf("PSE "); }
if (features & 0x10) { printf("TSC "); }
if (features & 0x20) { printf("MSR "); }
if (features & 0x40) { printf("PAE "); }
if (features & 0x80) { printf("MCE "); }
if (features & 0x100) { printf("CX8 "); }
if (features & 0x200) { printf("APIC "); }
if (features & 0x200) { printf("R0 "); }
if (features & 0x800) { printf("SEP "); }
if (features & 0x1000) { printf("MTRR "); }
if (features & 0x2000) { printf("PGE "); }
if (features & 0x4000) { printf("MCA "); }
if (features & 0x8000) { printf("CMOV "); }
printf("\n ");
if (features & 0x10000) { printf("PAT "); }
if (features & 0x20000) { printf("PSE36 "); }
if (features & 0x40000) { printf("PSN "); }
if (features & 0x80000) { printf("CFLUSH "); }
if (features & 0x100000) { printf("R1 "); }
if (features & 0x200000) { printf("DS "); }
if (features & 0x400000) { printf("ACPI "); }
if (features & 0x800000) { printf("MMX "); }
if (features & 0x1000000) { printf("FXSR "); }
if (features & 0x2000000) { printf("SSE "); }
if (features & 0x4000000) { printf("SSE2 "); }
if (features & 0x8000000) { printf("SS "); }
if (features & 0x10000000) { printf("HTT "); }
if (features & 0x20000000) { printf("TM "); }
if (features & 0x40000000) { printf("R2 "); }
if (features & 0x80000000) { printf("PBE "); }
printf("\n");
}
static void CheckCpuid(const Struct_Microsoft_Singularity_BootInfo *bi)
{
/////////////////////////////////////////////////////////////////// CPUID.
#if 1
{
UINT32 output[4];
CPUID(1, output);
UINT family = (output[0] & 0xf00) >> 8;
UINT model = (output[0] & 0x0f0) >> 4;
UINT step = (output[0] & 0x00f);
UINT brand = (output[1] & 0xff);
if (family == 0xf) {
family += (output[0] & 0xff00000) >> 24;
}
if (model == 0xf) {
model += (output[0] & 0xf0000) >> 16;
}
CPUID(0, output);
printf("CPUID: %c%c%c%c%c%c%c%c%c%c%c%c Family %d, Model %d, Step %d, Brand %d\n",
((char *)output)[4],
((char *)output)[5],
((char *)output)[6],
((char *)output)[7],
((char *)output)[12],
((char *)output)[13],
((char *)output)[14],
((char *)output)[15],
((char *)output)[8],
((char *)output)[9],
((char *)output)[10],
((char *)output)[11],
family, model, step, brand);
UINT32 max = output[0];
for (UINT32 i = 3; i <= max; i++) {
CPUID(i, output);
printf(" %08x: %08x %08x %08x %08x\n",
i, output[0], output[1], output[2], output[3]);
}
CPUID(1, output);
#if DEBUG
if ((output[1] & 0xff00) != 0) {
printf(" CFlush %d bytes\n", ((output[1] & 0xff00) >> 8) * 8);
}
if ((output[1] & 0xff0000) != 0) {
printf(" Hyperthreads: %d\n", (output[1] & 0xff0000) >> 16);
}
if ((output[1] & 0xff000000) != 0xff) {
printf(" Local APIC Id: %d\n", (output[1] & 0xff000000) >> 24);
}
#endif
printf(" Features: ");
if (output[2] & 0x80) { printf("EST "); }
if (output[2] & 0x100) { printf("TM2 "); }
if (output[2] & 0x400) { printf("L1C "); }
printf("\n");
DumpFeatures(output[3]);
#if DEBUG
printf(" Caches:\n");
CPUID(2, output);
for (int j = 0; j < 4; j++) {
if (output[j] & 0x80000000) {
output[j] = 0;
}
}
output[0] &= 0xffffff00;
UINT8 *pbCache = (UINT8*)output;
check(pbCache, 0x01, "ITLB: 4KB Pages, 4-way, 32 entries");
check(pbCache, 0x02, "ITLB: 4MB Pages, 4-way, 2 entries");
check(pbCache, 0x03, "DTLB: 4KB Pages, 4-way, 64 entries");
check(pbCache, 0x04, "DTLB: 4MB Pages, 4-way, 8 entries");
check(pbCache, 0x06, "L1-I: 8KB, 4-way, 32 byte line size");
check(pbCache, 0x08, "L1-I: 16KB, 4-way, 32 byte line size");
check(pbCache, 0x0A, "L1-D: 8KB, 2-way, 32 byte line size");
check(pbCache, 0x0C, "L1-D: 16KB, 4-way, 32 byte line size");
check(pbCache, 0x22, "L3 : 512KB, 4-way, 64 byte line size, 128 byte sector size");
check(pbCache, 0x23, "L3 : 1MB, 8-way, 64 byte line size, 128 byte sector size");
check(pbCache, 0x25, "L3 : 2MB, 8-way, 64 byte line size, 128 byte sector size");
check(pbCache, 0x29, "L3 : 4MB, 8-way, 64 byte line size, 128 byte sector size");
check(pbCache, 0x2C, "L1-D: 32KB, 8-way, 64 byte line size");
check(pbCache, 0x30, "L1-I: 32KB, 8-way, 64 byte line size");
check(pbCache, 0x40, "----: No L2 or, if processor contains a valid L2, no L3");
check(pbCache, 0x41, "L2 : 128KB, 4-way, 32 byte line size");
check(pbCache, 0x42, "L2 : 256KB, 4-way, 32 byte line size");
check(pbCache, 0x43, "L2 : 512KB, 4-way, 32 byte line size");
check(pbCache, 0x44, "L2 : 1MB, 4-way, 32 byte line size");
check(pbCache, 0x45, "L2 : 2MB, 4-way, 32 byte line size");
check(pbCache, 0x50, "ITLB: 4KB and 4MB pages, 64 entries");
check(pbCache, 0x51, "ITLB: 4KB and 4MB pages, 128 entries");
check(pbCache, 0x52, "ITLB: 4KB and 4MB pages, 256 entries");
check(pbCache, 0x5B, "DTLB: 4KB and 4MB pages, 64 entries");
check(pbCache, 0x5C, "DTLB: 4KB and 4MB pages, 128 entries");
check(pbCache, 0x5D, "DTLB: 4KB and 4MB pages, 256 entries");
check(pbCache, 0x60, "L1-D: 16KB, 8-way, 64 byte line size");
check(pbCache, 0x66, "L1-D: 8KB, 4-way, 64 byte line size");
check(pbCache, 0x67, "L1-D: 16KB, 4-way, 64 byte line size");
check(pbCache, 0x68, "L1-D: 32KB, 4-way, 64 byte line size");
check(pbCache, 0x70, "TC : 12K-uop, 8-way");
check(pbCache, 0x71, "TC : 16K-uop, 8-way");
check(pbCache, 0x72, "TC : 32K-uop, 8-way");
check(pbCache, 0x78, "L2 : 1MB, 8-way, 64 byte line size");
check(pbCache, 0x79, "L2 : 128KB, 8-way, 64 byte line size, 128 byte sector size");
check(pbCache, 0x7A, "L2 : 256KB, 8-way, 64 byte line size, 128 byte sector size");
check(pbCache, 0x7B, "L2 : 512KB, 8-way, 64 byte line size, 128 byte sector size");
check(pbCache, 0x7C, "L2 : 1MB, 8-way, 64 byte line size, 128 byte sector size");
check(pbCache, 0x7D, "L2 : 2MB, 8-way, 64 byte line size");
check(pbCache, 0x7F, "L2 : 512KB, 2-way, 64 byte line size");
check(pbCache, 0x82, "L2 : 256KB, 8-way, 32 byte line size");
check(pbCache, 0x83, "L2 : 512KB, 8-way, 32 byte line size");
check(pbCache, 0x84, "L2 : 1MB, 8-way, 32 byte line size");
check(pbCache, 0x85, "L2 : 2MB, 8-way, 32 byte line size");
check(pbCache, 0x86, "L2 : 512KB, 4-way, 64 byte line size");
check(pbCache, 0x87, "L2 : 1MB, 8-way, 64 byte line size");
check(pbCache, 0xB0, "ITLB: 4KB Pages, 4-way, 128 entries");
check(pbCache, 0xB3, "DTLB: 4KB Pages, 4-way, 128 entries");
check(pbCache, 0xF0, "----: 64 byte prefetch");
check(pbCache, 0xF1, "----: 128 byte prefetch");
for (int j = 0; j < 16; j++) {
if (pbCache[j] != 0) {
printf(" Missed %02x\n", pbCache[j]);
}
}
#endif
CPUID(0x80000000, output);
if ((output[0] & 0x80000000)) {
UINT32 max = output[0];
#if DEBUG
printf("Max ext CPUID = %x\n", max);
for (UINT32 i = 0x80000005; i <= max; i++) {
CPUID(i, output);
printf(" %08x: %08x %08x %08x %08x\n",
i, output[0], output[1], output[2], output[3]);
}
#endif
CPUID(0x80000001, output);
if (output[3] != 0) {
printf(" AMD Features:\n");
printf(" ");
if (output[3] & 0x1) { printf("x87 "); }
if (output[3] & 0x2) { printf("VME "); }
if (output[3] & 0x4) { printf("DBG "); }
if (output[3] & 0x8) { printf("PSE "); }
if (output[3] & 0x10) { printf("TSC "); }
if (output[3] & 0x20) { printf("MSR "); }
if (output[3] & 0x40) { printf("PAE "); }
if (output[3] & 0x80) { printf("MCE "); }
if (output[3] & 0x100) { printf("CX8 "); }
if (output[3] & 0x200) { printf("APIC "); }
if (output[3] & 0x400) { printf("R0 "); }
if (output[3] & 0x800) { printf("FSEP "); }
if (output[3] & 0x1000) { printf("MTRR "); }
if (output[3] & 0x2000) { printf("PGE "); }
if (output[3] & 0x4000) { printf("MCA "); }
if (output[3] & 0x8000) { printf("CMOV "); }
printf("\n ");
if (output[3] & 0x10000) { printf("PAT "); }
if (output[3] & 0x20000) { printf("PSE36 "); }
if (output[3] & 0x40000) { printf("R1 "); }
if (output[3] & 0x80000) { printf("R2 "); }
if (output[3] & 0x100000) { printf("NX "); }
if (output[3] & 0x200000) { printf("R3 "); }
if (output[3] & 0x400000) { printf("xMMX "); }
if (output[3] & 0x800000) { printf("MMX "); }
if (output[3] & 0x1000000) { printf("FXSR "); }
if (output[3] & 0x2000000) { printf("FFXSR "); }
if (output[3] & 0x4000000) { printf("R4 "); }
if (output[3] & 0x8000000) { printf("R5 "); }
if (output[3] & 0x10000000) { printf("R6 "); }
if (output[3] & 0x20000000) { printf("LM "); }
if (output[3] & 0x40000000) { printf("x3D "); }
if (output[3] & 0x80000000) { printf("3D "); }
printf("\n");
}
CHAR szBrand[64];
CPUID(0x80000002, (UINT32*)&szBrand[0]);
CPUID(0x80000003, (UINT32*)&szBrand[16]);
CPUID(0x80000004, (UINT32*)&szBrand[32]);
szBrand[48] = '\0';
CHAR *pszBrand = szBrand;
while (*pszBrand == ' ') {
pszBrand++;
}
printf(" Brand: %s\n", pszBrand);
}
printf("\n");
}
#endif
}
static void CheckApic(const Struct_Microsoft_Singularity_BootInfo *bi)
{
////////////////////////////////////////////////////// Local and I/O APIC.
//
#if DEBUG
UINT32 apicid = 0;
UINT32 apicver = 0;
printf(" IO APIC:\n");
for (UINT32 base = 0xfec00000; base <= 0xfec0fc00; base += 0x400) {
__asm {
mov ebx, base;
mov eax, 0;
mov [ebx], eax;
mov eax, [ebx+0x10];
mov apicid, eax;
mov eax, 1;
mov [ebx], eax;
mov eax, [ebx+0x10];
mov apicver, eax;
}
if (apicid == ~0u && apicver == ~0u) {
continue;
}
printf(" %08x: %08x %08x\n", base, apicid, apicver);
}
printf(" Local APIC:\n");
for (UINT32 base = 0xfee00000; base <= 0xfee00000; base += 0x400) {
__asm {
mov ebx, base;
mov eax, [ebx+0x20];
mov apicid, eax;
mov eax, [ebx+0x30];
mov apicver, eax;
}
printf(" %08x: id=%08x ver=%08x\n", base, apicid, apicver);
}
printf(" MSR[0x%02x] = %016lx\n", 0x10, RDMSR(0x10));
//printf(" MSR[0x%02x] = %016lx\n", 0x17, RDMSR(0x17));
//printf(" MSR[0x%02x] = %016lx\n", 0x1b, RDMSR(0x1b));
printf("\n");
#endif
}
struct ACPI_RSDP
{
CHAR Signature[8]; // "RSD PTR "
UINT8 Checksum;
CHAR OemId[6];
UINT8 Revision;
UINT32 RsdtAddress;
UINT32 RsdtLength;
UINT32 XsdtAddrLo;
UINT32 XsdtAddrHi;
UINT8 ExtendedChecksum;
UINT8 Reserved[3];
};
typedef ACPI_RSDP * PACPI_RSDP;
int IsAcpiRsdp(PACPI_RSDP pScan)
{
if (pScan->Signature[0] != 'R' || pScan->Signature[1] != 'S' ||
pScan->Signature[2] != 'D' || pScan->Signature[3] != ' ' ||
pScan->Signature[4] != 'P' || pScan->Signature[5] != 'T' ||
pScan->Signature[6] != 'R' || pScan->Signature[7] != ' ') {
return 0;
}
return Checksum((UINT8*)pScan, 20);
}
static void CheckAcpi(Struct_Microsoft_Singularity_BootInfo *bi)
{
/////////////////////////////////////////////////////////// Scan for ACPI.
//
PACPI_RSDP pAcpi = NULL;
for (UINT8 *pbScan = (UINT8*)0xe0000; pbScan < (UINT8*)0xfffff; pbScan += 0x10) {
PACPI_RSDP pScan = (PACPI_RSDP)pbScan;
if (IsAcpiRsdp(pScan)) {
pAcpi = pScan;
break;
}
}
if (pAcpi == NULL && bi->Ebda32 != NULL) {
#if 0
printf("bi->Ebda32 = %08x\n", bi->Ebda32);
Dump((UINT8*)bi->Ebda32, 0x400);
#endif
for (UINT8 *pbScan = (UINT8*)bi->Ebda32;
pbScan < (UINT8*)bi->Ebda32 + 0x400; pbScan += 0x10) {
PACPI_RSDP pScan = (PACPI_RSDP)pbScan;
if (IsAcpiRsdp(pScan)) {
pAcpi = pScan;
break;
}
}
}
bi->AcpiRoot32 = (UINT)pAcpi;
#if DO_ACPI
if (pAcpi != NULL) {
printf("ACPI Information:\n");
Acpi(pAcpi);
}
#endif
}
//////////////////////////////////////////////////////////////////////////////
//
struct MP_FLOAT
{
UINT8 Signature[4]; // "_MP_"
UINT32 AddrMpConfigTable32; //canonical form
UINT8 Paragraphs;
UINT8 Version;
UINT8 Checksum;
UINT8 Features[5];
};
struct MP_FIXED
{
UINT8 Signature[4];
UINT16 BaseTableSize;
UINT8 Version;
UINT8 Checksum;
UINT8 OemId[8];
UINT8 ProductId[12];
UINT32 AddrOemTablePointer; //canonical form
UINT16 OemTableSize;
UINT32 LocalAPIC;
UINT16 ExtendedTableSize;
UINT8 ExtendedTableChecksum;
};
struct MP_PROCESSOR
{
UINT8 EntryType; // == 0x00
UINT8 ApicId;
UINT8 ApicVersion;
UINT8 Flags;
UINT32 Signature;
UINT32 Features;
UINT32 Reserved0;
UINT32 Reserved1;
};
struct MP_BUS
{
UINT8 EntryType; // == 0x01
UINT8 BusId;
UINT8 BusType[6];
};
struct MP_IO_APIC
{
UINT8 EntryType; // == 0x02
UINT8 ApicId;
UINT8 ApicVersion;
UINT8 Flags;
UINT32 Address;
};
struct MP_IO_INTERRUPT
{
UINT8 EntryType; // == 0x03
UINT8 Type;
UINT16 Flags;
UINT8 SrcBusId;
UINT8 SrcBusIrq;
UINT8 DstApicId;
UINT8 DstApicIrq;
};
struct MP_LOCAL_INTERRUPT
{
UINT8 EntryType; // == 0x04
UINT8 Type;
UINT16 Flags;
UINT8 SrcBusId;
UINT8 SrcBusIrq;
UINT8 DstApicId;
UINT8 DstApicIrq;
};
struct MP_ADDRESS_SPACE_MAPPING
{
UINT8 EntryType; // == 0x80
UINT8 EntrySize;
UINT8 BusId;
UINT8 AddressType;
UINT64 AddressBase;
UINT64 AddressSize;
};
struct MP_BUS_HIERARCHY
{
UINT8 EntryType; // == 0x81
UINT8 EntrySize;
UINT8 BusId;
UINT8 BusInfo;
UINT8 ParentBusId;
UINT8 Reserved[3];
};
struct MP_ADDRESS_SPACE_MODIFIER
{
UINT8 EntryType; // == 0x82
UINT8 EntrySize;
UINT8 BusId;
UINT8 Predefined;
UINT32 RangeList;
};
int IsMpsFps(MP_FLOAT * pScan)
{
if (pScan->Signature[0] != '_' || pScan->Signature[1] != 'M' ||
pScan->Signature[2] != 'P' || pScan->Signature[3] != '_') {
return 0;
}
return Checksum((UINT8*)pScan, pScan->Paragraphs * 0x10);
}
MP_FLOAT * ScanForMp(UINT8 * pbBase, UINT8 * pbLimit)
{
for (; pbBase < pbLimit; pbBase += 0x10) {
MP_FLOAT * pScan = (MP_FLOAT *)pbBase;
if (IsMpsFps(pScan)) {
return pScan;
}
}
return NULL;
}
static void CheckMp(Struct_Microsoft_Singularity_BootInfo *bi)
{
printf("MP Information:\n");
const UINT16 CMOS_SELECT = 0x70;
const UINT16 CMOS_DATA = 0x71;
IoSpaceWrite8(CMOS_SELECT, 0xf);
UINT8 boot = IoSpaceRead8(CMOS_DATA);
#if DEBUG
printf("CMOS Boot type = %02x\n", boot);
#endif
if ((bi->MpEnter32 & 0xfff00fff) != 0) {
printf("MpEnter is not valid for IPI Startup: %08x\n", bi->MpEnter32);
Halt();
}
//////////////////////////////////////////////////////////// Scan for MPS.
//
MP_FLOAT * pFloat = NULL;
if (pFloat == NULL && bi->Ebda32 != NULL) {
pFloat = ScanForMp((UINT8*)bi->Ebda32, (UINT8*)bi->Ebda32 + 0x400);
}
if (pFloat == NULL) {
pFloat = ScanForMp((UINT8*)0x9fc00, (UINT8*)0xa0000);
}
if (pFloat == NULL) {
pFloat = ScanForMp((UINT8*)0x7fc00, (UINT8*)0x80000);
}
if (pFloat == NULL) {
pFloat = ScanForMp((UINT8*)0xf0000, (UINT8*)0xfffff);
}
if (pFloat == NULL) {
return;
}
printf(" Found MPS Version 1.%d at %lp\n", pFloat->Version, pFloat);
if (pFloat->Version < 4) {
pFloat = NULL;
return;
}
bi->MpFloat32 = (UINT32) pFloat;
#if DEBUG
printf(" MpConfigTable32=%x, Features=%02x%02x%02x%02x%02x\n",
pFloat->AddrMpConfigTable32,
pFloat->Features[0],
pFloat->Features[1],
pFloat->Features[2],
pFloat->Features[3],
pFloat->Features[4]);
#endif
if (pFloat->AddrMpConfigTable32) {
#if DEBUG
MP_FIXED * pFixed = (MP_FIXED *) pFloat->AddrMpConfigTable32;
printf(" %c%c%c%c len=%d ver=%d sum=%02x\n",
pFixed->Signature[0],
pFixed->Signature[1],
pFixed->Signature[2],
pFixed->Signature[3],
pFixed->BaseTableSize,
pFixed->Version,
pFixed->Checksum);
printf(" Oem=[%-8.8s] Product=[%-12.12s] table=%x size=%d\n",
pFixed->OemId,
pFixed->ProductId,
pFixed->AddrOemTablePointer,
pFixed->OemTableSize);
printf(" LocalAPIC=%08x ExtSize=%d ExtSum=%02x\n",
pFixed->LocalAPIC,
pFixed->ExtendedTableSize,
pFixed->ExtendedTableChecksum);
UINT8 *pbBegin = ((UINT8*)pFixed) + sizeof(*pFixed);
UINT8 *pbLimit = ((UINT8*)pFixed) + pFixed->BaseTableSize;
while (pbBegin < pbLimit) {
printf(" %4d: ", pbBegin - ((UINT8*)pFixed));
switch (pbBegin[0]) {
case 0:
{
MP_PROCESSOR *pProc = (MP_PROCESSOR *)pbBegin;
printf("Proc Apic=%02x Ver=%02x Flags=%02x Sign=%08x Feat=%08x\n",
pProc->ApicId,
pProc->ApicVersion,
pProc->Flags,
pProc->Signature,
pProc->Features);
DumpFeatures(pProc->Features);
pbBegin = (UINT8*)(pProc + 1);
}
break;
case 1:
{
MP_BUS *pBus = (MP_BUS *)pbBegin;
printf("Bus Id=%02x Type=[%-6.6s]\n",
pBus->BusId,
pBus->BusType);
pbBegin = (UINT8*)(pBus + 1);
}
break;
case 2:
{
MP_IO_APIC *pApic = (MP_IO_APIC *)pbBegin;
printf("Apic Apic=%02x Ver=%02x Flags=%02x Address=%08x\n",
pApic->ApicId,
pApic->ApicVersion,
pApic->Flags,
pApic->Address);
pbBegin = (UINT8*)(pApic + 1);
}
break;
case 3:
{
MP_IO_INTERRUPT *pInterrupt = (MP_IO_INTERRUPT *)pbBegin;
printf("I/O Type=%02x Flags=%04x [Bus=%02x Irq=%02x] -> [Apic=%02x Irq=%02x]\n",
pInterrupt->Type,
pInterrupt->Flags,
pInterrupt->SrcBusId,
pInterrupt->SrcBusIrq,
pInterrupt->DstApicId,
pInterrupt->DstApicIrq);
pbBegin = (UINT8*)(pInterrupt + 1);
}
break;
case 4:
{
MP_LOCAL_INTERRUPT *pInterrupt = (MP_LOCAL_INTERRUPT *)pbBegin;
printf("Loc Type=%02x Flags=%04x [Id=%02x Irq=%02x] -> [Id=%02x Irq=%02x]\n",
pInterrupt->Type,
pInterrupt->Flags,
pInterrupt->SrcBusId,
pInterrupt->SrcBusIrq,
pInterrupt->DstApicId,
pInterrupt->DstApicIrq);
pbBegin = (UINT8*)(pInterrupt + 1);
}
break;
default:
printf("Unknown Configuration Type = %02x\n", pbBegin[0]);
pbBegin = pbLimit;
break;
}
}
pbBegin = ((UINT8*)pFixed) + pFixed->BaseTableSize;
pbLimit = pbBegin + pFixed->ExtendedTableSize;
while (pbBegin < pbLimit) {
printf(" %4d: ", pbBegin - ((UINT8*)pFixed));
switch (pbBegin[0]) {
case 0x80:
{
MP_ADDRESS_SPACE_MAPPING *pMap = (MP_ADDRESS_SPACE_MAPPING *)pbBegin;
printf("Map Bus=%02x Type=%02x Base=%08lx Size=%08lx\n",
pMap->BusId,
pMap->AddressType,
pMap->AddressBase,
pMap->AddressSize);
}
break;
case 0x81:
{
MP_BUS_HIERARCHY *pHier = (MP_BUS_HIERARCHY *)pbBegin;
printf("Hier Bus=%02x Info=%02x ParentBusId=%02x\n",
pHier->BusId,
pHier->BusInfo,
pHier->ParentBusId);
}
break;
case 0x82:
{
MP_ADDRESS_SPACE_MODIFIER *pMap = (MP_ADDRESS_SPACE_MODIFIER *)pbBegin;
printf("Mod Bus=%02x Prefined=%02x RangeList=%08x\n",
pMap->BusId,
pMap->Predefined,
pMap->RangeList);
}
break;
default:
printf("Unknown Extended Type = %02x (len=%d bytes)\n", pbBegin[0], pbBegin[1]);
break;
}
pbBegin += pbBegin[1];
}
#endif
#if BOOT_START_MP
printf(" MP Init:\n");
volatile UINT32 * LocalApicIcrLo = (UINT32 *)(pFixed->LocalAPIC + 0x300);
volatile UINT32 * LocalApicIcrHi = (UINT32 *)(pFixed->LocalAPIC + 0x310);
volatile UINT32 * LocalApicEoi = (UINT32 *)(pFixed->LocalAPIC + 0x0b0);
volatile UINT32 * LocalApicEsr = (UINT32 *)(pFixed->LocalAPIC + 0x280);
const UINT32 AllExcludingSelf = 0xc0000;
const UINT32 LevelAssert = 0x04000;
const UINT32 SendPending = 0x01000;
const UINT32 DeliveryStartup = 0x00600;
const UINT32 DeliveryInit = 0x00500;
printf(" Sending IPI Init.\n");
*LocalApicEsr = 0;
*LocalApicEsr = 0;
*LocalApicIcrLo = (AllExcludingSelf |
LevelAssert |
SendPending |
DeliveryInit);
while (*LocalApicIcrLo & SendPending) {
__asm pause;
// Write tells APIC to update ESR.
*LocalApicEsr = 0;
if (*LocalApicEsr != 0) {
printf(" APIC Error: %08x\n", *LocalApicEsr);
break;
}
}
printf(" Sent IPI Init.\n");
for (int i = 0; i < 10000; i++) {
}
for (int i = 0; i < 2; i++) {
printf( "Sending IPI Startup %d.\n", i);
*LocalApicEsr = 0;
*LocalApicEsr = 0;
*LocalApicIcrLo = (AllExcludingSelf |
LevelAssert |
SendPending |
DeliveryStartup |
(bi->MpEnter32 >> 12));
while (*LocalApicIcrLo & SendPending) {
__asm pause;
// Write tells APIC to update ESR.
*LocalApicEsr = 0;
if (*LocalApicEsr != 0) {
printf(" APIC Error: %08x\n", *LocalApicEsr);
break;
}
}
printf(" Sent IPI Startup.\n");
for (int i = 0; i < 10000; i++) {
}
}
#endif // BOOT_START_MP
}
printf("\n");
}
static void CheckMinidump(Struct_Microsoft_Singularity_BootInfo *bi, uintptr *pEntry, uintptr *pStack)
{
//////////////////////////////////////////////////////////// Vet Minidump.
//
UINT8* pbImage = (UINT8*)bi->DumpAddr32;
UINT32 cbImage = bi->DumpSize32;
UINT32 *plHeader = (UINT32*)pbImage;
UINT32 *plTrailer = NULL;
#if DEBUG
printf("Minidump at %x\n", pbImage);
#endif
if (plHeader[0] != MINIDUMP_SIGNATURE ||
plHeader[1] != MINIDUMP_VERSION) {
printf("Image is corrupt!\n");
printf(" Addr: %8x, Size: %8x\n", bi->DumpAddr32, bi->DumpSize32);
printf(" %08x != %08x, %08x != %08x\n",
MINIDUMP_SIGNATURE, plHeader[0],
MINIDUMP_VERSION, plHeader[1]);
Halt();
}
/////////////////////////////////////////////////////// Size the Minidump.
//
UINT32 Entry = 0;
UINT32 Stack = 0;
UINT32 Base = 0xffffffff;
UINT32 Limit = 0;
UINT32 cbSave = 0xfffffff;
PMINIDUMP_HEADER pHeader = (PMINIDUMP_HEADER)(pbImage + 0);
PMINIDUMP_DIRECTORY pDir
= (PMINIDUMP_DIRECTORY)(pbImage + pHeader->StreamDirectoryRva);
#if DEBUG
printf(" Streams: %d\n", pHeader->NumberOfStreams);
#endif
for (UINT i = 0; i < pHeader->NumberOfStreams; i++) {
switch (pDir[i].StreamType) {
case ThreadListStream:
{
PMINIDUMP_THREAD_LIST pl =
(PMINIDUMP_THREAD_LIST)(pbImage + pDir[i].Location.Rva);
#if DEBUG
printf(" Threads: %d\n", pl->NumberOfThreads);
#endif
for (UINT t = 0; t < pl->NumberOfThreads; t++) {
PCONTEXT pContext = (PCONTEXT)(pbImage + pl->Threads[t].ThreadContext.Rva);
Entry = pContext->Eip;
Stack = pContext->Esp;
#if DEBUG
printf(" entry: %x, stack %x \n", Entry, Stack);
#endif
}
}
break;
case MemoryListStream:
{
PMINIDUMP_MEMORY_LIST pl =
(PMINIDUMP_MEMORY_LIST)(pbImage + pDir[i].Location.Rva);
#if DEBUG
printf(" Number of Memory Ranges: %d, pl =%lx \n", pl->NumberOfMemoryRanges);
for (UINT t = 0; t < pl->NumberOfMemoryRanges; t++) {
printf(" stream at %lx, size =%lx \n",
pl->MemoryRanges[t].StartOfMemoryRange,
pl->MemoryRanges[t].Memory.DataSize);
}
#endif
for (UINT t = 0; t < pl->NumberOfMemoryRanges; t++) {
if (cbSave > pl->MemoryRanges[t].Memory.Rva) {
cbSave = pl->MemoryRanges[t].Memory.Rva;
}
UINT32 pbDst = (UINT32)pl->MemoryRanges[t].StartOfMemoryRange;
UINT32 cbSrc = (UINT32)pl->MemoryRanges[t].Memory.DataSize;
if (!CheckSmapForRam(bi,
pl->MemoryRanges[t].StartOfMemoryRange,
pl->MemoryRanges[t].Memory.DataSize)) {
printf("No RAM available at %lx..%lx.\n",
pl->MemoryRanges[t].StartOfMemoryRange,
pl->MemoryRanges[t].StartOfMemoryRange +
pl->MemoryRanges[t].Memory.DataSize);
Halt();
}
if (pbDst > 0x100000) {
if (Base > pbDst) {
Base = pbDst;
}
if (Limit < pbDst + cbSrc) {
Limit = pbDst + cbSrc;
}
}
}
}
break;
case 0xcafeface:
plTrailer = (UINT32 *)(pbImage + pDir[i].Location.Rva);
break;
}
}
/////////////////////////////////////////////////// Validate the minidump.
if (plTrailer == NULL || plTrailer[0] != 0xfeedbeef || plTrailer[1] != 0xcafeface) {
printf("Image is corrupt!\n");
printf(" Addr: %8x, Size: %8x\n", bi->DumpAddr32, bi->DumpSize32);
printf(" 0xfeedbeef != 0x%08x, 0xcafeface != 0x%08x\n",
plTrailer[0], plTrailer[1]);
Halt();
}
else {
UINT32 *plPos = (UINT32*)pbImage;
UINT32 *plEnd = (UINT32*)(plTrailer + 4);
UINT32 sum = 0;
for (; plPos < plEnd;) {
sum += *plPos++;
}
if (sum != 0) {
printf("Image is corrupt!\n");
printf(" Addr: %8x, Size: %8x\n", bi->DumpAddr32, bi->DumpSize32);
printf(" Checksum: %08x\n", sum);
Halt();
}
}
///////////////////////////////////////////////////// Expand the minidump.
//
for (UINT i = 0; i < pHeader->NumberOfStreams; i++) {
if (pDir[i].StreamType == MemoryListStream) {
PMINIDUMP_MEMORY_LIST pl =
(PMINIDUMP_MEMORY_LIST)(pbImage + pDir[i].Location.Rva);
for (UINT t = 0; t < pl->NumberOfMemoryRanges; t++) {
UINT8 *pbSrc = pbImage + pl->MemoryRanges[t].Memory.Rva;
UINT8 *pbDst = (UINT8*)pl->MemoryRanges[t].StartOfMemoryRange;
UINT32 cbSrc = pl->MemoryRanges[t].Memory.DataSize;
if (pbDst < (UINT8*)0x100000) {
// Don't write into memory below 1MB.
#if DEBUG
printf(" %p..%p -> %p..%p Ignored.\n",
pbSrc, pbSrc + cbSrc,
pbDst, pbDst + cbSrc);
#endif
}
else {
#if DEBUG
printf(" %p..%p -> %p..%p Copied\n",
pbSrc, pbSrc + cbSrc,
pbDst, pbDst + cbSrc);
#endif
CopyDown(pbDst, pbSrc, cbSrc);
}
}
}
}
#if DEBUG
printf(" Minidump at %x..%x\n",
bi->DumpAddr32, bi->DumpAddr32 + bi->DumpSize32);
printf(" Kernel at %x..%x [Entry=%x, Stack=%x]\n", Base, Limit, Entry, Stack);
#endif
*pEntry = Entry;
*pStack = Stack;
bi->DumpBase = Base;
bi->DumpLimit = Limit;
bi->DumpRemainder = (UINT32)(plTrailer + 4);
}
static uintptr g_Entry = 0;
static uintptr g_Stack = 0;
static Struct_Microsoft_Singularity_BootInfo *g_bi = 0;
static Struct_Microsoft_Singularity_X86_IDTP g_idt;
static Struct_Microsoft_Singularity_X86_IDTE g_idtEntries[32];
extern "C" void __cdecl IdtHandler(UINT32 _cr2,
UINT32 _edi, UINT32 _esi, UINT32 _ebp, UINT32 _esp,
UINT32 _ebx, UINT32 _edx, UINT32 _ecx, UINT32 _eax,
UINT32 _num, UINT32 _err, UINT32 _eip, UINT32 _cs0,
UINT32 _efl)
{
printf("\n");
printf("=-=-=-= X86 Exception 0x%x [%x] =-=-=-=\n", _num, &_efl);
printf("err=%08x cr2=%08x eip=%08x efl=%08x\n",
_err, _cr2, _eip, _efl);
printf("eax=%08x ebx=%08x ecx=%08x edx=%08x\n",
_eax, _ebx, _ecx, _edx);
printf("esi=%08x edi=%08x ebp=%08x esp=%08x\n",
_esi, _edi, _ebp, _esp);
printf("Stack:\n");
UINT32 * stack = ((UINT32*)_esp);
for (int i = 0; i < 10; i++) {
printf(" %08x: %08x\n", &stack[i], stack[i]);
}
printf("Call Stack:\n");
for (int i = 0; i < 10 && _ebp >= Struct_Microsoft_Singularity_BootInfo_PHYSICAL_DISABLED; i++) {
ULONG_PTR next = ((ULONG_PTR *)_ebp)[0];
ULONG_PTR code = ((ULONG_PTR *)_ebp)[1];
printf(" %p: %p %p\n", _ebp, next, code);
_ebp = next;
}
Halt();
for (;;);
}
static void IdtInit()
{
Struct_Microsoft_Singularity_BootInfo *bi = g_bi;
UINT32 entry = (UINT32)bi->IdtEnter0;
UINT32 offset = ((UINT32)bi->IdtEnter1) - ((UINT32)bi->IdtEnter0);
for (int i = 0; i < arrayof(g_idtEntries); i++) {
g_idtEntries[i].offset_0_15 = (UINT16)entry;
g_idtEntries[i].selector =
(UINT16)(offsetof(Struct_Microsoft_Singularity_CpuInfo,GdtPC) -
offsetof(Struct_Microsoft_Singularity_CpuInfo,GdtNull));
g_idtEntries[i].access =
(Struct_Microsoft_Singularity_X86_IDTE_PRESENT |
Struct_Microsoft_Singularity_X86_IDTE_DPL_RING0 |
Struct_Microsoft_Singularity_X86_IDTE_INT_GATE);
g_idtEntries[i].offset_16_31 = (UINT16)(entry >> 16);
entry += offset;
}
*(void **)bi->IdtTarget = (void *)IdtHandler;
g_idt.limit = sizeof(g_idtEntries);
g_idt.addr = (UINT32)g_idtEntries;
__asm {
lidt g_idt.limit;
}
}
static void __declspec(naked) __fastcall SwitchStack
(
void (__fastcall *pfNext)(void) /* ECX */,
UINT32 _esp /* EDX */
)
{
__asm {
#if 0
push ebp;
mov ebp, esp;
mov ebx, 0xb8000;
mov eax, ecx;
call printdw;
mov eax, edx;
call printdw;
mov eax, ecx;
call printdw;
#endif
mov esp, edx;
jmp ecx;
#if 0
// Print a DWORD to the screen
// [in] ebx = address of screen
// [in] eax = dword to print
// [in] edi = trashed for temporary
//
printdw:
mov edi, eax;
shr edi, 28;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print28;
add edi, 7;
print28:
mov [ebx+0], edi;
add ebx, 2;
mov edi, eax;
shr edi, 24;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print24;
add edi, 7;
print24:
mov [ebx+0], edi;
add ebx, 2;
mov edi, eax;
shr edi, 20;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print20;
add edi, 7;
print20:
mov [ebx+0], edi;
add ebx, 2;
mov edi, eax;
shr edi, 16;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print16;
add edi, 7;
print16:
mov [ebx+0], edi;
add ebx, 2;
mov edi, eax;
shr edi, 12;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print12;
add edi, 7;
print12:
mov [ebx+0], edi;
add ebx, 2;
mov edi, eax;
shr edi, 8;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print08;
add edi, 7;
print08:
mov [ebx+0], edi;
add ebx, 2;
mov edi, eax;
shr edi, 4;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print04;
add edi, 7;
print04:
mov [ebx+0], edi;
add ebx, 2;
mov edi, eax;
shr edi, 0;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print00;
add edi, 7;
print00:
mov [ebx+0], edi;
add ebx, 2;
mov edi, 0x0f20;
mov [ebx+0], edi;
add ebx, 2;
mov [ebx+0], edi;
add ebx, 2;
ret;
#endif
}
}
static void __fastcall undump1(void);
static void __fastcall undump2(void);
static void __fastcall undump_mp(int cpu);
extern "C" void undump(Struct_Microsoft_Singularity_BootInfo *bi, int cpu)
{
if (cpu == 0)
{
g_bi = bi;
g_bi->BootCount = 0;
undump1();
}
else
{
g_bi->MpStatus32 = Struct_Microsoft_Singularity_MpBootStatus_UndumpEntry;
undump_mp(cpu);
}
}
static void __fastcall undump1(void)
{
BdInitDebugger(g_bi->DebugBasePort);
Normal();
Cls();
Struct_Microsoft_Singularity_BootInfo *bi = (Struct_Microsoft_Singularity_BootInfo *)g_bi;
printf("32-bit Singularity Undump [" __DATE__ " " __TIME__ "]\n");
printf("BootInfo: %08lx (0x%x/%d bytes)\n", bi, sizeof(*bi), sizeof(*bi));
if (sizeof(Struct_Microsoft_Singularity_BootInfo) != bi->RecSize) {
printf("sizeof(BootInfo)=%d, bi->RecSize=%ld\n",
sizeof(Struct_Microsoft_Singularity_BootInfo), bi->RecSize);
for(;;);
}
IdtInit();
CheckMinidump(bi, &g_Entry, &g_Stack);
#if 0
UINT32 _esp;
__asm mov _esp, esp;
printf(" SwitchStack(bi=%x, next=%x, esp=%x) was esp=%x\n",
bi, undump2, g_Stack, _esp);
Dump(((UINT8*)undump2) - 8, 16);
Probe(((UINT8*)undump2) - 8, 16);
Dump(((UINT8*)g_Stack) - 8, 16);
Probe(((UINT8*)g_Stack) - 8, 16);
#endif
printf("Switching stack to %x and calling %x\n", g_Stack, undump2);
SwitchStack(undump2, g_Stack); // Transfers execution to undump2();
}
static void __fastcall undump2(void)
{
#if 0
__asm {
mov eax, esp;
call printdw;
int 3;
again: jmp again;
jmp ecx;
// Print a DWORD to the screen
// [in] ebx = address of screen
// [in] eax = dword to print
// [in] edi = trashed for temporary
//
printdw:
mov edi, eax;
shr edi, 28;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print28;
add edi, 7;
print28:
mov [ebx+0], edi;
add ebx, 2;
mov edi, eax;
shr edi, 24;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print24;
add edi, 7;
print24:
mov [ebx+0], edi;
add ebx, 2;
mov edi, eax;
shr edi, 20;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print20;
add edi, 7;
print20:
mov [ebx+0], edi;
add ebx, 2;
mov edi, eax;
shr edi, 16;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print16;
add edi, 7;
print16:
mov [ebx+0], edi;
add ebx, 2;
mov edi, eax;
shr edi, 12;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print12;
add edi, 7;
print12:
mov [ebx+0], edi;
add ebx, 2;
mov edi, eax;
shr edi, 8;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print08;
add edi, 7;
print08:
mov [ebx+0], edi;
add ebx, 2;
mov edi, eax;
shr edi, 4;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print04;
add edi, 7;
print04:
mov [ebx+0], edi;
add ebx, 2;
mov edi, eax;
shr edi, 0;
and edi, 0xf;
add edi, 0x0f30;
cmp edi, 0x0f3a;
jl print00;
add edi, 7;
print00:
mov [ebx+0], edi;
add ebx, 2;
mov edi, 0x0f20;
mov [ebx+0], edi;
add ebx, 2;
mov [ebx+0], edi;
add ebx, 2;
ret;
}
#endif
Struct_Microsoft_Singularity_BootInfo *bi = g_bi;
void (__cdecl * pfHal)(const Struct_Microsoft_Singularity_BootInfo *, int)
= (void (__cdecl *)(const Struct_Microsoft_Singularity_BootInfo *, int))g_Entry;
#if DEBUG
printf("Probing basic hardware.\n");
#endif
CheckPci(bi);
CheckCpuid(bi);
CheckApic(bi);
CheckAcpi(bi);
CheckMp(bi);
FpuInit();
printf("Starting Singularity Kernel (at 0x%x)\n", pfHal);
pfHal(bi, 0);
bi->BootCount++;
SwitchStack(undump1, Struct_Microsoft_Singularity_BootInfo_REAL_STACK);
// Transfers execution to undump1();
}
static void __fastcall undump_mp(int cpu)
{
IdtInit();
FpuInit();
g_bi->MpStatus32 = Struct_Microsoft_Singularity_MpBootStatus_HalEntry;
void (__cdecl * pfHal)(const Struct_Microsoft_Singularity_BootInfo *, int)
= (void (__cdecl *)(const Struct_Microsoft_Singularity_BootInfo *, int))g_Entry;
pfHal(g_bi, cpu);
}