#include "efi.h" #include "memory.h" #include "cpu.h" #include "bootstrap.h" #include "descriptors.h" #include "interrupts.h" #include "kernel.h" #define BOB64_MEMORY_MAP_CAPACITY 131072 #define BOB64_BOOT_STACK_PAGES 8 #define BOB64_TABLE_POOL_PAGES 128 #define BOB64_FRAMEBUFFER_MAP_LIMIT (64ULL*1024ULL*1024ULL) static u8 memory_map[BOB64_MEMORY_MAP_CAPACITY] __attribute__((aligned(16))); BOB64_PAGE_EXTENT bob64_boot_page_extents[BOB64_PAGE_EXTENT_LIMIT]; BOB64_PAGE_ALLOCATOR bob64_boot_page_allocator; BOB64_BOOTSTRAP_SPACE bob64_bootstrap_space; static u64 kernel_gdt[BOB64_GDT_ENTRY_COUNT]; BOB64_TSS bob64_kernel_tss; static BOB64_IDT_GATE kernel_idt[BOB64_IDT_ENTRIES]; static BOB64_DESCRIPTOR_TABLE_POINTER kernel_gdtr,kernel_idtr; #ifdef BOB64_ENABLE_HANDOFF static BOB64_KERNEL_BOOT_INFO kernel_boot_info; #endif static int boot_grow_table_pool(void *context,BOB64_BOOTSTRAP_SPACE *space, u64 *base,u64 *pages) { BOB64_PAGE_ALLOCATOR *allocator=(BOB64_PAGE_ALLOCATOR *)context; u64 physical,bytes; const u64 count=BOB64_BOOTSTRAP_TABLE_GROW_PAGES; if(!allocator||!space||!base||!pages||count>~(u64)0/BOB64_PAGE_SIZE) return -1; bytes=count*BOB64_PAGE_SIZE; physical=bob64_page_alloc(allocator,count); if(!physical)return -1; if(physical>=0x0000800000000000ULL|| bytes>0x0000800000000000ULL-physical|| bob64_page_map_range(&space->PageTable,physical,physical,bytes, BOB64_PAGE_WRITE|(space->NxSupported?BOB64_PAGE_NX:0))) { for(u64 offset=0;offsetPageTable,physical+offset, &translated,0)==1&&translated==physical+offset) { (void)bob64_page_unmap(&space->PageTable,physical+offset,0,0); __asm__ volatile("invlpg (%0)"::"r"((void *)(uintptr_t)(physical+offset)): "memory"); } } (void)bob64_page_free(allocator,physical,count); return -1; } *base=physical;*pages=count; return 0; } static const EFI_GUID loaded_image_guid={0x5b1b31a1u,0x9562u,0x11d2u, {0x8e,0x3f,0x00,0xa0,0xc9,0x69,0x72,0x3b}}; #ifdef BOB64_ENABLE_HANDOFF static const EFI_GUID graphics_output_guid={0x9042a9deu,0x23dcu,0x4a38u, {0x96,0xfb,0x7a,0xde,0xd0,0x80,0x51,0x6a}}; #endif static u64 *physical_identity_access(void *context,u64 physical_address) { (void)context; return (u64 *)(uintptr_t)physical_address; } static EFI_STATUS efi_print(EFI_SYSTEM_TABLE *system,const CHAR16 *text) { if(!system || !system->ConOut || !system->ConOut->OutputString) return EFI_UNSUPPORTED; return system->ConOut->OutputString(system->ConOut,text); } EFI_STATUS EFIAPI efi_main(EFI_HANDLE image,EFI_SYSTEM_TABLE *system) { static const CHAR16 active[]={'b','o','b','6','4',':',' ','l','o','n','g',' ' , 'm','o','d','e',' ','a','c','t','i','v','e','\r','\n',0}; static const CHAR16 unsupported[]={'b','o','b','6','4',':',' ','x','8','6','-','6','4', ' ','l','o','n','g',' ','m','o','d','e',' ','r','e','q','u','i','r','e','d','\r','\n',0}; #ifndef BOB64_ENABLE_HANDOFF static const CHAR16 prepared[]={'b','o','b','6','4',':',' ','b','o','o','t','s','t','r','a','p', ' ','p','a','g','i','n','g',' ','p','r','e','p','a','r','e','d','\r','\n',0}; #endif #ifdef BOB64_ENABLE_HANDOFF static const CHAR16 handoff[]={'b','o','b','6','4',':',' ','e','x','i','t','i','n','g',' ' , 'U','E','F','I',' ','b','o','o','t',' ','s','e','r','v','i','c','e','s','\r','\n',0}; #endif static const CHAR16 marker[]={'b','o','b','6','4','!','\r','\n',0}; /* This image-base-relative pointer must be repaired if firmware relocates the PE image. */ static const CHAR16 * volatile relocated_marker=marker; UINTN map_capacity=sizeof(memory_map),map_size=sizeof(memory_map),map_key=0,descriptor_size=0; u32 descriptor_version=0; EFI_STATUS status; EFI_MEMORY_DESCRIPTOR *map=(EFI_MEMORY_DESCRIPTOR *)memory_map; BOB64_CPU_FEATURES cpu; EFI_LOADED_IMAGE_PROTOCOL *loaded_image; void *loaded_image_interface=0; #ifdef BOB64_ENABLE_HANDOFF EFI_GRAPHICS_OUTPUT_PROTOCOL *graphics=0; EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE *graphics_mode=0; EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *graphics_info=0; int framebuffer_valid=0; u64 framebuffer_map_size=0; #endif u64 stack_base,table_pool_base,translated; u64 probe_page; BOB64_PAGE_EXTENT *active_page_extents=bob64_boot_page_extents; BOB64_PAGE_ALLOCATOR *active_page_allocator=&bob64_boot_page_allocator; BOB64_BOOTSTRAP_SPACE *active_bootstrap_space=&bob64_bootstrap_space; if(!system)return EFI_UNSUPPORTED; if(bob64_cpu_detect(&cpu)||!cpu.PAE||!cpu.LongMode|| !bob64_cpu_long_mode_active(&cpu)) { efi_print(system,unsupported); return EFI_UNSUPPORTED; } #ifdef BOB64_ENABLE_HANDOFF if(!bob64_cpu_four_level_paging_active()) { efi_print(system,unsupported); return EFI_UNSUPPORTED; } #endif if(EFI_ERROR(efi_print(system,active)))return EFI_UNSUPPORTED; if(EFI_ERROR(efi_print(system,relocated_marker)))return EFI_UNSUPPORTED; if(!system->BootServices||!system->BootServices->GetMemoryMap|| !system->BootServices->HandleProtocol)return EFI_UNSUPPORTED; status=system->BootServices->HandleProtocol(image,&loaded_image_guid,&loaded_image_interface); if(EFI_ERROR(status))return status; if(!loaded_image_interface)return EFI_UNSUPPORTED; loaded_image=(EFI_LOADED_IMAGE_PROTOCOL *)loaded_image_interface; if(!loaded_image->ImageBase||!loaded_image->ImageSize)return EFI_UNSUPPORTED; #ifdef BOB64_ENABLE_HANDOFF if(system->BootServices->LocateProtocol&& !EFI_ERROR(system->BootServices->LocateProtocol(&graphics_output_guid,0, (void **)&graphics))&& graphics&&graphics->Mode&&(graphics_mode=graphics->Mode)&& graphics_mode->Info&&(graphics_info=graphics_mode->Info)&& (graphics_info->PixelFormat==0||graphics_info->PixelFormat==1)&& graphics_mode->FrameBufferBase&&graphics_mode->FrameBufferSize&& graphics_info->HorizontalResolution>=6&&graphics_info->VerticalResolution>=8&& graphics_info->PixelsPerScanLine>=graphics_info->HorizontalResolution&& (u64)graphics_info->PixelsPerScanLine<=~(u64)0/graphics_info->VerticalResolution) { u64 pixels=(u64)graphics_info->PixelsPerScanLine*graphics_info->VerticalResolution; if(pixels<=~(u64)0/4) { framebuffer_map_size=pixels*4; framebuffer_valid=framebuffer_map_size<=graphics_mode->FrameBufferSize&& framebuffer_map_size<=BOB64_FRAMEBUFFER_MAP_LIMIT; } } #endif status=system->BootServices->GetMemoryMap(&map_size,map,&map_key,&descriptor_size,&descriptor_version); if(status==EFI_BUFFER_TOO_SMALL) { if(!system->BootServices->AllocatePool)return status; UINTN slack=(descriptor_size?descriptor_size:sizeof(EFI_MEMORY_DESCRIPTOR))*2; if(map_size>(~(UINTN)0)-slack)return EFI_UNSUPPORTED; UINTN required=map_size+slack; status=system->BootServices->AllocatePool(EFI_MEMORY_LOADER_DATA,required,(void **)&map); if(EFI_ERROR(status))return status; map_capacity=required;map_size=required; status=system->BootServices->GetMemoryMap(&map_size,map,&map_key,&descriptor_size,&descriptor_version); } if(EFI_ERROR(status))return status; if(descriptor_version!=1||bob64_page_allocator_init(active_page_allocator,active_page_extents, BOB64_PAGE_EXTENT_LIMIT,cpu.PhysicalAddressBits,map,(usize)map_size, (usize)descriptor_size)<0) return EFI_UNSUPPORTED; probe_page=bob64_page_alloc(active_page_allocator,1); if(!probe_page||bob64_page_free(active_page_allocator,probe_page,1))return EFI_UNSUPPORTED; stack_base=bob64_page_alloc(active_page_allocator,BOB64_BOOT_STACK_PAGES); table_pool_base=bob64_page_alloc(active_page_allocator,BOB64_TABLE_POOL_PAGES); if(!stack_base||!table_pool_base)return EFI_UNSUPPORTED; volatile u64 *stack_words=(volatile u64 *)(uintptr_t)stack_base; for(usize i=0;iImageBase,loaded_image->ImageSize, stack_base,BOB64_BOOT_STACK_PAGES*EFI_PAGE_SIZE,cpu.NX)<0) return EFI_UNSUPPORTED; bob64_bootstrap_space_set_table_growth(active_bootstrap_space, boot_grow_table_pool, active_page_allocator); #ifdef BOB64_ENABLE_HANDOFF u64 runtime_services=(u64)(uintptr_t)system->RuntimeServices; int runtime_services_mapped=!bob64_bootstrap_map_runtime_services( active_bootstrap_space,map,(usize)map_size,(usize)descriptor_size, runtime_services); #endif u64 image_base=(u64)(uintptr_t)loaded_image->ImageBase; u64 map_base=(u64)(uintptr_t)map; int map_is_in_image=map_base>=image_base&&map_base-image_base<=loaded_image->ImageSize&& (u64)map_capacity<=loaded_image->ImageSize-(map_base-image_base); if(!map_is_in_image&&bob64_page_map_range(&active_bootstrap_space->PageTable,map_base,map_base, (u64)map_capacity,BOB64_PAGE_WRITE|(cpu.NX?BOB64_PAGE_NX:0))) return EFI_UNSUPPORTED; #ifdef BOB64_ENABLE_HANDOFF if(framebuffer_valid&&bob64_page_map_range(&active_bootstrap_space->PageTable, graphics_mode->FrameBufferBase,graphics_mode->FrameBufferBase, framebuffer_map_size,BOB64_PAGE_WRITE|BOB64_PAGE_PCD|BOB64_PAGE_PWT| (cpu.NX?BOB64_PAGE_NX:0)))framebuffer_valid=0; #endif if(bob64_page_translate(&active_bootstrap_space->PageTable, (u64)(uintptr_t)loaded_image->ImageBase,&translated,0)!=1|| translated!=(u64)(uintptr_t)loaded_image->ImageBase|| bob64_page_translate(&active_bootstrap_space->PageTable, stack_base+BOB64_BOOT_STACK_PAGES*EFI_PAGE_SIZE-1,&translated,0)!=1|| translated!=stack_base+BOB64_BOOT_STACK_PAGES*EFI_PAGE_SIZE-1) return EFI_UNSUPPORTED; #ifdef BOB64_ENABLE_HANDOFF if(!system->BootServices->ExitBootServices)return EFI_UNSUPPORTED; if(EFI_ERROR(efi_print(system,handoff)))return EFI_UNSUPPORTED; kernel_boot_info.PageTableRoot=active_bootstrap_space->PageTable.RootPhysical; kernel_boot_info.MemoryMapAddress=map_base; kernel_boot_info.MemoryDescriptorSize=descriptor_size; kernel_boot_info.StackBase=stack_base; kernel_boot_info.StackSize=BOB64_BOOT_STACK_PAGES*EFI_PAGE_SIZE; kernel_boot_info.PhysicalAddressBits=cpu.PhysicalAddressBits; kernel_boot_info.NxSupported=cpu.NX; kernel_boot_info.RuntimeServices=runtime_services_mapped?runtime_services:0; if(framebuffer_valid) { kernel_boot_info.FramebufferBase=graphics_mode->FrameBufferBase; kernel_boot_info.FramebufferSize=framebuffer_map_size; kernel_boot_info.FramebufferWidth=graphics_info->HorizontalResolution; kernel_boot_info.FramebufferHeight=graphics_info->VerticalResolution; kernel_boot_info.FramebufferPixelsPerScanLine=graphics_info->PixelsPerScanLine; kernel_boot_info.FramebufferPixelFormat=graphics_info->PixelFormat; kernel_boot_info.HasFramebuffer=1; } for(u32 attempt=0;attempt<3;attempt++) { map_size=map_capacity; status=system->BootServices->GetMemoryMap(&map_size,map,&map_key,&descriptor_size, &descriptor_version); if(EFI_ERROR(status))return status; if(descriptor_version!=1||!descriptor_size||map_size>map_capacity)return EFI_UNSUPPORTED; kernel_boot_info.MemoryMapSize=map_size; kernel_boot_info.MemoryDescriptorSize=descriptor_size; status=system->BootServices->ExitBootServices(image,map_key); if(!EFI_ERROR(status)) bob64_enter_kernel(kernel_boot_info.PageTableRoot, stack_base+BOB64_BOOT_STACK_PAGES*EFI_PAGE_SIZE,&kernel_gdtr,&kernel_idtr, &kernel_boot_info); if(status!=EFI_INVALID_PARAMETER)return status; } return status; #else if(EFI_ERROR(efi_print(system,prepared)))return EFI_UNSUPPORTED; return EFI_SUCCESS; #endif }