23. November 2024, 02:17
Beiträge anzeigen
Diese Sektion erlaubt es dir alle Beiträge dieses Mitglieds zu sehen. Beachte, dass du nur solche Beiträge sehen kannst, zu denen du auch Zugriffsrechte hast.
Übersicht
Wiki
Hilfe
Suche
Einloggen
Registrieren
// Defines
#define PAGESIZE 0x1000
/* Initialize the PMM
* Returnvalue: TRUE if all was ok, FALSE if smth. went wrong
*/
int PMMInit();
/* Alloc a frame
* Arguments: The frame to alloc
* Returnvalue: TRUE if all was ok, FALSE if smth. went wrong
*/
int MallocFrame(const u_long Frame);
/* Free a frame
* Arguments: The frame to free
* Returnvalue: TRUE if all was ok, FALSE if smth. went wrong
*/
int FreeFrame(const u_long Frame);
/* Get the value of a frame
* Arguments: The frame to get
* Returnvalue: The value of the frame
*/
int GetFrame(const u_long Frame);
/* Malloc ram
* Arguments: Size of ram to malloc; Pagealing?; Pointer to the startaddr
* Returnvalue: The addr of the ram
*/
u_long PMM_Malloc(const u_long Size, const int Align, u_long* Phys);
/* Free ram
* Arguments: The start addr of the the ram; Size of the ram
*/
void PMM_Free(const u_long StartAddr, const u_long Size);
/* Initialize the bitmap (bitset)
*/
void InitBitmap();
/* Get the actually placement addr
* Returnvalue: The placement addr
*/
u_long GetPlacementAddr();
/* Get the first free frame in the bitmap (bitset)
* Returnvalue: The first free frame
*/
u_long GetFirstFreeFrame();
// Vars
u_long* Bitmap; // The Bitmap
u_long NFrames; // The number of frames in the bitmap
int IsBitsetCreated; // Is the bitset created?
u_long PlacementAddr = (u_long) &kernel_end; // Address of the first free memory
u_long OldPlacementAddr = (u_long) &kernel_end; // The old address of the first free memory
// Create the Bitmap
void CreateBitmap()
{
// Compute the number of frames
NFrames = 0x0;
struct SMbs_MMap_Entry* MMap = (struct SMbs_MMap_Entry*) pMultibootstruct->MMap_addr;
while(MMap < (struct SMbs_MMap_Entry*) pMultibootstruct->MMap_addr + pMultibootstruct->MMap_length)
{
if(MMap->Type == 1)
{
// Vars
u_int64 EndAddr = MMap->Length;
// Save the addr
NFrames = EndAddr;
}
MMap = (struct SMbs_MMap_Entry*) ((u_int32) MMap + MMap->Size + sizeof(u_int32));
}
NFrames = NFrames / PAGESIZE;
//NFrames = (CMOSRead(0x30) | CMOSRead(0x31) << 8) / PAGESIZE;
// Create the bitmap
Bitmap = (u_long*) PMM_Malloc(NFrames / 32, 0, 0);
// Init the bitmap
InitBitmap();
// The bitmap is now created
IsBitsetCreated = TRUE;
}
// Init the PMM
int PMMInit()
{
// Create the Bitmap
CreateBitmap();
return TRUE;
}
// Malloc a frame
int MallocFrame(const u_long Frame)
{
// Set the bit
Bitmap[Frame / 32] |= (1 << Frame % 32);
return TRUE;
}
// Free a frame
int FreeFrame(const u_long Frame)
{
// Delete the bit
Bitmap[Frame / 32] &= ~(1 << Frame % 32);
return TRUE;
}
// Get the value of a frame
int GetFrame(const u_long Frame)
{
// Is the bit set?
return (Bitmap[Frame / 32] & (1 << Frame % 32));
}
// Init the bitmap
void InitBitmap()
{
// Vars
struct SMbs_MMap_Entry* MMap = (struct SMbs_MMap_Entry*) pMultibootstruct->MMap_addr;
// Reset the bitmap
k_memset(Bitmap, 1, NFrames / 32);
// Search the MMap for free memory
while(MMap < (struct SMbs_MMap_Entry*) pMultibootstruct->MMap_addr + pMultibootstruct->MMap_length)
{
// Is the address free?
if(MMap->Type == 1)
{
// Vars
u_int64 Addr = MMap->BaseAddr;
u_int64 EndAddr = MMap->Length;
// The address is free! Mark the bitmap-entry
while(Addr < EndAddr)
{
FreeFrame(Addr / PAGESIZE);
Addr += PAGESIZE;
}
}
MMap = (struct SMbs_MMap_Entry*) ((u_int32) MMap + MMap->Size + sizeof(u_int32));
}
}
// Return the placement addr
u_long GetPlacementAddr()
{
return PlacementAddr;
}
// Return the first free frame
u_long GetFirstFreeFrame()
{
// Vars
u_long Index;
u_long Offset;
// Search for a free frame
for(Index = 0; Index < (NFrames / 32); Index++)
{
for(Offset = 0; Offset < 32; Offset++)
{
if(!(Bitmap[Index] & 1 << Offset))
return Index * 32 + Offset;
}
}
// If nothing was found, return -1
return -1;
}
// Malloc memory
u_long PMM_Malloc(const u_long Size, const int Align, u_long* Phys)
{
// Vars
u_long Addr;
// Page alignt?
if(Align == TRUE && PlacementAddr & 0xFFFFF000)
{
PlacementAddr &= 0xFFFFF000;
PlacementAddr += PAGESIZE;
}
// If Phys, save the start address of the new memory
if(Phys != 0)
*Phys = PlacementAddr;
// Reserv memory
Addr = PlacementAddr;
PlacementAddr += Size;
// If the bitmap is created, mark the bits in the bitset
if(IsBitsetCreated == TRUE)
{
// Temp-Vars
u_long Temp = Addr;
while(Temp < PlacementAddr)
{
MallocFrame(Temp / PAGESIZE);
Temp += PAGESIZE;
}
}
return Addr;
}
// Free memory
void PMM_Free(const u_long StartAddr, const u_long Size)
{
// Vars
u_long Addr = StartAddr;
// Clear the bits in the bitset
while(Addr < StartAddr + Size)
{
FreeFrame(Addr / PAGESIZE);
Addr += PAGESIZE;
}
}
Virtueller Speichermanager:// A page
struct SPage
{
u_int32 Present : 1; // Is the page present in the memory?
u_int32 RW : 1; // Read- or Write-able
u_int32 User : 1; // User or supervisor previligs
u_int32 Accessed : 1; // Has the page been accessed since the last refresh?
u_int32 Dirty : 1; // Has the page been changed since the last refresh?
u_int32 Reserved : 7; // Reserved
u_int32 Frame : 20; // Frameaddr in the physical memory
};
// A pagetable
struct SPage_Table
{
struct SPage Pages[1024]; // All pages in the pagetable
};
// Pagediretory
struct SPage_Directory
{
u_int32 TablesPhysical[1024]; // Pointer to the page tables
struct SPage_Table* Tables[1024]; // The page tables
u_int32 PhysicalAddr; // Physicaladdr
};
/* Initalize the VMM
* Returnvalue: TRUE if all was ok, FALSE if smth. went wrong
*/
int VMMInit();
/* Malloc a page
* Arguments: The page to malloc; User?; RW?
* Returnvalue: TRUE if all was ok, FALSE if smth. went wrong
*/
int MallocPage(struct SPage* Page, int User, int RW);
/* Free a page
* Arguments: The page to free
*/
void FreePage(struct SPage* Page);
/* Get the page for an addr
* Arguments:
* Returnvalue: The page for the addr
*/
struct SPage* GetPage(u_long Addr);
// Vars
struct SPage_Directory* PageDirectory; // The page directory
// Init the VMM
int VMMInit()
{
// Create a page directory
u_long Phys;
PageDirectory = (struct SPage_Directory*) PMM_Malloc(sizeof(struct SPage_Directory), TRUE, &Phys);
k_memset(PageDirectory, 0, sizeof(struct SPage_Directory));
PageDirectory->PhysicalAddr = Phys;
// Map the memory from physical to virtual
// NOTE: We only map the memory which is actually used!
int Addr = 0;
while(Addr < GetPlacementAddr())
{
MallocPage(GetPage(Addr), FALSE, TRUE);
Addr += PAGESIZE;
}
// Enable paging
asm ("mov %0, %%cr3":: "r"(&PageDirectory->PhysicalAddr));
extern void InitPaging();
InitPaging();
return TRUE;
}
// Malloc a page
int MallocPage(struct SPage* Page, int User, int RW)
{
// Is the page already allocated?
if(Page->Frame != 0)
return FALSE;
// Malloc the page
// Search a free frame
u_long Frame = GetFirstFreeFrame();
// If no Frame free?
if(Frame == -1)
return FALSE;
MallocFrame(Frame * PAGESIZE);
Page->Present = 1;
Page->User = User ? 1 : 0;
Page->RW = RW ? 1 : 0;
Page->Frame = Frame;
return TRUE;
}
// Get a page
struct SPage* GetPage(u_long Addr)
{
// Compute the index of the page table
u_int32 Index = Addr / PAGESIZE / 1024;
// Is the page already existing?
if(PageDirectory->Tables[Index])
{
// Return the page
return &PageDirectory->Tables[Index]->Pages[(Addr / PAGESIZE) % 1024];
}
else
{
// The page is not already existing, create it
u_long Temp;
PageDirectory->Tables[Index] = (struct SPage_Table*) PMM_Malloc(sizeof(struct SPage_Table), TRUE, &Temp);
k_memset(PageDirectory->Tables[Index], 0, PAGESIZE);
PageDirectory->TablesPhysical[Index] = Temp | 0x7;
return &PageDirectory->Tables[Index]->Pages[(Addr / PAGESIZE) % 1024];
}
}
// Free a page
void FreePage(struct SPage* Page)
{
// Free the frame and the page
FreeFrame(Page->Frame);
Page->Frame = 0x0;
}
Ich hoffe, dass mir jemand helfen kann, und bedanke mich schoneinmal für Hilfe im voraus.
// Test for Irq
void IRQ0_Test(struct SIRQParam Param)
{
kprintf("IRQ 0", 0, 10);
DeleteIRQHandler(0);
kprintf("IRQ0-handler deleted", 0, 12);
}
IRQ.c// Defines
#define PCI1 0x20
#define PCI2 0xA0
#define PCI1_DATA (PCI1 + 1)
#define PCI2_DATA (PCI2 + 1)
#define PCI1_VECTOR 0x20
#define PCI2_VECTOR 0x28
// The 16 IRQ-functions (they are in IRQ.asm)
extern void IRQ0();
extern void IRQ1();
extern void IRQ2();
extern void IRQ3();
extern void IRQ4();
extern void IRQ5();
extern void IRQ6();
extern void IRQ7();
extern void IRQ8();
extern void IRQ9();
extern void IRQ10();
extern void IRQ11();
extern void IRQ12();
extern void IRQ13();
extern void IRQ14();
extern void IRQ15();
// The IRQHandler
void* IRQHandlers[16] =
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
// Remap the entries
void Remap()
{
// Start the init process
OutPort(PCI1, 0x11);
OutPort(PCI2, 0x11);
// Remap the entries
OutPort(PCI1_DATA, 0x20);
OutPort(PCI2_DATA, 0x28);
OutPort(PCI2_DATA, 0x04);
OutPort(PCI1_DATA, 0x02);
OutPort(PCI2_DATA, 0x01);
OutPort(PCI1_DATA, 0x01);
OutPort(PCI2_DATA, 0x00);
OutPort(PCI1_DATA, 0x00);
}
// Init IRQ
int IRQInit()
{
// Remap the IRQ entries
Remap();
// Set the IRQ-Functions
IDTSetEntry(32, (unsigned long) IRQ0, 0x08, 0x8E);
IDTSetEntry(33, (unsigned long) IRQ1, 0x08, 0x8E);
IDTSetEntry(34, (unsigned long) IRQ2, 0x08, 0x8E);
IDTSetEntry(35, (unsigned long) IRQ3, 0x08, 0x8E);
IDTSetEntry(36, (unsigned long) IRQ4, 0x08, 0x8E);
IDTSetEntry(37, (unsigned long) IRQ5, 0x08, 0x8E);
IDTSetEntry(38, (unsigned long) IRQ6, 0x08, 0x8E);
IDTSetEntry(39, (unsigned long) IRQ7, 0x08, 0x8E);
IDTSetEntry(40, (unsigned long) IRQ8, 0x08, 0x8E);
IDTSetEntry(41, (unsigned long) IRQ9, 0x08, 0x8E);
IDTSetEntry(42, (unsigned long) IRQ10, 0x08, 0x8E);
IDTSetEntry(43, (unsigned long) IRQ11, 0x08, 0x8E);
IDTSetEntry(44, (unsigned long) IRQ12, 0x08, 0x8E);
IDTSetEntry(45, (unsigned long) IRQ13, 0x08, 0x8E);
IDTSetEntry(46, (unsigned long) IRQ14, 0x08, 0x8E);
IDTSetEntry(47, (unsigned long) IRQ15, 0x08, 0x8E);
// Enable the IRQ
asm volatile("sti");
// All was success
return 1;
}
// This function set an IRQHandler
void SetIRQHandler(void *pFunction, const unsigned int iIRQIndex)
{
IRQHandlers[iIRQIndex] = pFunction;
}
// This function delete an IRQHandler
void DeleteIRQHandler(const unsigned int iIRQIndex)
{
IRQHandlers[iIRQIndex] = 0;
}
// The IRQ-Handler which is called in IRQ.asm
void IRQHandler(struct SIRQParam Param)
{
// Call the IRQ-Handler
void (*pIRQHandler) (struct SIRQParam);
if (IRQHandlers[Param.iIRQ] != NULL)
{
pIRQHandler = IRQHandlers[Param.iIRQ];
pIRQHandler(Param);
}
// Tell the PCI that we finished with the interrupt
if (Param.iIRQ >= 8)
OutPort(PCI2, 0x20);
OutPort(PCI1, 0x20);
}
IRQ.asm........
IRQ15:
cli
push byte 15
jmp IRQ_HANDLER
; The IRQ-Handler
extern IRQHandler
IRQ_HANDLER:
; Make sure that we are working with kernel privilegs
mov ax, 0x10
mov ds, ax
mov es, ax
mov fs, ax
mov gs, ax
; Call the c-Handler
call IRQHandler
iret
Er funktioniert aber nicht richtig. Der IRQ-Handler aus Kernel.c wird zwar ausgerufen, aber sobald der IRQ-Manager diese Interrupt fertig bearbeitet hat, gibt es einen Reboot. Warum? Was habe ich falsch gemacht?void kprintf(char* chBuffer, const unsigned int iXPos, const unsigned int iYPos)
{
// Compute the position in the ram
char* VGAMem = (char*) 0xB8000;
VGAMem += (iYPos * 80 + iXPos) * 2;
// Print every char with the attributes on the screen
while(*chBuffer)
{
*VGAMem = *chBuffer;
VGAMem++;
*VGAMem = iAttribute;
VGAMem++;
chBuffer++;
}
}
Eine Idee, was daran falsch sein könnte? Vielleicht liegt es am Zeiger...
void FaultHandler(struct SISRParam* Param)
{
// Print an error on the screen the screen and stop the cpu
ClsEx(0x47);
SetTextAttribute(0x47);
kprintf("Exception", 0, 0);
// Print an discription on the screen
kprintf("Description: ", 0, 1);
if(Param->int_no < 32)
kprintf((char*) ExceptionMessage[Param->int_no], 13, 1);
// Show all register
kprintf("Register:", 0, 2);
kprintf("GS:", 3, 3);
kprintf("FS:", 15, 3);
kprintf("ES:", 27, 3);
kprintf("DS:", 38, 3);
kprintf("EAX:", 52, 3);
kprintf("EDI:", 3, 4);
kprintf("ESI:", 15, 4);
kprintf("EBP:", 27, 4);
kprintf("ESP:", 38, 4);
kprintf("EBX:", 52, 4);
kprintf("EDX:", 65, 4);
kprintf("ECX:", 3, 5);
kprintf("EIP:", 15, 5);
kprintf("CS:", 27, 5);
kprintf("EFLAGS:", 38, 5);
kprintf("USERSP:", 52, 5);
kprintf("SS:", 65, 5);
// Stop the CPU
kprintf("System halted!", 0, 6);
SetCursor(0, 7);
asm volatile ("hlt");
}
struct SISRParam
{
unsigned int gs, fs, es, ds; /* pushed the segs last */
unsigned int edi, esi, ebp, esp, ebx, edx, ecx, eax; /* pushed by 'pusha' */
unsigned int int_no, err_code; /* our 'push byte #' and ecodes do this */
unsigned int eip, cs, eflags, useresp, ss; /* pushed by the processor automatically */
};
const char* ExceptionMessage[] = // Descriptions for the Exceptions
{
"Division By Zero Exception",
"Debug Exception",
"Non Maskable Interrupt Exception",
"Breakpoint Exception",
"Into Detected Overflow Exception",
"Out of Bounds Exception",
"Invalid Opcode Exception",
"No Coprocessor Exception",
"Double Fault Exception",
"Coprocessor Segment Overrun Exception",
"Bad TSS Exception",
"Segment Not Present Exception",
"Stack Fault Exception",
"General Protection Fault Exception",
"Page Fault Exception",
"Unknown Interrupt Exception",
"Coprocessor Fault Exception",
"Alignment Check Exception",
"Machine Check Exception",
"Reserved Exceptions",
"Reserved Exceptions",
"Reserved Exceptions",
"Reserved Exceptions",
"Reserved Exceptions",
"Reserved Exceptions",
"Reserved Exceptions",
"Reserved Exceptions",
"Reserved Exceptions",
"Reserved Exceptions",
"Reserved Exceptions",
"Reserved Exceptions"
};
ISR0:
cli ; Disable all interrupts
push byte 0 ; Push the isr number on th stack
push byte 0
jmp FAULT_HANDLER ; Jump to the general faulthandler
ISR1:
cli
push byte 1
push byte 1
jmp FAULT_HANDLER
; Create the parameters
pusha
push ds
push es
push fs
push gs
mov ax, 0x10 ; Load the Kernel Data Segment descriptor!
mov ds, ax
mov es, ax
mov fs, ax
mov gs, ax
mov eax, esp ; Push us the stack
push eax
; Call the c-FaultHandler
mov eax, FaultHandler
call eax
ret