From 7ed12065be7c90fc659e1a1cef91bafebf2dc24d Mon Sep 17 00:00:00 2001 From: Sergiusz Bazanski Date: Mon, 14 Mar 2011 17:49:22 +0100 Subject: [PATCH] Now with a heap! Holy cow! --- include/Tier0/heap.h | 51 ++++++ include/Tier0/paging.h | 3 +- src/Tier0/.heap.c.swp | Bin 0 -> 24576 bytes src/Tier0/.kmain.c.swp | Bin 0 -> 12288 bytes src/Tier0/heap.c | 381 +++++++++++++++++++++++++++++++++++++++++ src/Tier0/kmain.c | 11 +- src/Tier0/paging.c | 22 --- 7 files changed, 437 insertions(+), 31 deletions(-) create mode 100644 include/Tier0/heap.h create mode 100644 src/Tier0/.heap.c.swp create mode 100644 src/Tier0/.kmain.c.swp create mode 100644 src/Tier0/heap.c diff --git a/include/Tier0/heap.h b/include/Tier0/heap.h new file mode 100644 index 0000000..f38ca2f --- /dev/null +++ b/include/Tier0/heap.h @@ -0,0 +1,51 @@ +#ifndef __HEAP_H__ +#define __HEAP_H__ + +#include "types.h" + +#define HEAP_HEADER_MAGIC 0x8A4DF92E +#define HEAP_FOOTER_MAGIC 0x9AFE352B + +#define HEAP_START 0xD0000000 +#define HEAP_INITIAL_SIZE 0x00400000 +#define HEAP_MIN_SIZE 0x00400000 + +#define HEAP_INDEX_SIZE 0x00020000 + +typedef struct { + u32 Magic; + u8 Hole; + u32 Size; +} T_HEAP_HEADER; + +typedef struct { + u32 Magic; + T_HEAP_HEADER *Header; +} T_HEAP_FOOTER; + +typedef struct { + void **Array; + u32 Size; + u32 MaxSize; +} T_HEAP_INDEX; + +T_HEAP_INDEX heap_index_initialize(void *Address, u32 MaxSize); +void heap_index_insert(T_HEAP_INDEX *Index, void *Value); +u8 heap_index_smaller(void *A, void *B); + +typedef struct { + T_HEAP_INDEX Index; + u32 Start; + u32 End; + u32 Max; +} T_HEAP; + +T_HEAP *heap_create(u32 Start, u32 End, u32 Max); +void *heap_alloc(T_HEAP *Heap, u32 Size, u8 Aligned); +void heap_free(T_HEAP *Heap, void *Address); + +void heap_init_simple(void); +void *kmalloc(u32 Size); +void kfree(void *Data); + +#endif diff --git a/include/Tier0/paging.h b/include/Tier0/paging.h index c0490fd..402e1e8 100644 --- a/include/Tier0/paging.h +++ b/include/Tier0/paging.h @@ -5,5 +5,6 @@ void paging_init_simple(void); u8 paging_get_physical(u32 Virtual, u32 *Physical); -void paging_allocate_page(u32 Virtual); +void paging_map_kernel_page(u32 Virtual, u32 Physical); +void paging_map_kernel_table(u32 Virtual, u32 Physical); #endif diff --git a/src/Tier0/.heap.c.swp b/src/Tier0/.heap.c.swp new file mode 100644 index 0000000000000000000000000000000000000000..d9c354c8bd9dcfb03d00f59b6644bcc5710c9b1c GIT binary patch literal 24576 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 literal 0 HcmV?d00001 diff --git a/src/Tier0/.kmain.c.swp b/src/Tier0/.kmain.c.swp new file mode 100644 index 0000000000000000000000000000000000000000..74cc32245b6063241f5d88d06dcbbee2a5b6c835 GIT binary patch literal 12288 zcmeI2O=w+36vrnnQmcuTx)CdK@@nKo)4bPY(P9XgG>wTGQqndGZ5bx-&P^`wesyMU zK4@C^UFbr(DXs*;N(C1#iU8DzR%<)X~Bi!%;Wcld(M2E z`Oleogxuxo(%d|q7#U+IPcn9Y=Gy$76Q8nM=NZ#dt;prnv3GGJCD)`9eiX{RT3*Ws ztkjZP5-dwqd0nbd`W3Bem2;j{)k-}OUN}UMvC-qzwDZx@ z06ldWhujvcfK|XMU=^?mSOu&CRspMkRp5W4fQft9+gR-*jTOJzsC%~6jYnHq1*`&A z0jq#jz$#!BunJfOtO8a6tAJI&D)1jvKsb!uJ;2z3g9sk~|8M^N|JxzPz5`!?55RTc zgY#el~UER0Yz6~Bo zoq~A^Ox?Oa*vz{QvnoZ*z0fmUdqM2Wa%01~_x6H!iDrdz)`gOU?UqUN%y_8Kj%URoYPw53*%w%k~Usfi~6#|eX$uOm|q(1NLM7jX$BGN(W2O5ua=q1 z)nTeO=4%I4)FWF>t`wmtX%ZFYnVCMfa`=M0L^IfNe}E=WoteYh47pJfcCPFSOS^b3 zl^4%WpP6(VCAFrB351e)lCe?h@{p*-9(TRa;YvGkb8%VY_RLUtUIvlcB(WwuKh^VP z8cgc>S<;)@$bhdvqabU=lQ@>DJk(fz*EmyAWV~>N);vLjddC3EaQl&Pq~f6nu;ZOu z7O!q<%)kSo>exM=Xz7%XH(C@rn>$dcKntp8Z@f|-Bnb_z@lxy>awA)B_SINSER>c! zzEoQ_~A;Q4k}S zu{+e(u_N!>*)fj@YBYen*chFfoSv#yNAm>Px$$pGALB|g5uIwhIy`VOY#%0SloHVv z=e(OOJhv@dM7#AQ;#-t{S~Z5YTn?OSf?nyOLgCjYzdfZ%pJ^ z<38kRlPvNqy4MnI(k<0e()y}2t5T6!^)zXdxGru5lOW7ZT8~s+vwZQbu{8J8WuDKF z4~gH~qsTu$aU_-Ux5?AXdt|k=!=9c~4;pZcAJvLlwC~*_FD}?3bAE1%Jh-Tf%Size && heap_index_smaller(Index->Array[i], Value)) + i++; + + if (i == Index->Size) + Index->Array[Index->Size++] = Value; + else + { + void *Temporary = Index->Array[i]; + Index->Array[i] = Value; + while (i < Index->Size) + { + i++; + void *Temporary2 = Index->Array[i]; + Index->Array[i] = Temporary; + Temporary = Temporary2; + } + Index->Size++; + } +} + +u8 heap_index_smaller(void *A, void *B) +{ + return (((T_HEAP_HEADER *)A)->Size < ((T_HEAP_HEADER *)B)->Size)>0 ?1:0; +} + +void *heap_index_get(T_HEAP_INDEX *Index, u32 Position) +{ + return Index->Array[Position]; +} + +void heap_index_remove(T_HEAP_INDEX *Index, u32 Position) +{ + while (Position < Index->Size) + { Index->Array[Position] = Index->Array[Position + 1]; + Position++; + } + Index->Size--; +} + +T_HEAP *heap_create(u32 Start, u32 End, u32 Max) +{ + u16 NumSuperPages = (End - Start ) / (1024 * 1024 * 4); + if ((End - Start) % (1024 * 1024 * 4) != 0) + NumSuperPages++; + + kprintf("[i] Allocating %i superpages (%i MB) for heap.\n", + NumSuperPages, (End - Start) / 0x100000); + for (int i = 0; i < NumSuperPages; i++) + { + u32 Physical = physmem_superpage_to_physical( + physmem_allocate_superpage() + ); + + paging_map_kernel_table(Start + i * 1024 * 1024 * 4, Physical); + } + + T_HEAP* Heap = (T_HEAP *)Start; + Start += sizeof(T_HEAP); + + Heap->Index = heap_index_initialize((void*)Start, HEAP_INDEX_SIZE); + Start += HEAP_INDEX_SIZE * sizeof(void*); + + Heap->Start = Start; + Heap->End = Start + NumSuperPages * 4 * 1024 * 1024; + Heap->Max = Max; + + T_HEAP_HEADER *Hole = (T_HEAP_HEADER *)Start; + Hole->Size = End - Start; + Hole->Magic = HEAP_HEADER_MAGIC; + Hole->Hole = 1; + heap_index_insert(&Heap->Index, (void*)Hole); + + return Heap; +} + +s32 _heap_find_smallest_hole(T_HEAP *Heap, u32 Size, u8 Aligned) +{ + u32 Iterator = 0; + while (Iterator < Heap->Index.Size) + { + T_HEAP_HEADER *Header = heap_index_get(&Heap->Index, Iterator); + if (Aligned > 0) + { + u32 Location = (u32)Header; + u32 Offset = 0; + + if (((Location + sizeof(T_HEAP_HEADER)) & 0xFFFFF000) != 0) + Offset = 0x1000 - (Location + sizeof(T_HEAP_HEADER)) % 0x1000; + + u32 HoleSize = (u32)Header->Size - Offset; + + if (HoleSize >= Size) + break; + } + else if (Header->Size >= Size) + break; + Iterator++; + } + + if (Iterator == Heap->Index.Size) + return -1; + else + return Iterator; +} + +void _heap_expand(T_HEAP *Heap, u32 Size) +{ + u16 NumSuperPages = Size / 0x400000; + if (Size % 0x400000 != 0) + NumSuperPages++; + + for (int i = 0; i < NumSuperPages; i++) + { + u16 SuperPage = physmem_allocate_superpage(); + u32 Physical = physmem_superpage_to_physical(SuperPage); + paging_map_kernel_table(Heap->End + i * 0x400000, Physical); + } +} + +u32 _heap_contract(T_HEAP *Heap, u32 Size) +{ + if (Size & 0x400000) + { + Size &= 0x400000; + Size += 0x400000; + } + + if (Size < HEAP_MIN_SIZE) + Size = HEAP_MIN_SIZE; + + u32 OldSize = Heap->End - Heap->Start; + u32 NumberToDelete = (OldSize - Size) / 0x400000; + + for (int i = 0; i < NumberToDelete; i++) + { + u32 Virtual = Heap->End + i * 0x400000; + u32 Physical; + paging_get_physical(Virtual, &Physical); + u16 SuperPage = Physical / 0x400000; + physmem_free_superpage(SuperPage); + } + + Heap->End -= NumberToDelete * 0x400000; + + return (Heap->End - Heap->Start); +} + +void *heap_alloc(T_HEAP *Heap, u32 Size, u8 Aligned) +{ + u32 RealSize = Size + sizeof(T_HEAP_HEADER) + sizeof(T_HEAP_FOOTER); + s32 Iterator = _heap_find_smallest_hole(Heap, RealSize, Aligned); + + if (Iterator == -1) + { + u32 OldSize = Heap->End - Heap->Start; + u32 OldEnd = Heap->End; + + _heap_expand(Heap, RealSize); + u32 NewSize = Heap->End - Heap->Start; + + Iterator = 0; + u32 Last = 0; + s32 LastIndex = -1; + + while (Iterator < Heap->Index.Size) + { + u32 Location = (u32)heap_index_get(&Heap->Index, Iterator); + if (Location > Last) + { + Last = Location; + LastIndex = Iterator; + } + Iterator++; + } + + if (LastIndex == -1) + { + T_HEAP_HEADER *Header = (T_HEAP_HEADER *)OldEnd; + Header->Magic = HEAP_HEADER_MAGIC; + Header->Size = NewSize - OldSize; + Header->Hole = 1; + + T_HEAP_FOOTER *Footer = (T_HEAP_FOOTER *)(OldEnd + Header->Size + - sizeof(T_HEAP_FOOTER)); + Footer->Magic = HEAP_FOOTER_MAGIC; + Footer->Header = Header; + + heap_index_insert(&Heap->Index, (void*)Header); + } + else + { + T_HEAP_HEADER *Header = (T_HEAP_HEADER *)Last; + Header->Size += NewSize - OldSize; + + T_HEAP_FOOTER *Footer = (T_HEAP_FOOTER *)((u32)Header + + Header->Size - sizeof(T_HEAP_FOOTER)); + Footer->Header = Header; + Footer->Magic = HEAP_FOOTER_MAGIC; + } + + return heap_alloc(Heap, Size, Aligned); + } + + T_HEAP_HEADER *Header = (T_HEAP_HEADER*)heap_index_get(&Heap->Index, + Iterator); + u32 HoleStart = (u32)Header; + u32 HoleSize = Header->Size; + + if (HoleSize - RealSize < sizeof(T_HEAP_HEADER) + sizeof(T_HEAP_FOOTER)) + { + Size += (HoleSize - RealSize); + RealSize = HoleSize; + } + + if (Aligned && HoleStart & 0xFFFFF000) + { + u32 NewLocation = HoleStart + 0x1000 - (HoleStart & 0xFFF) + - sizeof(T_HEAP_HEADER); + Header->Size = 0x1000 - (HoleStart & 0xFFF) - sizeof(T_HEAP_HEADER); + Header->Magic = HEAP_HEADER_MAGIC; + Header->Hole = 1; + + T_HEAP_FOOTER *Footer = (T_HEAP_FOOTER*)(NewLocation + - sizeof(T_HEAP_FOOTER)); + Footer->Magic = HEAP_FOOTER_MAGIC; + Footer->Header = Header; + + HoleStart = NewLocation; + HoleSize -= Header->Size; + } + else + heap_index_remove(&Heap->Index, Iterator); + + T_HEAP_HEADER *BlockHeader = (T_HEAP_HEADER *)HoleStart; + BlockHeader->Magic = HEAP_HEADER_MAGIC; + BlockHeader->Size = RealSize; + BlockHeader->Hole = 0; + + + T_HEAP_FOOTER *BlockFooter = (T_HEAP_FOOTER *)(HoleStart + RealSize + - sizeof(T_HEAP_FOOTER)); + BlockFooter->Magic = HEAP_FOOTER_MAGIC; + BlockFooter->Header = BlockHeader; + + if (HoleSize - RealSize > 0) + { + T_HEAP_HEADER *NewHoleHeader = (T_HEAP_HEADER*)(HoleStart + RealSize); + NewHoleHeader->Magic = HEAP_HEADER_MAGIC; + NewHoleHeader->Size = HoleSize - RealSize; + NewHoleHeader->Hole = 1; + + T_HEAP_FOOTER *NewHoleFooter = (T_HEAP_FOOTER*)((u32)NewHoleHeader + + NewHoleHeader->Size - sizeof(T_HEAP_FOOTER)); + + if ((u32)NewHoleFooter < Heap->End) + { + NewHoleFooter->Magic = HEAP_FOOTER_MAGIC; + NewHoleFooter->Header = NewHoleHeader; + } + + heap_index_insert(&Heap->Index, (void*)NewHoleHeader); + } + + return (void *)((u32)BlockHeader + sizeof(T_HEAP_HEADER)); +} + +void heap_free(T_HEAP *Heap, void *Data) +{ + if (Data == 0) return; + T_HEAP_HEADER *Header = (T_HEAP_HEADER *)((u32)Data + - sizeof(T_HEAP_HEADER)); + T_HEAP_FOOTER *Footer = (T_HEAP_FOOTER *)((u32)Header + Header->Size + - sizeof(T_HEAP_FOOTER)); + + if (Header->Magic != HEAP_HEADER_MAGIC) + return; + if (Footer->Magic != HEAP_FOOTER_MAGIC) + return; + Header->Hole = 1; + + u8 ShouldAdd = 1; + + T_HEAP_FOOTER *FooterLeft = (T_HEAP_FOOTER *)((u32)Data + - sizeof(T_HEAP_FOOTER)); + if (FooterLeft->Magic == HEAP_FOOTER_MAGIC && FooterLeft->Header->Hole) + { + u32 OurSize = Header->Size; + Header = FooterLeft->Header; + Footer->Header = Header; + Header->Size += OurSize; + ShouldAdd = 0; + } + + T_HEAP_HEADER *HeaderRight = (T_HEAP_HEADER *)((u32)Footer + + sizeof(T_HEAP_FOOTER)); + if (HeaderRight->Magic == HEAP_HEADER_MAGIC && HeaderRight->Hole) + { + Header->Size += HeaderRight->Size; + Footer = (T_HEAP_FOOTER *)((u32)HeaderRight + HeaderRight->Size + - sizeof(T_HEAP_FOOTER)); + Footer->Header = Header; + + u32 Iterator = 0; + while (Iterator < Heap->Index.Size && + heap_index_get(&Heap->Index, Iterator) != (void *)HeaderRight) + Iterator++; + + if (Iterator != -1) + heap_index_remove(&Heap->Index, Iterator); + } + + if ((u32)Footer + sizeof(T_HEAP_FOOTER) == Heap->End) + { + u32 OldSize = Heap->End - Heap->Start; + u32 NewSize = _heap_contract(Heap, (u32)Header - Heap->Start); + + if (Header->Size > (OldSize - NewSize)) + { + Header->Size -= (OldSize - NewSize); + Footer = (T_HEAP_FOOTER *)((u32)Header + Header->Size + - sizeof(T_HEAP_FOOTER)); + Footer->Magic = HEAP_FOOTER_MAGIC; + Footer->Header = Header; + } + else + { + u32 Iterator = 0; + while (Iterator < Heap->Index.Size && + heap_index_get(&Heap->Index, Iterator) != (void *)Header) + Iterator++; + + if (Iterator < Heap->Index.Size) + { + heap_index_remove(&Heap->Index, Iterator); + ShouldAdd = 0; + } + } + } + + if (ShouldAdd) + heap_index_insert(&Heap->Index, (void *)Header); +} + +void heap_init_simple(void) +{ + g_heap = heap_create(HEAP_START, HEAP_START + HEAP_INITIAL_SIZE, + HEAP_START + 0x0FFFF000); +} + +void *kmalloc(u32 Size) +{ + return heap_alloc(g_heap, Size, 0); +} + +void kfree(void *Data) +{ + heap_free(g_heap, Data); +} diff --git a/src/Tier0/kmain.c b/src/Tier0/kmain.c index e00e754..7396f03 100644 --- a/src/Tier0/kmain.c +++ b/src/Tier0/kmain.c @@ -9,6 +9,7 @@ #include "Tier0/pic.h" #include "Tier0/kbd_layout.h" #include "Tier0/physical_alloc.h" +#include "Tier0/heap.h" void interrupts_irq_sample(void); @@ -64,13 +65,7 @@ void kmain(void *MultibootHeader, u32 Magic) kprintf("[i] Hardware interrupts are now enabled.\n"); - /*while(1) - { - s8 c = ps2_getc(); - kprintf("%c", c); - }*/ - - physmem_dump_map(); - + heap_init_simple(); + LOOPFOREVER; } diff --git a/src/Tier0/paging.c b/src/Tier0/paging.c index e789796..9aa8821 100644 --- a/src/Tier0/paging.c +++ b/src/Tier0/paging.c @@ -3,14 +3,9 @@ #include "Tier0/kstdio.h" #include "types.h" -// 10 megabytes is safe guess, I guess. -#define PAGING_FREEFORALL_START 0x00F00000 - u32 g_kernel_page_directory[1024] __attribute__ ((aligned (4096))); u32 g_kernel_page_tables[1024][1024] __attribute__ ((aligned (4096))); -u32 g_paging_current_offset = PAGING_FREEFORALL_START; - u8 paging_get_physical(u32 Virtual, u32 *Physical) { u16 DirectoryIndex = (Virtual >> 22) & 0x3FF; @@ -112,20 +107,3 @@ void paging_init_simple(void) "mov %%eax, %%cr0\n" :: "m" (PhysicalDirectory)); } -// This allocates a 4kb page for whatever reason -void paging_allocate_page(u32 Virtual) -{ - u32 MaximumAddress = system_get_memory_upper(); - while (!system_memory_available(g_paging_current_offset, 0x1000)) - { - g_paging_current_offset += 0x1000; - if (g_paging_current_offset > MaximumAddress) - { - kprintf("[e] Fatal error: out of memory!\n"); - for (;;) {} - } - } - - paging_map_kernel_page(Virtual, g_paging_current_offset); - g_paging_current_offset += 0x1000; -}