OSDev.org

Code: Select all

for(unsigned int *i = 0; (unsigned int)i < KernelHeader->ElfSectionHeaderEntrySize * KernelHeader->ElfProgramHeaderEntries; i += KernelHeader->ElfSectionHeaderEntrySize)
	{
		// 3.1: Get ourselves a section header
		TElf64SectionHeader *SectionHeader = (TElf64SectionHeader*)((unsigned int)KernelHeader + (KernelHeader->ElfSectionHeaderOffset + i));
		if(SectionHeader->SectionHeaderAddress)
		{
			// 3.2: Check for BSS section:
			if(SectionHeader->SectionHeaderType == SectionHeaderTypeNoBits)
			{
				// This is the BSS section, zero it
				memset((void*)SectionHeader->SectionHeaderAddress, 0, SectionHeader->SectionHeaderSize);
			}
			else
			{
				// Copy it somewhere.
				memcpy((void*)SectionHeader->SectionHeaderAddress, (void*)((unsigned int)KernelHeader + SectionHeader->SectionHeaderOffset), SectionHeader->SectionHeaderSize);
			}
		}
	}

Code: Select all

[BITS 64]
section .text
global Execute
extern main

Execute:
	; Indicate something to the outside world that we're here.

	cli
	call main
	hlt

Code: Select all

void main()
{
	//unsigned int i = 6 / 0;
	unsigned char *videoram = (unsigned char*)0xB8000;
	unsigned int f = 0;
	for(int i = 0; i < 4001; i++)
	{
		videoram[i] = (char)(32);
	 	videoram[i + 1] = 0x0D;
	 	i++;
	}
}

Code: Select all

ENTRY(Execute)
OUTPUT_FORMAT(elf64-x86-64)

phys = 0x00200000;

SECTIONS
{
	.text phys :
	{
		code = .;
		*(.text)
		. = ALIGN(4096);
	}
	.data :
	{
		data = .;
		*(.data)
		*(.rodata)
		. = ALIGN(4096);
	}
	.bss :
	{
		bss = .;
		*(.bss)
		. = ALIGN(4096);
	}
	end = .; _end = .; __end = .;
}

Code: Select all

kernel.bin:     file format elf64-x86-64
kernel.bin
architecture: i386:x86-64, flags 0x00000112:
EXEC_P, HAS_SYMS, D_PAGED
start address 0x0000000000200000

Program Header:
    LOAD off    0x0000000000200000 vaddr 0x0000000000200000 paddr 0x0000000000200000 align 2**21
         filesz 0x0000000000002000 memsz 0x0000000000002000 flags rwx

Sections:
Idx Name          Size      VMA               LMA               File off  Algn
  0 .text         00001000  0000000000200000  0000000000200000  00200000  2**4
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .eh_frame     00000030  0000000000201000  0000000000201000  00201000  2**3
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
  2 .data         00000fd0  0000000000201030  0000000000201030  00201030  2**2
                  CONTENTS, ALLOC, LOAD, DATA
  3 .comment      00000011  0000000000000000  0000000000000000  00202000  2**0
                  CONTENTS, READONLY

Code: Select all

for(unsigned int *i = 0; (unsigned int)i < KernelHeader->ElfSectionHeaderEntrySize * KernelHeader->ElfProgramHeaderEntries; i += KernelHeader->ElfSectionHeaderEntrySize)

Code: Select all

    // Load program into vaddr
    // TODO: validate vaddr
    for(unsigned int i=0; i<(unsigned int)elf_ehdr->e_phnum; i++) {
        elf_phdr = (ELF64_Phdr*)(buffer + elf_ehdr->e_phoff + i * elf_ehdr->e_phentsize);
        switch (elf_phdr->p_type) {
        case PT_LOAD:
            if ( elf_phdr->p_memsz < elf_phdr->p_filesz ) goto fail;

            // register this segment to avoid collision, return a translated, usable memory address with the requested size
            seg = add_segment((uintptr_t)elf_phdr->p_vaddr, (uintptr_t)elf_phdr->p_vaddr, (((size_t)elf_phdr->p_memsz + 4095)>>12)<<12 );

            MMU_mmap((void*)seg->base, 0, seg->size, MMU_PROT_RW|MMU_PROT_USER);
            memcpy ( (void*)seg->base, buffer + elf_phdr->p_offset, elf_phdr->p_filesz );
            if ( elf_phdr->p_filesz < elf_phdr->p_memsz ) {
                memset ( (void*)(seg->base + elf_phdr->p_filesz), 0, elf_phdr->p_memsz - elf_phdr->p_filesz);
            }
            break;
        case PT_NULL:
        case PT_DYNAMIC:
        case PT_INTERP:
        case PT_NOTE:
        case PT_SHLIB:
        case PT_PHDR:
            break;
        }
    }
    relocate ( buffer, imports, imports_count );
    entry = translate_addr(elf_ehdr->e_entry);

Code: Select all

 Section to Segment mapping:
  Segment Sections...
   00     .text .eh_frame .data 

Code: Select all

typedef struct {
    ELF64_Addr      r_offset;
    ELF64_Xword     r_info;    
} __attribute__ ((__packed__)) ELF64_Rel;

Code: Select all

	// 6.1.2: I am aware that such paranoia is probably unhealthy. Either way, check again.
	// VerifyElfHeader() Does exactly that; refer to ELF spec.

	if(!VerifyElfHeader((TElf64Header*)KernelModuleAddress))
	{
		HaltSystem();
	}


	// 6.2. Bring the ELF file into memory.


	TElf64Header *Kernel64 = (TElf64Header*)KernelModuleAddress;


	// 6.2.1: Why do I do this? I might need help.

	if(!VerifyElfHeader(Kernel64))
	{
		puts("\n\nInvalid ELF File\n\n");
		HaltSystem();
	}

	unsigned long ElfProgramHeaderOffset = Kernel64->ElfProgramHeaderOffset;
	void *ElfEntry = (void*)Kernel64->ElfEntry;


	// 6.2.2: Find and copy each program segment into memory.

	// Map: ElfHeader --> ProgramHeaderTable --> ProgramHeader --> Describes Segment.

	// In this case, we are dealing with a statically linked file. No relocations, no linking, no shared objects, nothing. Just load and jump.
	// Also, since all the sections are contained within this segment (checked with readelf), we don't need to copy them separately.


    TElf64ProgramHeader *ElfProgramHeader;			// Elf Program Header

	for(unsigned int i = 0; i < Kernel64->ElfProgramHeaderEntries; i++)
	{
		// 6.3.1: Set the current program header to the address of the offset from the beginning of the ELF file.
		ElfProgramHeader = (TElf64ProgramHeader*)(ElfProgramHeaderOffset + (unsigned int)Kernel64);

		// 6.3.2: Increase the offset, such that the next segment we load (if any) will be at the right place. Program headers are the same size.
		ElfProgramHeaderOffset += sizeof(*ElfProgramHeader);

		// 6.3.3: I can assure everyone that this is not paranoia: We need to check if the ELF file is actually loadable.
		if(ElfProgramHeader->ProgramType != ProgramTypeLoadableSegment)
		{
			puts("\n\n");
			TextModeSetTextColour(LIGHTBROWN);
			puts("ELF File not of Loadable type!");
			puts("\n");
			TextModeSetTextColour(WHITE);
			puts("Expected 1, was ");
			putnum(ElfProgramHeader->ProgramType);
			HaltSystem();
		}

		// 6.3.4: Copy the segment over. We use memmove simply because it handles overlapping memory regions.
		memmove((void*)(ElfProgramHeader->ProgramVirtualAddress), (void*)(ElfProgramHeader->ProgramOffset + Kernel64), ElfProgramHeader->ProgramFileSize);

		// 6.3.5: In the event that the program's memory is more than its file size, zero that region, so it doesn't have to deal with random data.
		memset((char*)(ElfProgramHeader->ProgramVirtualAddress + ElfProgramHeader->ProgramFileSize), 0, ElfProgramHeader->ProgramMemorySize - ElfProgramHeader->ProgramFileSize);


		// Once more, from the top! (Doesn't apply here)
	}

Code: Select all

// 6.3.2: Increase the offset, such that the next segment we load (if any) will be at the right place. Program headers are the same size.
      ElfProgramHeaderOffset += sizeof(*ElfProgramHeader);

Code: Select all

 if(ElfProgramHeader->ProgramType != ProgramTypeLoadableSegment) {
  ... 
     HaltSystem();
 }

Code: Select all

	Elf64_Half			ElfProgramHeaderEntrySize;