- Add a minimal implementation of SetupScanFileQueueW

[reactos.git] / msvc6 / ntoskrnl / ke_i386_multiboot.c

/*
 *  ReactOS kernel
 *  Copyright (C) 2003 Mike Nordell
 *  Based on multiboot.S (no copyright note present), but so heavily
 *  modified that it bears close to no resemblance to the original work.
 *
 *  MSVC compatible combination of plain C and inline assembler to:
 *  1 Relocated all the sections in the kernel - something I feel the
 *    bootloader should have done, but multiboot being just a "raw image"
 *    loader, it unfortunately had to be done here - in-place.
 *  2 Set up page directories and stuff.
 *  3 Load IDT, GDT and turn on paging, making us execute at the intended
 *    target address (as if the image was PE-loaded and parsed into that addr.)
 *  4 Call _main, and let the rest of the startup run...
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

//
// TODO: Fix the MP parts
//

/* INCLUDES ******************************************************************/

#pragma hdrstop

#include <ddk/ntddk.h>
#include <ddk/status.h>
#include <internal/i386/segment.h>
#include <internal/i386/fpu.h>
#include <internal/ps.h>
#include <ddk/defines.h>
#include <pe.h>

#include <roscfg.h>
#include <internal/ntoskrnl.h>
#include <internal/i386/segment.h>
#include <internal/ps.h>
#include <internal/ldr.h>


// some notes:
// The MSVC linker (by defult) emits no special .bss section, but uses the data
// section with a rawsize smaller than virtualsize. The "slack" is BSS.


//////////////////////////////////////////////////////////////////
// Some macros we need

// some stuff straight from freeloaders multiboot.h
#define MULTIBOOT_HEADER_MAGIC (0x1BADB002)
#define MULTIBOOT_HEADER_FLAGS (0x00010003)

#define TARGET_LOAD_ADDR  0x00200000
#define BASE_TO_PHYS_DIST (KERNEL_BASE - TARGET_LOAD_ADDR)

#define V2P(x)   (x - BASE_TO_PHYS_DIST)


#ifdef MP

#define AP_MAGIC (0x12481020)

#endif /* MP */



void  initialize_page_directory(void);

void* relocate_pointer_log_to_phys(const void* p)
{
        // DON'T CALL this function until relocation of .data and/or .rdata,
        // is completed - but still be sure that we have not yet enabled paging!
        return (void*)((DWORD)p - BASE_TO_PHYS_DIST);
}



#ifdef _DEBUG

// Macro to emit one character to Bochs debug-port (0x9e).
// We need to do it this way, since at this point of the startup, obviously
// we have neither HAL nor DbgPrint support.
#define BOCHS_OUT_CHAR(c1)      __asm push eax __asm push edx __asm mov dx, 0xe9 __asm mov al, c1 __asm out dx, al __asm pop edx __asm pop eax

void boch_out_hex_digit(unsigned char ch1)
{
        if (ch1 <= 9) { ch1 += '0'; } else { ch1 += 'a' - 10; }
        BOCHS_OUT_CHAR(ch1)
}

void bochs_dump_hex(DWORD p)
{
        unsigned char ch3 = (unsigned char)((p >> 28) & 0x0f);
        unsigned char cl3 = (unsigned char)((p >> 24) & 0x0f);
        unsigned char ch2 = (unsigned char)((p >> 20) & 0x0f);
        unsigned char cl2 = (unsigned char)((p >> 16) & 0x0f);
        unsigned char ch1 = (unsigned char)((p >> 12) & 0x0f);
        unsigned char cl1 = (unsigned char)((p >>  8) & 0x0f);
        unsigned char ch0 = (unsigned char)((p >>  4) & 0x0f);
        unsigned char cl0 = (unsigned char)((p >>  0) & 0x0f);
        BOCHS_OUT_CHAR('0') BOCHS_OUT_CHAR('x')
        boch_out_hex_digit(ch3);
        boch_out_hex_digit(cl3);
        boch_out_hex_digit(ch2);
        boch_out_hex_digit(cl2);
        boch_out_hex_digit(ch1);
        boch_out_hex_digit(cl1);
        boch_out_hex_digit(ch0);
        boch_out_hex_digit(cl0);
        BOCHS_OUT_CHAR('\n')
}

static void bochs_out_string(const char* s /* logical address! */)
{
        s = relocate_pointer_log_to_phys(s);
        __asm
        {
                pushad
                mov dx, 0xe9
                mov ebx, s
L1:
                cmp byte ptr[ebx], 0
                je end
                mov al, [ebx]
                out dx, al
                inc ebx
                jmp L1
end:
                popad
        }
}

#else

#define BOCHS_OUT_CHAR(c1)
#define bochs_dump_hex(VAL)
#define bochs_out_string(STR)

#endif  // _DEBUG


//////////////////////////////////////////////////////////////////

typedef char kernel_page_t[4096];

// Use 4096 (pagesize) more bytes that actually needed for each *_holder,
// to be able to make sure that the other stuff is page aligned.
// No other way to do this portably... :-(
//
// TODO: Consider allocating just one large block of BSS memory here, align
// just the first pointer, and then get the other ones just as offsets from
// this (now-aligned) pointer. That way we could get away with wasting just
// one page of memory, instead of 4 (like 16KB would matter... but still)
static kernel_page_t*  startup_pagedirectory_holder[1024 * 2];
static kernel_page_t*  lowmem_pagetable_holder[1024 * 2];
static kernel_page_t*  kernel_pagetable_holder[32*1024 + 1];
static __int32         kpcr_pagetable_holder[4096/4 * 2];

#ifdef MP
char apic_pagetable[4096];
#endif /* MP */

__int32 unmap_me[4096/4];
__int32 unmap_me2[4096/4];
__int32 unmap_me3[4096/4];

__int32 init_stack[3*4096/4];
int     init_stack_top;


__int32 trap_stack[3*4096/4];
int     trap_stack_top;



void _main();
// lie a bit about types - since C is basically typeless anyway, it
// doesn't really matter what type we say it is here...
extern int KiGdtDescriptor;
extern int KiIdtDescriptor;



        /*
         * This is called by the realmode loader, with protected mode
         * enabled, paging disabled and the segment registers pointing
         * a 4Gb, 32-bit segment starting at zero.
         *
         *    EAX = Multiboot magic or application processor magic
         *
         *    EBX = Points to a structure in lowmem with data from the
         *    loader
         */
#pragma intrinsic(memset)


// We need to implement this ourself, to be able to get to it by short call's
void our_memmove(void* pDest, const void* pSrc, DWORD size)
{
              char* pD = (char*)pDest;
        const char* pS = (char*)pSrc;
        if (pDest < pSrc)
        {
                while (size--)
                {
                        *pD++ = *pS++;
                }
        }
        else if (pSrc < pDest)
        {
                while (size--)
                {
                        pD[size] = pS[size];
                }
        }
}
void dummy_placeholder(void)
{
        // NOTE: This function MUST be placed JUST AFTER MultibootStub in memory.
        // Yes, it's BEFORE it in this file, but linkorder.txt fixes this for us.
}


// This one is needed, since the boot loader hasn't relocated us
__declspec(naked)
void MultibootStub()
{
        __asm
        {
                jmp             _multiboot_entry
                // This sucks, I know...
#define EMIT_DWORD(x) __asm __emit ((x) >> 0) & 0xff __asm _emit ((x) >> 8) & 0xff __asm _emit ((x) >> 16) & 0xff __asm _emit ((x) >> 24) & 0xff
                ALIGN 4
                EMIT_DWORD(MULTIBOOT_HEADER_MAGIC)
                EMIT_DWORD(MULTIBOOT_HEADER_FLAGS)
                EMIT_DWORD(-(MULTIBOOT_HEADER_MAGIC + MULTIBOOT_HEADER_FLAGS))
                EMIT_DWORD(TARGET_LOAD_ADDR + 0x0400 + 0x04)
                // Now just make something up, since there is no way we can know, beforehand,
                // where any BSS data is...
                EMIT_DWORD((TARGET_LOAD_ADDR))
                EMIT_DWORD((TARGET_LOAD_ADDR + 1*1024*1024)) /* assume ntoskrnel.exe is < 1MB! */
                EMIT_DWORD((TARGET_LOAD_ADDR + 2*1024*1024)) /* just to have something, let's say BSS is 1MB too */
                /* This is *REALLY* ugly! If MultibootStub is *EVER* at   */
                /* any other offset, this will crash like crazy! */
                /* 0x0400 is the file alignment of the binary (ntoskrnl.exe) */
                EMIT_DWORD((TARGET_LOAD_ADDR + 0x0400)) // entry_addr

_multiboot_entry:

                cld             // just for good measure
        }

        {
                /* Save the multiboot or application processor magic */
                DWORD saved_eax;
                DWORD saved_ebx;
                __asm   mov     saved_eax, eax
                __asm   mov     saved_ebx, ebx

//              bochs_out_string("MultibootStub()\n");

                // OK, time to relocate the brute-loaded image in-place...
                // If we don't watch it, we will overwrite ourselves here - imagine
                // the fireworks! :-) That's why the function dummy_placeholder()
                // MUST be placed JUST JUST AFTER this function.

                {
                PIMAGE_NT_HEADERS     NtHeader = RtlImageNtHeader((PVOID)TARGET_LOAD_ADDR);
                PIMAGE_SECTION_HEADER Section  = IMAGE_FIRST_SECTION(NtHeader);
                const int count = NtHeader->FileHeader.NumberOfSections;
                int i;
                Section += count - 1;   // make it point to the last section
                // NOTE: We MUST walk the sections "backwards".
                for (i = count-1; i >= 0; --i, --Section)
                {
                        DWORD dwSrc = TARGET_LOAD_ADDR + Section->PointerToRawData;
                        DWORD dwDst = TARGET_LOAD_ADDR + Section->VirtualAddress;
                        DWORD dwSiz = Section->SizeOfRawData;
                        const char* pEndThisFunc;

                        if (dwSrc == dwDst)
                        {
                                continue;
                        }

//bochs_out_string("MultibootStub: relocating section\n");

                        if (Section->Characteristics & IMAGE_SCN_MEM_EXECUTE)
                        {
                                // can't get a pointer to a label from plain C :-(
                                __asm mov       pEndThisFunc, offset dummy_placeholder
                                pEndThisFunc -= BASE_TO_PHYS_DIST;
                                if (dwDst < (DWORD)pEndThisFunc)
                                {
                                        // We must not move the code from under our feet!
                                        // This can only happen in the code segment - the first segment
                                        DWORD diff = (DWORD)pEndThisFunc - dwDst;
                                        dwDst += diff;
                                        dwSrc += diff;
                                        dwSiz -= diff;
                                }
                        }

                        // obviously we must use memmove, since memory can overlap
                        our_memmove((void*)dwDst, (void*)dwSrc, dwSiz);

                        // While at it, we might as well zero any uninitialized data in the section...
                        if (Section->SizeOfRawData < Section->Misc.VirtualSize)
                        {
                                memset((char*)(Section->VirtualAddress + Section->SizeOfRawData + TARGET_LOAD_ADDR),
                                           0,
                                           Section->Misc.VirtualSize - Section->SizeOfRawData);
                        }
                }

                // Now all sections are relocated to their intended in-memory layout,
                // but we are still running int the low TARGET_LOAD_ADDR memory.

                {
                        // Time to jump to the real startup, the entry-point function.
                        // We must do this using assembler, since both eax and ebx are assumed
                        // to hold some magic values.
                        typedef VOID (STDCALL* pfn_t)(PPEB);
                        pfn_t pfn = (pfn_t)(NtHeader->OptionalHeader.AddressOfEntryPoint + TARGET_LOAD_ADDR);
#if 1
                        __asm   mov eax, saved_eax
                        __asm   mov ebx, saved_ebx
                        __asm   mov ecx, pfn
                        __asm   jmp ecx
#else
                        __asm   mov ebx, saved_ebx
                        (*pfn)((PPEB)saved_eax);
#endif
                }
                }
        }
}


// TMN: TODO: Convert this to the extent possible to plain C code
// Due to the "magic" above, we enter this function with all kernel sections
// properly relocated wrt. offsets from start-of-mem. But, we are still running
// without paging, meaning that the address that is to be KERNEL_BASE+xyz is
// currently still TARGET_LOAD_ADDR+xyz.
// We get aways with a few of the functions call here since they are near calls
// (PC-relative), but don't even _think_ about calling any other functions
// until we have turned on paging!
VOID STDCALL
NtProcessStartup(
        IN      PPEB    Peb
        )
{
        DWORD saved_ebx;
        DWORD saved_eax;
        __asm mov saved_ebx, ebx
        __asm mov saved_eax, eax

        bochs_out_string("NtProcessStartup: Just entered\n");

#ifdef MP
        if (saved_eax != AP_MAGIC)
        {
#endif /* MP */

                bochs_out_string("NtProcessStartup: Calling initialize_page_directory()\n");

                initialize_page_directory();    // Initialize the page directory

                bochs_out_string("NtProcessStartup: Page directory initialized\n");

#ifdef  MP

                __asm
                {
                        /*
                         * Initialize the page table that maps the APIC register address space
                         */
                         
                        /* 
                         * FIXME: APIC register address space can be non-standard so do the 
                         * mapping later 
                         */
                        mov             esi, V2P(apic_pagetable)
                        mov             edi, 0
                        mov             eax, 0xFEC0001B
                        mov             [esi+edi], eax
                        mov             edi, 0x800
                        mov             eax, 0xFEE0001B
                        mov             [esi+edi], eax
                }
        }

#endif /* MP */

        {
                bochs_out_string("NtProcessStartup: Enabling paging...\n");

                /*
                 * Enable paging and set write protect
                 * bit 31: PG, bit 16: WP
                 */
                __asm   mov             eax, cr0
                __asm   or              eax, 0x80010000
                __asm   mov             cr0, eax

                bochs_out_string("NtProcessStartup: Paging enabled!\n");
                bochs_out_string("NtProcessStartup: But we're still at the \"low\" address\n");

                /*
                 * Do an absolute jump because we now want to execute above KERNEL_BASE
                 */
                __asm   mov             eax, offset l2_
                __asm   jmp             eax
        }

l2_:

bochs_out_string("We have now left \"low\" memory, and is flying at an altitude of...\n");
bochs_out_string("OK, we're not flying, we're just executing above KERNEL_BASE\n");

        /*
         * Load the GDTR and IDTR with new tables located above
         * KERNEL_BASE
         */

#ifdef _DEBUG
        {
                DWORD val = (DWORD)&KiGdtDescriptor;
                bochs_out_string("&KiGdtDescriptor: ");
                bochs_dump_hex(val);

                val = (DWORD)&KiIdtDescriptor;
                bochs_out_string("&KiIdtDescriptor: ");
                bochs_dump_hex(val);
        }
#endif

bochs_out_string("Loading GDT and IDT...\n");

        /* FIXME: Application processors should have their own GDT/IDT */
        __asm   lgdt    KiGdtDescriptor
        __asm   lidt    KiIdtDescriptor

bochs_out_string("GDT and IDT loaded\n");

        __asm
        {
                /*
                 * Reload the data segment registers 
                 */
                mov             eax, KERNEL_DS
                mov             ds, ax
                mov             es, ax
                mov             gs, ax
                mov             ss, ax
                mov             eax, 0
                mov             fs, ax
        }

bochs_out_string("NtProcessStartup: segment registers loaded\n");

#ifdef MP

        if (saved_eax == AP_MAGIC)
        {
                __asm
                {
                        /*
                         * This is an application processor executing
                         */

                        /*
                         * Initialize EFLAGS
                         */
                        push    0
                        popfd

                        /*
                         * Call the application processor initialization code
                         */
                        push    0
                        push    offset l7_
                        push    KERNEL_CS
                        push    KiSystemStartup
                        retf

                        /*
                         * Catch illegal returns from KiSystemStartup
                         */
l7_:
                        pop             eax
                }

                KeBugCheck(0);

                for (;;)
                        ;       /*forever */
        }

#endif /* MP */

bochs_out_string("Loading fs with PCR_SELECTOR\n");

        /* Load the PCR selector */
        __asm   mov             eax, PCR_SELECTOR
        __asm   mov             fs, ax

bochs_out_string("Loading esp with init_stack_top    : "); bochs_dump_hex((DWORD)&init_stack_top);
bochs_out_string("Just for interest, init_stack is at: "); bochs_dump_hex((DWORD)init_stack);
bochs_out_string("Meaing the init_stack in bytes is  : "); bochs_dump_hex((DWORD)&init_stack_top - (DWORD)init_stack);


        /* Load the initial kernel stack */
        __asm   mov             esp, offset init_stack_top

bochs_out_string("Loaded esp with init_stack_top\n");

        /*
         * Initialize EFLAGS
         */
        __asm   push    0
        __asm   popfd

bochs_out_string("Loaded eflags\n");

                /*
                 * Call the main kernel initialization
                 */
bochs_out_string("TMN: Calling _main...\n");

        __asm
        {
                xor             ebp,ebp
                push    ebx
                push    edx
                push    offset l5_
                push    KERNEL_CS
                push    offset _main
                retf
        
        /*
         * Catch illegal returns from main, try bug checking the system,
         * if that fails then loop forever.
         */
l5_:
                pop             eax
                pop             eax

        } // end of __asm block

bochs_out_string("TMN: Back from _main ?! Let's crash!\n");

        KeBugCheck(0);

        for (;;)
                ;       /*forever */
}


void initialize_page_directory(void)
{
        /*
         * Initialize the page directory
         */

        // First convert the pointers from the virtual address the compiler generated
        // code thinks we are at, to the currently active physical address we actually
        // got loaded into by the loader. At this point we have been relocated, so
        // that there is a 1:1 mapping between KERNEL_BASE+n and TARGET_LOAD_ADDR+n.

        kernel_page_t** startup_pagedirectory = startup_pagedirectory_holder;
        kernel_page_t** lowmem_pagetable      = lowmem_pagetable_holder;
        kernel_page_t** kernel_pagetable      = kernel_pagetable_holder;
        __int32*        kpcr_pagetable        = kpcr_pagetable_holder;

        bochs_out_string("startup_pagedirectory before reloc: ");
        bochs_dump_hex((DWORD)startup_pagedirectory);

        startup_pagedirectory = (kernel_page_t**)relocate_pointer_log_to_phys(startup_pagedirectory);
        lowmem_pagetable      = (kernel_page_t**)relocate_pointer_log_to_phys(lowmem_pagetable);
        kernel_pagetable      = (kernel_page_t**)relocate_pointer_log_to_phys(kernel_pagetable);
        kpcr_pagetable        = (__int32*)       relocate_pointer_log_to_phys(kpcr_pagetable);

        bochs_out_string("startup_pagedirectory after reloc : ");
        bochs_dump_hex((DWORD)startup_pagedirectory);

        // Now align the pointers to PAGE_SIZE...
        startup_pagedirectory = (kernel_page_t**)(((ULONG_PTR)startup_pagedirectory + 4095) & ~4095);
        lowmem_pagetable      = (kernel_page_t**)(((ULONG_PTR)lowmem_pagetable      + 4095) & ~4095);
        kernel_pagetable      = (kernel_page_t**)(((ULONG_PTR)kernel_pagetable      + 4095) & ~4095);
        kpcr_pagetable        = (__int32* )      (((ULONG_PTR)kpcr_pagetable        + 4095) & ~4095);

#ifdef _DEBUG
        bochs_out_string("startup_pagedirectory aligned     : ");
        bochs_dump_hex((DWORD)startup_pagedirectory);
#endif

        // Ugly macros, I know...
#define DEST(PAGE)   startup_pagedirectory[(PAGE) + 0xc00 / 4]
#define SRC(PAGE)    (kernel_page_t*)((char*)kernel_pagetable + (PAGE)*4096 + 0x7)

        startup_pagedirectory[0] = (kernel_page_t*)((char*)lowmem_pagetable + 0x7);

        {
                unsigned int i;
                for (i=0; i<32; ++i)
                {
                        DEST(i) = SRC(i);
                }
        }

        DEST( 64) = (kernel_page_t*)((char*)lowmem_pagetable      + 0x7);
        DEST(192) = (kernel_page_t*)((char*)startup_pagedirectory + 0x7);
#ifdef MP
        DEST(251) = (kernel_page_t*)((char*)apic_pagetable        + 0x7);
#endif /* MP */
        DEST(252) = (kernel_page_t*)((char*)kpcr_pagetable        + 0x7);


        {
                unsigned int i;
                /* Initialize the page table that maps low memory */
                for (i=0; i<1024; ++i) {
                        lowmem_pagetable[i] = (kernel_page_t*)(i*4096 + 7);
                }

                /* Initialize the page table that maps kernel memory */
                for (i=0; i<6144/4 /* 1536 pages = 6MB */; ++i) {
                        kernel_pagetable[i] = (kernel_page_t*)(i*4096 + TARGET_LOAD_ADDR + 0x7);
                }

                /* Initialize the page table that maps the initial KPCR (at FF000000) */
                kpcr_pagetable[0] = 0x1007;
        }

        /*
         * Set up the PDBR
         */     
        __asm   mov             eax, startup_pagedirectory
        __asm   mov             cr3, eax
}