diff --git a/APILib/APILib.c b/APILib/APILib.c new file mode 100644 index 0000000..e69de29 diff --git a/Docs/Untitled Diagram.drawio b/Docs/Untitled Diagram.drawio new file mode 100644 index 0000000..6b6159c --- /dev/null +++ b/Docs/Untitled Diagram.drawio @@ -0,0 +1 @@ +UzV2zq1wL0osyPDNT0nNUTV2VTV2LsrPL4GwciucU3NyVI0MMlNUjV1UjYwMgFjVyA2HrCFY1qAgsSg1rwSLBiADYTaQg2Y1AA== \ No newline at end of file diff --git a/Hal/Psi/HalBoot.c b/Hal/Psi/HalBoot.c new file mode 100644 index 0000000..e69de29 diff --git a/Hal/Psi/HalCPU.c b/Hal/Psi/HalCPU.c new file mode 100644 index 0000000..e69de29 diff --git a/Hal/Psi/HalCache.c b/Hal/Psi/HalCache.c new file mode 100644 index 0000000..e69de29 diff --git a/Hal/Psi/HalFirmware.c b/Hal/Psi/HalFirmware.c new file mode 100644 index 0000000..e69de29 diff --git a/Hal/Psi/HalIPC.c b/Hal/Psi/HalIPC.c new file mode 100644 index 0000000..e69de29 diff --git a/Hal/Psi/HalInterface.c b/Hal/Psi/HalInterface.c new file mode 100644 index 0000000..e69de29 diff --git a/Hal/Psi/HalInterrupt.c b/Hal/Psi/HalInterrupt.c new file mode 100644 index 0000000..e69de29 diff --git a/Hal/Psi/HalMMU.c b/Hal/Psi/HalMMU.c new file mode 100644 index 0000000..e69de29 diff --git a/Hal/Psi/HalSync.c b/Hal/Psi/HalSync.c new file mode 100644 index 0000000..e69de29 diff --git a/Hal/Psi/HalVirtual.c b/Hal/Psi/HalVirtual.c new file mode 100644 index 0000000..e69de29 diff --git a/Hal/X86_64/HalBoot.c b/Hal/X86_64/HalBoot.c new file mode 100644 index 0000000..1db755e --- /dev/null +++ b/Hal/X86_64/HalBoot.c @@ -0,0 +1,78 @@ +/********************************************************** + 底层引导初始化文件HalBoot.c +*********************************************************** + 彭东 +**********************************************************/ +#include "BaseType.h" +#include "HalBoot.h" +#include "HalFirmware.h" +#include "HalCPU.h" +#include "HalMMU.h" +#include "HalCache.h" +#include "HalIPC.h" +#include "HalInterrupt.h" +#include "HalInterface.h" +#include "KrlInit.h" + +public MachStartInfo* HalGetMachStartInfoAddr() +{ + return (MachStartInfo*)HalPAddrToVAddr((Addr)MSI_PADR); +} + +public Addr HalBootAllocMem(Size size) +{ + MachStartInfo* msinfo = NULL; + Addr ret = NULL; + if(0 == size) + { + return NULL; + } + msinfo = HalExPGetMachStartInfoAddr(); + IF_NULL_DEAD(msinfo); + + ret = (Addr)msinfo->BrkCurrAddr; + if(((U64)(ret + (Addr)size)) >= msinfo->BrkEndAddr) + { + return NULL; + } + msinfo->BrkCurrAddr += (U64)size; + return HalPAddrToVAddr(ret); +} + +public E820Map* HalBootGetNextE820() +{ + MachStartInfo* msinfo = NULL; + E820Map* ret = NULL; + E820Map* start = NULL; + + msinfo = HalExPGetMachStartInfoAddr(); + IF_NULL_DEAD(msinfo); + + start = (E820Map*)HalPAddrToVAddr((Addr)msinfo->E820PAddr); + if(NULL == start || msinfo->E820Curr >= msinfo->E820NR) + { + return NULL; + } + + ret = &start[msinfo->E820Curr]; + msinfo->E820Curr++; + return ret; +} + +private Bool HalBootInit() +{ + HalFirmwareInit(); + HalCPUInit(); + HalMMUInit(); + HalCacheInit(); + HalInterruptInit(); + HalIPCInit(); + return TRUE; +} + +public void HalBootStart() +{ + HalBootInit(); + KrlCoreInit(); + return; +} \ No newline at end of file diff --git a/Hal/X86_64/HalCPU.c b/Hal/X86_64/HalCPU.c new file mode 100644 index 0000000..b994aa6 --- /dev/null +++ b/Hal/X86_64/HalCPU.c @@ -0,0 +1,295 @@ +/********************************************************** + CPU相关的文件HalCPU.c +*********************************************************** + 彭东 +**********************************************************/ +#include "BaseType.h" +#include "HalCPU.h" +#include "HalInterrupt.h" + +DefinedCPUArchData(GDT, GDTable); +DefinedCPUArchData(IDT, IDTable); +DefinedCPUArchData(TSS, TSSTable); +DefinedCPUArchData(GDTPTR, GDTablePtr); +DefinedCPUArchData(IDTPTR, IDTablePtr); + +public void __attribute__((optnone)) HalDead(UInt count) +{ + if(0 == count) + { + HALT(); + } + + for(UInt i = 0; i < count; i++) + { + for(UInt j = 0; j < count; j++) + { + for(UInt k = 0; k < count; k++) + { + for(UInt l = 0; l < count; l++) + { + for(UInt m = 0; m < count; m++) + { + for(UInt n = 0; n < count; n++) + { + ; + } + } + } + } + } + } + return; +} +public Addr HalVAddrToPAddr(Addr kvaddr) +{ + if (kvaddr < KRNL_MAP_VIRTADDRESS_START || kvaddr > KRNL_MAP_VIRTADDRESS_END) + { + // system_error("virAddro_phyadr err\n"); + return KRNL_ADDR_ERROR; + } + return kvaddr - KRNL_MAP_VIRTADDRESS_START; +} + +public Addr HalPAddrToVAddr(Addr kpaddr) +{ + if (kpaddr >= KRNL_MAP_PHYADDRESS_END) + { + // system_error("phyAddro_viradr err\n"); + return KRNL_ADDR_ERROR; + } + return kpaddr + KRNL_MAP_VIRTADDRESS_START; +} + +//gate = &IDTable.GateDescArr[vector]; +private Bool SetOneGateDesc(GateDesc* gate, U8 type, IDTHandler handler, U8 privilege) +{ + U64 base = (U64)handler; + gate->OffsetLow = base & 0xFFFF; + gate->Selector = SELECTOR_KERNEL_CS; + gate->DCount = 0; + gate->Attr = (U8)(type | (privilege << 5)); + gate->OffsetHigh = (U16)((base >> 16) & 0xFFFF); + gate->OffsetHighH = (U32)((base >> 32) & 0xffffffff); + gate->OffsetResv = 0; + return TRUE; +} + +private Bool SetOneSegmentDesc(SegmentDesc* desc, U32 base, U32 limit, U16 attribute) +{ + desc->LimitLow = limit & 0x0FFFF; // 段界限 1(2 字节) + desc->BaseLow = base & 0x0FFFF; // 段基址 1(2 字节) + desc->BaseMiddle = (base >> 16) & 0x0FF; // 段基址 2(1 字节) + desc->Attr1 = (U8)(attribute & 0xFF); // 属性 1 + desc->LimitHighAttr2 = (U8)(((limit >> 16) & 0x0F) | ((attribute >> 8) & 0xF0)); // 段界限 2 + 属性 2 + desc->BaseHigh = (U8)((base >> 24) & 0x0FF); // 段基址 3\(1 字节) + return; +} + +private Bool SetOneX64TSSAttrInSegmentDesc(SegmentDesc* desc, U64 base, U32 limit, U16 attribute) +{ + U32* x64tssbasehight = (U32*)(desc + 1); + + desc->LimitLow = limit & 0x0FFFF; // 段界限 1(2 字节) + desc->BaseLow = base & 0x0FFFF; // 段基址 1(2 字节) + desc->BaseMiddle = (base >> 16) & 0x0FF; // 段基址 2(1 字节) + desc->Attr1 = (U8)(attribute & 0xFF); // 属性 1 + desc->LimitHighAttr2 = (U8)(((limit >> 16) & 0x0F) | ((attribute >> 8) & 0xF0)); // 段界限 2 + 属性 2 + desc->BaseHigh = (U8)((base >> 24) & 0x0FF); + + *x64tssbasehight = (U32)((base >> 32) & 0xffffffff); + *(x64tssbasehight + 1) = 0; + return TRUE; +} + +private void CPULoadGDT(GDTPTR* gdtptr) +{ + + __asm__ __volatile__( + + "cli \n\t" + "pushq %%rax \n\t" + //"movq %0,%%rax \n\t" + "lgdt (%0) \n\t" + + "movabsq $1f,%%rax \n\t" + //"pushq $0 \n\t" $x64_igdt_reg//# fake return address to stop unwinder + "pushq $8 \n\t" + "pushq %%rax \n\t" + "lretq \n\t" + "1:\n\t" + "movw $0x10,%%ax\n\t" + "movw %%ax,%%ds\n\t" + "movw %%ax,%%es\n\t" + "movw %%ax,%%ss\n\t" + "movw %%ax,%%fs\n\t" + "movw %%ax,%%gs\n\t" + "popq %%rax \n\t" + : + : "r"(gdtptr) + : "rax", "memory"); + return; +} + +private void CPULoadIDT(IDTPTR* idtptr) +{ + __asm__ __volatile__( + "lidt (%0) \n\t" + + : + : "r"(idtptr) + : "memory"); + return; +} + +private void CPULoadTr(U16 trindx) +{ + __asm__ __volatile__( + "ltr %0 \n\t" + : + : "r"(trindx) + : "memory"); + return; +} + + +private Bool CPUInitIDT() +{ + for(UInt i = 0; i < IDTMAX; i++) + { + SetOneGateDesc(&IDTable.GateDescArr[i], DA_386IGate, HalExCOSDefaultFaultHandle, PRIVILEGE_KRNL) + } + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_DIVIDE, DA_386IGate, HalExCDivideError, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_DEBUG, DA_386IGate, HalExCSingleStepException, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_NMI, DA_386IGate, HalExCNMI, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_BREAKPOINT, DA_386IGate, HalExCBreakPointException, PRIVILEGE_USER); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_OVERFLOW, DA_386IGate, HalExCOverflow, PRIVILEGE_USER); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_BOUNDS, DA_386IGate, HalExCBoundsCheck, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_INVAL_OP, DA_386IGate, HalExCInvalOPCode, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_COPROC_NOT, DA_386IGate, HalExCCoprNotAvailable, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_DOUBLE_FAULT, DA_386IGate, HalExCDoubleFault, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_COPROC_SEG, DA_386IGate, HalExCCoprSegOverrun, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_INVAL_TSS, DA_386IGate, HalExCInvalTSS, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_SEG_NOT, DA_386IGate, HalExCSegmentNotPresent, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_STACK_FAULT, DA_386IGate, HalExCStackException, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_PROTECTION, DA_386IGate, HalExCGeneralProtection, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_PAGE_FAULT, DA_386IGate, HalExCPageFault, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_COPROC_ERR, DA_386IGate, HalExCCoprError, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_ALIGN_CHEK, DA_386IGate, HalExCAlignmentCheck, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_MACHI_CHEK, DA_386IGate, HalExCMachineCheck, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_SIMD_FAULT, DA_386IGate, HalExCSimdFault, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ0 + 0], DA_386IGate, HalExIHWINT00, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ0 + 1], DA_386IGate, HalExIHWINT01, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ0 + 2], DA_386IGate, HalExIHWINT02, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ0 + 3], DA_386IGate, HalExIHWINT03, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ0 + 4], DA_386IGate, HalExIHWINT04, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ0 + 5], DA_386IGate, HalExIHWINT05, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ0 + 6], DA_386IGate, HalExIHWINT06, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ0 + 7], DA_386IGate, HalExIHWINT07, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 0], DA_386IGate, HalExIHWINT08, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 1], DA_386IGate, HalExIHWINT09, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 2], DA_386IGate, HalExIHWINT10, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 3], DA_386IGate, HalExIHWINT11, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 4], DA_386IGate, HalExIHWINT12, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 5], DA_386IGate, HalExIHWINT13, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 6], DA_386IGate, HalExIHWINT14, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 7], DA_386IGate, HalExIHWINT15, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 8], DA_386IGate, HalExIHWINT16, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 9], DA_386IGate, HalExIHWINT17, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 10], DA_386IGate, HalExIHWINT18, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 11], DA_386IGate, HalExIHWINT19, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 12], DA_386IGate, HalExIHWINT20, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 13], DA_386IGate, HalExIHWINT21, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 14], DA_386IGate, HalExIHWINT22, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_IRQ8 + 15], DA_386IGate, HalExIHWINT23, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_APIC_IPI_SCHEDUL], DA_386IGate, HalExIApicIPISchedul, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_APIC_SVR], DA_386IGate, HalExIApicSVR, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_APIC_TIMER], DA_386IGate, HalExIApicTimer, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_APIC_THERMAL], DA_386IGate, HalExIApicThermal, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_APIC_PERFORM], DA_386IGate, HalExIApicPerformonitor, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_APIC_LINTO], DA_386IGate, HalExIApicLint0, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_APIC_LINTI], DA_386IGate, HalExIApicLint1, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_APIC_ERROR], DA_386IGate, HalExIApicError, PRIVILEGE_KRNL); + + SetOneGateDesc(&IDTable.GateDescArr[INT_VECTOR_SYSCALL], DA_386IGate, HalExSAPICall, PRIVILEGE_USER); + + IDTablePtr.IDTBass = (U64)(&IDTable.GateDescArr[0]); + IDTablePtr.IDTLen = sizeof(IDTable.GateDescArr) - 1; + CPULoadIDT(&IDTablePtr); + return TRUE; +} + +private Bool CPUInitGDT() +{ + SetOneSegmentDesc(&GDTable.SegmentDescArr[0], 0, 0, 0); + SetOneSegmentDesc(&GDTable.SegmentDescArr[1], 0, 0, DA_CR | DA_64 | 0); + SetOneSegmentDesc(&GDTable.SegmentDescArr[2], 0, 0, DA_DRW | DA_64 | 0); + SetOneSegmentDesc(&GDTable.SegmentDescArr[3], 0, 0, DA_CR | DA_64 | DA_DPL3 | 0); + SetOneSegmentDesc(&GDTable.SegmentDescArr[4], 0, 0, DA_DRW | DA_64 | DA_DPL3 | 0); + SetOneX64TSSAttrInSegmentDesc(&GDTable.SegmentDescArr[6], (U64)(&TSSTable.TSSArr[0]), sizeof(TSSTable.TSSArr[0]) - 1, DA_386TSS); + + GDTablePtr.GDTBass = (U64)(GDTable.SegmentDescArr); + GDTablePtr.GDTLen = sizeof(GDTable.SegmentDescArr) - 1; + + CPULoadGDT(&GDTablePtr); + CPULoadTr(X64TSS_INDEX); + return TRUE; +} + +public Bool HalCPUInit() +{ + CPUInitGDT(); + CPUInitIDT(); + return TRUE; +} \ No newline at end of file diff --git a/Hal/X86_64/HalCache.c b/Hal/X86_64/HalCache.c new file mode 100644 index 0000000..6fd2fab --- /dev/null +++ b/Hal/X86_64/HalCache.c @@ -0,0 +1,94 @@ +/********************************************************** + Cache控制文件HalCache.c +*********************************************************** + 彭东 +**********************************************************/ +#include "BaseType.h" +#include "HalCache.h" +private void CacheWbinvd() +{ + __asm__ __volatile__("wbinvd": : :"memory"); + return; +} + +private void CacheInvd() +{ + __asm__ __volatile__("invd": : :"memory"); + return; +} + +private void CacheCLFlush(void* addr) +{ + __asm__ __volatile__("clflush %0" : "+m" (*(volatile char*)addr)); + return; +} + +private void CacheEnable() +{ + __asm__ __volatile__( + "movl %%cr0, %%eax \n\t" + "btrl $29, %%eax \n\t" //CR0.NW=0 + "btrl $30, %%eax \n\t" //CR0.CD=0 CACHE + "movl %%eax, %%cr0 \n\t" + : + : + :"eax", "memory" + ) + return; +} + +private void CacheDisable() +{ + __asm__ __volatile__( + "movl %%cr0, %%eax \n\t" + "btsl $29, %%eax \n\t" //CR0.NW=0 + "btsl $30, %%eax \n\t" //CR0.CD=0 CACHE + "movl %%eax, %%cr0 \n\t" + : + : + :"eax", "memory" + ) + return; +} + + +public Bool HalCacheEnable() +{ + CacheEnable(); + return TRUE; +} + +public Bool HalCacheDisable() +{ + CacheWbinvd(); + CacheDisable(); + return TRUE; +} + +public Bool HalCacheRefresh() +{ + CacheWbinvd(); + return TRUE; +} + +public Bool HalCacheRefreshLine(Addr vaddr) +{ + CacheCLFlush((void*)vaddr); + return TRUE; +} + +public Bool HalCacheInvalid() +{ + CacheInvd(); + return TRUE; +} + +public Bool HalCacheInvalidLine(Addr vaddr) +{ + return HalCacheRefreshLine(vaddr); +} + +public Bool HalCacheInit() +{ + return HalCacheEnable(); +} \ No newline at end of file diff --git a/Hal/X86_64/HalEIIntoPoint.asm b/Hal/X86_64/HalEIIntoPoint.asm new file mode 100644 index 0000000..4c9d45b --- /dev/null +++ b/Hal/X86_64/HalEIIntoPoint.asm @@ -0,0 +1,181 @@ +;***************************************************************************** +;* 底层核心文件Kernel.asm * +;* 彭东 +;***************************************************************************** + +%include "HalEIIntoPoint.h" +[section .hwint.text] +[BITS 64] + +ALIGN 16 +HalExCDivideError: + SRFTFAULT 0 +ALIGN 16 +HalExCSingleStepException: + SRFTFAULT 1 +ALIGN 16 +HalExCnmi: + SRFTFAULT 2 +ALIGN 16 +HalExCBreakPointException: + SRFTFAULT 3 +ALIGN 16 +HalExCOverflow: + SRFTFAULT 4 +ALIGN 16 +HalExCBoundsCheck: + SRFTFAULT 5 +ALIGN 16 +HalExCInvalOPCode: + SRFTFAULT 6 +ALIGN 16 +HalExCCoprNotAvailable: + SRFTFAULT 7 +ALIGN 16 +HalExCDoubleFault: + SRFTFAULT_ECODE 8 +ALIGN 16 +HalExCCoprSegOverrun: + SRFTFAULT 9 +ALIGN 16 +HalExCInvalTSS: + SRFTFAULT_ECODE 10 +ALIGN 16 +HalExCSegmentNotPresent: + SRFTFAULT_ECODE 11 +ALIGN 16 +HalExCStackException: + SRFTFAULT_ECODE 12 +ALIGN 16 +HalExCGeneralProtection: + SRFTFAULT_ECODE 13 +ALIGN 16 +HalExCPageFault: + SRFTFAULT_ECODE 14 +ALIGN 16 +HalExCCoprError: + SRFTFAULT 16 +ALIGN 16 +HalExCAlignmentCheck: + SRFTFAULT_ECODE 17 +ALIGN 16 +HalExCMachineCheck: + SRFTFAULT 18 +ALIGN 16 +HalExCSimdFault: + SRFTFAULT 19 +ALIGN 16 +HalExCOSDefaultFaultHandle: + SRFTFAULT 256 + + +ALIGN 16 +HalExIHWINT00: + HARWINT (INT_VECTOR_IRQ0+0) +ALIGN 16 +HalExIHWINT01: + HARWINT (INT_VECTOR_IRQ0+1) +ALIGN 16 +HalExIHWINT02: + HARWINT (INT_VECTOR_IRQ0+2) +ALIGN 16 +HalExIHWINT03: + HARWINT (INT_VECTOR_IRQ0+3) +ALIGN 16 +HalExIHWINT04: + HARWINT (INT_VECTOR_IRQ0+4) +ALIGN 16 +HalExIHWINT05: + HARWINT (INT_VECTOR_IRQ0+5) +ALIGN 16 +HalExIHWINT06: + HARWINT (INT_VECTOR_IRQ0+6) +ALIGN 16 +HalExIHWINT07: + HARWINT (INT_VECTOR_IRQ0+7) +ALIGN 16 +HalExIHWINT08: + HARWINT (INT_VECTOR_IRQ0+8) +ALIGN 16 +HalExIHWINT09: + HARWINT (INT_VECTOR_IRQ0+9) +ALIGN 16 +HalExIHWINT10: + HARWINT (INT_VECTOR_IRQ0+10) +ALIGN 16 +HalExIHWINT11: + HARWINT (INT_VECTOR_IRQ0+11) +ALIGN 16 +HalExIHWINT12: + HARWINT (INT_VECTOR_IRQ0+12) + +ALIGN 16 +HalExIHWINT13: + HARWINT (INT_VECTOR_IRQ0+13) +ALIGN 16 +HalExIHWINT14: + HARWINT (INT_VECTOR_IRQ0+14) +ALIGN 16 +HalExIHWINT15: + HARWINT (INT_VECTOR_IRQ0+15) +ALIGN 16 +HalExIHWINT16: + HARWINT (INT_VECTOR_IRQ0+16) +ALIGN 16 +HalExIHWINT17: + HARWINT (INT_VECTOR_IRQ0+17) + +ALIGN 16 +HalExIHWINT18: + HARWINT (INT_VECTOR_IRQ0+18) + +ALIGN 16 +HalExIHWINT19: + HARWINT (INT_VECTOR_IRQ0+19) + +ALIGN 16 +HalExIHWINT20: + HARWINT (INT_VECTOR_IRQ0+20) + +ALIGN 16 +HalExIHWINT21: + HARWINT (INT_VECTOR_IRQ0+21) + +ALIGN 16 +HalExIHWINT22: + HARWINT (INT_VECTOR_IRQ0+22) +ALIGN 16 +HalExIHWINT23: + HARWINT (INT_VECTOR_IRQ0+23) + +ALIGN 16 +HalExIApicIPISchedul: + HARWINT INT_VECTOR_APIC_IPI_SCHEDUL +ALIGN 16 +HalExIApicSVR: + HARWINT INT_VECTOR_APIC_SVR +ALIGN 16 +HalExIApicTimer: + HARWINT INT_VECTOR_APIC_TIMER +ALIGN 16 +HalExIApicThermal: + HARWINT INT_VECTOR_APIC_THERMAL +ALIGN 16 +HalExIApicPerformonitor: + HARWINT INT_VECTOR_APIC_PERFORM +ALIGN 16 +HalExIApicLint0: + HARWINT INT_VECTOR_APIC_LINTO +ALIGN 16 +HalExIApicLint1: + HARWINT INT_VECTOR_APIC_LINTI +ALIGN 16 +HalExIApicError: + HARWINT INT_VECTOR_APIC_ERROR + +ALIGN 16 +HalExSAPICall: + EXSAPICALL +ALIGN 16 +HalASMRetFromUserMode: + RESTOREALL diff --git a/Hal/X86_64/HalFirmware.c b/Hal/X86_64/HalFirmware.c new file mode 100644 index 0000000..18f629f --- /dev/null +++ b/Hal/X86_64/HalFirmware.c @@ -0,0 +1,849 @@ +/********************************************************** + 固件文件HalFirmware.c +*********************************************************** + 彭东 +**********************************************************/ +#include "BaseType.h" +#include "HalFirmware.h" +#include "HalSync.h" +#include "HalCPU.h" +#include "KrlLog.h" + + +const char* CosmosVersion = "Cosmos\n内核版本:00.01\n彭东 @ 构建于 "__DATE__ + " "__TIME__ + "\n"; + +private void DefGraphInit() +{ + DefGraph* kghp = &kdftgh; + machbstart_t* kmbsp = &kmachbsp; + HalMemset(kghp, 0, sizeof(DefGraph)); + SPinLockInit(&kghp->Lock); + kghp->Mode = kmbsp->mb_ghparm.mode; + kghp->X = kmbsp->mb_ghparm.X; + kghp->Y = kmbsp->mb_ghparm.Y; + kghp->FramPhyAddr = HalPAddrToVAddr((Addr)kmbsp->mb_ghparm.FramPhyAddr); + kghp->FvrmPhyAddr = HalPAddrToVAddr((Addr)kmbsp->mb_fvrmphyadr); + kghp->FvrmSZ = kmbsp->mb_fvrmsz; + kghp->OnePixBits = kmbsp->mb_ghparm.gh_onepixbits; + kghp->OnePixByte = kmbsp->mb_ghparm.gh_onepixbits / 8; + kghp->VBEModeNR = kmbsp->mb_ghparm.gh_vbemodenr; + kghp->Bank = kmbsp->mb_ghparm.Bank; + kghp->CurrDispBank = kmbsp->mb_ghparm.gh_curdipbnk; + kghp->NextBank = kmbsp->mb_ghparm.FvrmPhyAddr; + kghp->BankSZ = kmbsp->mb_ghparm.Banksz; + kghp->FontAddr = HalPAddrToVAddr((Addr)kmbsp->mb_bfontpadr); + kghp->FontSZ = kmbsp->mb_bfontsz; + kghp->FontHigh = 16; + kghp->LineSZ = 16 + 4; + kghp->DefFontPX = BGRA(0xff, 0xff, 0xff); + return; +} + +private Pixl SetDefFontPx(Pixl px) +{ + DefGraph* kghp = &kdftgh; + Pixl bkpx = kghp->DefFontPX; + kghp->DefFontPX = px; + return bkpx; +} + +private void SetNextCharsXY(U64 x, U64 y) +{ + DefGraph* kghp = &kdftgh; + kghp->NextCharsX = x; + kghp->NextCharsY = y; + return; +} + +private void SetCharsDXWFlush(U64 chardxw, U64 flush) +{ + kdftgh.CharDefXW = chardxw; + kdftgh.Flush = flush; + return; +} + +public void HalShowVersion() +{ + Pixl bkpx = SetDefFontPx(BGRA(0xff, 0, 0)); + KrlPrint(CosmosVersion); + KrlPrint("系统存在进程:%d个 系统空闲内存大小:%dMB\n", (UInt)osschedcls.scls_threadnr, (UInt)((memmgrob.mo_freepages << 12) >> 20)); + KrlPrint("系统处理器工作模式:%d位 系统物理内存大小:%dMB\n", (UInt)kmachbsp.mb_cpumode, (UInt)(kmachbsp.mb_memsz >> 20)); + SetDefFontPx(bkpx); + return; +} + +private void FillRect(Pixl pix, UInt x, UInt y, UInt tx, UInt ty) +{ + for (UInt i = y; i < y + ty; i++) + { + for (UInt j = x; j < x + tx; j++) + { + WritePixColor(&kdftgh, (U32)j, (U32)i, pix); + } + } + return; +} + +private void FillBitMAPFile(Char* bmfname) +{ + DefGraph* kghp = &kdftgh; + machbstart_t* kmbsp = &kmachbsp; + U64 fadr = 0, fsz = 0; + get_file_rvadrandsz(bmfname, kmbsp, &fadr, &fsz); + if (0 == fadr || 0 == fsz) + { + system_error("not bitmap file err\n"); + } + BMDBGR* bmdp; + U64 img = fadr + sizeof(BMFHead) + sizeof(BitMInfo); + bmdp = (BMDBGR* )((UInt)img); + Pixl pix; + int k = 0, l = 0; + for (int j = 768; j >= 0; j--, l++) + { + for (int i = 0; i < 1024; i++) + { + pix = BGRA(bmdp[k].bmd_r, bmdp[k].bmd_g, bmdp[k].bmd_b); + WritePixColor(kghp, i, j, pix); + k++; + } + } + FlushVideoRam(kghp); + return; +} + +private void SlouSreen(UInt hy) +{ + UInt x, y, ofx, ofy; + DefGraph* kghp = &kdftgh; + BGAGetXYOffset(kghp, &x, &y); + BGAGetVWH(kghp, &ofx, &ofy); + y += hy; + ofy += hy; + BGASetVWH(kghp, ofx, ofy); + BGASetXYOffset(kghp, x, y); + return; +} + +private void HalBackGround() +{ + DefGraph* kghp = &kdftgh; + machbstart_t* kmbsp = &kmachbsp; + U64 fadr = 0, fsz = 0; + get_file_rvadrandsz("desktop1.bmp", kmbsp, &fadr, &fsz); + if (0 == fadr || 0 == fsz) + { + system_error("Cosmos background fail"); + } + BMDBGR* bmdp; + U64 img = fadr + sizeof(BMFHead) + sizeof(BitMInfo); + bmdp = (BMDBGR*)((UInt)img); + Pixl pix; + int k = 0, l = 0; + for (int j = 768; j >= 0; j--, l++) + { + for (int i = 0; i < 1024; i++) + { + pix = BGRA(bmdp[k].bmd_r, bmdp[k].bmd_g, bmdp[k].bmd_b); + DRXWPixColor(kghp, i, j, pix); + k++; + } + } + HalShowVersion(); + return; +} + +public void HalLogo() +{ + DefGraph* kghp = &kdftgh; + machbstart_t* kmbsp = &kmachbsp; + U64 fadr = 0, fsz = 0; + get_file_rvadrandsz("logo.bmp", kmbsp, &fadr, &fsz); + if (0 == fadr || 0 == fsz) + { + system_error("logoerr"); + } + BMDBGR* bmdp; + U64 img = fadr + sizeof(BMFHead) + sizeof(BitMInfo); + bmdp = (BMDBGR* )((UInt)img); + Pixl pix; + int k = 0, l = 0; + for (int j = 617; j >= 153; j--, l++) + { + for (int i = 402; i < 622; i++) + { + pix = BGRA(bmdp[k].bmd_r, bmdp[k].bmd_g, bmdp[k].bmd_b); + DRXWPixColor(kghp, i, j, pix); + k++; + } + if (l > 205) + { + die(0x80); + } + } + return; +} + +public void BootVideoDeviceInit() +{ + DefGraph* kghp = &kdftgh; + + DefGraphInit(); + BGAInit(); + VBEInit(); + FillGraph(kghp, BGRA(0, 0, 0)); + SetCharsDXWFlush(0, 0); + HalBackGround(); + KrlLog(0, "图形显示初始化成功\n"); + // die(0x400); + return; +} + +private void BGAInit() +{ + DefGraph* kghp = &kdftgh; + if (kghp->gh_mode != BGAMODE) + { + return; + } + kghp->OpFunc.GOpRead = BGARead; + kghp->OpFunc.GOpWrite = BGAWrite; + kghp->OpFunc.GOpIoCtrl = BGAIoCtrl; + kghp->OpFunc.GOpFlush = BGAFlush; + kghp->OpFunc.GOpSetBank = BGASetBank; + kghp->OpFunc.GOpReadPix = BGAReadPix; + kghp->OpFunc.GOpWritePix = BGAWritePix; + kghp->OpFunc.GOpDXReadPix = BGADXReadPix; + kghp->OpFunc.GOpDXWritePix = BGADXWritePix; + kghp->OpFunc.GOpSetXY = BGASetXY; + kghp->OpFunc.GOpSetVWH = BGASetVWH; + kghp->OpFunc.GOpSetXYOffset = BGASetXYOffset; + kghp->OpFunc.GOpGetXY = BGAGetXY; + kghp->OpFunc.GOpGetVWH = BGAGetVWH; + kghp->OpFunc.GOpGetXYOffset = BGAGetXYOffset; + return; +} + +private void VBEInit() +{ + DefGraph* kghp = &kdftgh; + if (kghp->gh_mode != VBEMODE) + { + return; + } + kghp->OpFunc.GOpRead = VBERead; + kghp->OpFunc.GOpWrite = VBEWrite; + kghp->OpFunc.GOpIoCtrl = VBEIoCtrl; + kghp->OpFunc.GOpFlush = VBEFlush; + kghp->OpFunc.GOpSetBank = VBESetBank; + kghp->OpFunc.GOpReadpix = VBEReadPix; + kghp->OpFunc.GOpWritePix = VBEWritePix; + kghp->OpFunc.GOpDXReadPix = VBDXReadPix; + kghp->OpFunc.GOpDXWritePix = VBEDXWritePix; + kghp->OpFunc.GOpSetXY = VBESetXY; + kghp->OpFunc.GOpSetVWH = VBESetVWH; + kghp->OpFunc.GOpSetXYOffset = VBESetXYOffset; + kghp->OpFunc.GOpGetXY = VBEGetXY; + kghp->OpFunc.GOpGetVWH = VBEGetVWH; + kghp->OpFunc.GOpGetXYOffSet = VBEGetXYOffset; + return; +} + +private void FillGraph(DefGraph* kghp, Pixl pix) +{ + for (U64 y = 0; y < kghp->Y; y++) + { + for (U64 x = 0; x < kghp->X; x++) + { + WritePixColor(kghp, (U32)x, (U32)y, pix); + } + } + FlushVideoRam(kghp); + return; +} + +private void WritePixColor(DefGraph* kghp, U32 x, U32 y, Pixl pix) +{ + kghp->OpFunc.GOpWritePix(kghp, pix, x, y); + return; +} + +private void DRXWPixColor(DefGraph* kghp, U32 x, U32 y, Pixl pix) +{ + + kghp->OpFunc.GOpDXWritePix(kghp, pix, x, y); + return; +} + +private void FlushVideoRam(DefGraph* kghp) +{ + kghp->OpFunc.GOpFlush(kghp); + return; +} + +private U32 Utf8ToUnicode(UTF8* utf, int* retuib) +{ + U8 uhd = utf->UByte1, ubyt = 0; + U32 ucode = 0, tmpuc = 0; + if (0x80 > uhd) //0xbf&&uhd<=0xbf + { + ucode = utf->UByte1 & 0x7f; + *retuib = 1; + return ucode; + } + if (0xc0 <= uhd && uhd <= 0xdf) //0xdf + { + ubyt = utf->UByte1 & 0x1f; + tmpuc |= ubyt; + ubyt = utf->UByte2 & 0x3f; + ucode = (tmpuc << 6) | ubyt; + *retuib = 2; + return ucode; + } + if (0xe0 <= uhd && uhd <= 0xef) //0xef + { + ubyt = utf->UByte1 & 0x0f; + tmpuc |= ubyt; + ubyt = utf->UByte2 & 0x3f; + tmpuc <<= 6; + tmpuc |= ubyt; + ubyt = utf->UByte3 & 0x3f; + ucode = (tmpuc << 6) | ubyt; + *retuib = 3; + return ucode; + } + if (0xf0 <= uhd && uhd <= 0xf7) //0xf7 + { + ubyt = utf->UByte1 & 0x7; + tmpuc |= ubyt; + ubyt = utf->UByte2 & 0x3f; + tmpuc <<= 6; + tmpuc |= ubyt; + ubyt = utf->UByte3 & 0x3f; + tmpuc <<= 6; + tmpuc |= ubyt; + ubyt = utf->UByte4 & 0x3f; + ucode = (tmpuc << 6) | ubyt; + *retuib = 4; + return ucode; + } + if (0xf8 <= uhd && uhd <= 0xfb) //0xfb + { + ubyt = utf->UByte1 & 0x3; + tmpuc |= ubyt; + ubyt = utf->UByte2 & 0x3f; + tmpuc <<= 6; + tmpuc |= ubyt; + ubyt = utf->UByte3 & 0x3f; + tmpuc <<= 6; + tmpuc |= ubyt; + ubyt = utf->UByte4 & 0x3f; + tmpuc <<= 6; + tmpuc |= ubyt; + ubyt = utf->UByte5 & 0x3f; + ucode = (tmpuc << 6) | ubyt; + *retuib = 5; + return ucode; + } + if (0xfc <= uhd && uhd <= 0xfd) //0xfd + { + ubyt = utf->UByte1 & 0x1; + tmpuc |= ubyt; + ubyt = utf->UByte2 & 0x3f; + tmpuc <<= 6; + tmpuc |= ubyt; + ubyt = utf->UByte3 & 0x3f; + tmpuc <<= 6; + tmpuc |= ubyt; + ubyt = utf->UByte4 & 0x3f; + tmpuc <<= 6; + tmpuc |= ubyt; + ubyt = utf->UByte5 & 0x3f; + tmpuc <<= 6; + tmpuc |= ubyt; + ubyt = utf->UByte6 & 0x3f; + ucode = (tmpuc << 6) | ubyt; + *retuib = 6; + return ucode; + } + *retuib = 0; + return 0; +} + +private U8* GetCharsInfo(DefGraph* kghp, U32 unicode, int* retchwx, int* retchhx, int* retlinb) +{ + FontData* fntp = (FontData* )((UInt)kghp->FontAddr); + *retchwx = fntp[unicode].FontWidth; + *retchhx = fntp[unicode].FontHigh; + *retlinb = fntp[unicode].FontByteSZ; + + return (U8*)(&(fntp[unicode].FontCharMap[0])); +} + +public void PutPixOneChar(DefGraph* kghp, U32 unicode, Pixl pix) +{ + int y = 0, chwx = 0, chhx = 0, linb = 0; + U8* charyp = NULL; + if (unicode == 10) + { + kghp->NextCharsX = 0; + if ((kghp->NextCharsY + kghp->LineSZ) > (kghp->Y - kghp->FontHigh)) + { + kghp->NextCharsY = 0; + HalBackGround(); + goto ret; + } + kghp->NextCharsY += kghp->LineSZ; + goto ret; + } + charyp = GetCharsInfo(kghp, unicode, &chwx, &chhx, &linb); + if (charyp == NULL) + { + goto ret; + } + if ((kghp->NextCharsX + chwx) > (kghp->X - chwx)) + { + kghp->NextCharsX = 0; + if ((kghp->NextCharsY + kghp->LineSZ) > (kghp->Y - kghp->FontHigh)) + { + kghp->NextCharsY = 0; + } + else + { + kghp->NextCharsY += kghp->LineSZ; + } + } + U32 wpx = (U32)kghp->NextCharsX, wpy = (U32)kghp->NextCharsY; + + for (int hx = 0; hx < chhx; hx++) + { + for (int btyi = 0, x = 0; btyi < linb; btyi++) + { + U8 bitmap = charyp[hx * linb + btyi]; + if (bitmap == 0) + { + x += 8; + continue; + } + for (int bi = 7; bi >= 0; bi--) + { + if (x >= chwx) + { + break; + } + if (((bitmap >> bi) & 1) == 1) + { + WritePixColor(kghp, wpx + x, wpy + y, pix); + } + x++; + } + } + y++; + } + kghp->NextCharsX += (U64)chwx; + return; +} + +public void DRXPutPixOneChar(DefGraph* kghp, U32 unicode, Pixl pix) +{ + int y = 0, chwx = 0, chhx = 0, linb = 0; + U8* charyp = NULL; + if (unicode == 10) + { + kghp->NextCharsX = 0; + if ((kghp->NextCharsY + kghp->LineSZ) > (kghp->Y - kghp->FontHigh)) + { + kghp->NextCharsY = 0; + HalBackGround(); + goto ret; + } + kghp->NextCharsY += kghp->LineSZ; + goto ret; + } + charyp = GetCharsInfo(kghp, unicode, &chwx, &chhx, &linb); + if (charyp == NULL) + { + goto ret; + } + if ((kghp->NextCharsX + chwx) > (kghp->X - chwx)) + { + kghp->NextCharsX = 0; + if ((kghp->NextCharsY + kghp->LineSZ) > (kghp->Y - kghp->FontHigh)) + { + kghp->NextCharsY = 0; + } + else + { + kghp->NextCharsY += kghp->LineSZ; + } + } + U32 wpx = (U32)kghp->NextCharsX, wpy = (U32)kghp->NextCharsY; + + for (int hx = 0; hx < chhx; hx++) + { + for (int btyi = 0, x = 0; btyi < linb; btyi++) + { + U8 bitmap = charyp[hx * linb + btyi]; + if (bitmap == 0) + { + x += 8; + continue; + } + for (int bi = 7; bi >= 0; bi--) + { + if (x >= chwx) + { + break; + } + if (((bitmap >> bi) & 1) == 1) + { + DRXWPixColor(kghp, wpx + x, wpy + y, pix); + } + x++; + } + } + y++; + } + kghp->NextCharsX += (U64)chwx; + + return; +} + +public void HalDefStringWrite(Char* buf) +{ + int chinx = 0; + int chretnext = 0; + U32 uc = 0; + DefGraph* kghp = &kdftgh; + Pixl pix = kghp->DefFontPX; + IF_NULL_RETURN(buf); + while (buf[chinx] != 0) + { + uc = Utf8ToUnicode((UTF8* )(&buf[chinx]), &chretnext); + chinx += chretnext; + if (kghp->gh_chardxw == 1) + { + PutPixOneChar(kghp, uc, pix); + } + else + { + DRXPutPixOneChar(kghp, uc, pix); + } + } + if (kghp->gh_flush == 1) + { + FlushVideoRam(kghp); + } + return; +} + +private void BGAWriteReg(U16 index, U16 data) +{ + out_u16(VBE_DISPI_IOPORT_INDEX, index); + out_u16(VBE_DISPI_IOPORT_DATA, data); + return; +} + +private U16 BGAReadReg(U16 index) +{ + out_u16(VBE_DISPI_IOPORT_INDEX, index); + return in_u16(VBE_DISPI_IOPORT_DATA); +} + +private size_t BGARead(void* ghpdev, void* outp, size_t rdsz) +{ + //DefGraph* kghp=(DefGraph*)ghpdev; + return rdsz; +} + +private size_t BGAWrite(void* ghpdev, void* inp, size_t wesz) +{ + //DefGraph* kghp=(DefGraph*)ghpdev; + return wesz; +} + +private SInt BGAIoCtrl(void* ghpdev, void* outp, UInt iocode) +{ + return -1; +} + +private U64* GetVRamAddrInBank(void* ghpdev) +{ + DefGraph* kghp = (DefGraph* )ghpdev; + U64* d = (U64* )((UInt)(kghp->FramPhyAddr + (kghp->X * kghp->Y * kghp->FvrmPhyAddr * kghp->FvrmPhyAddr))); + + return d; +} + +private void BGADispNextBank(void* ghpdev) +{ + DefGraph* kghp = (DefGraph* )ghpdev; + U16 h = (U16)(kghp->Y * kghp->NextBank + 1); + U16 ofy = (U16)(kghp->Y * (kghp->FvrmPhyAddr)); + BGAWriteReg(VBE_DISPI_INDEX_VIRT_HEIGHT, h); + BGAWriteReg(VBE_DISPI_INDEX_Y_OFFSET, ofy); + kghp->gh_curdipbnk = kghp->FvrmPhyAddr; + kghp->FvrmPhyAddr++; + if (kghp->FvrmPhyAddr > kghp->Bank) + { + kghp->FvrmPhyAddr = 0; + } + return; +} + +private void BGAFlush(void* ghpdev) +{ + DefGraph* kghp = (DefGraph* )ghpdev; + + U64* s = (U64* )((UInt)kghp->FvrmPhyAddr); + U64* d = GetVRamAddrInBank(kghp); //(U64*)kghp->FramPhyAddr; + U64 i = 0, j = 0; + U64 e = kghp->X * kghp->Y * kghp->OnePixByte; + //U64 k=e/8; + for (; i < e; i += 8) + { + d[j] = s[j]; + j++; + } + BGADispNextBank(kghp); + return; +} + +private SInt BGASetBank(void* ghpdev, SInt bnr) +{ + return -1; +} + +private Pixl BGAReadPix(void* ghpdev, UInt x, UInt y) +{ + return 0; +} + +private void BGAWritePix(void* ghpdev, Pixl pix, UInt x, UInt y) +{ + DefGraph* kghp = (DefGraph* )ghpdev; + U8* p24bas; + if (kghp->gh_onepixbits == 24) + { + U64 p24adr = (x + (y * kghp->X)) * 3; + p24bas = (U8* )((UInt)(p24adr + kghp->FvrmPhyAddr)); + p24bas[0] = (U8)(pix); + p24bas[1] = (U8)(pix >> 8); + p24bas[2] = (U8)(pix >> 16); + return; + } + U32* phybas = (U32* )((UInt)kghp->FvrmPhyAddr); + phybas[x + (y * kghp->X)] = pix; + return; +} + +private Pixl BGADXReadPix(void* ghpdev, UInt x, UInt y) +{ + return 0; +} + +private void BGADXWritePix(void* ghpdev, Pixl pix, UInt x, UInt y) +{ + DefGraph* kghp = (DefGraph* )ghpdev; + U8* p24bas; + if (kghp->gh_onepixbits == 24) + { + U64 p24adr = (x + (y * kghp->X)) * 3 * kghp->gh_curdipbnk; + p24bas = (U8* )((UInt)(p24adr + kghp->FramPhyAddr)); + p24bas[0] = (U8)(pix); + p24bas[1] = (U8)(pix >> 8); + p24bas[2] = (U8)(pix >> 16); + return; + } + U32* phybas = (U32* )((UInt)(kghp->FramPhyAddr + (kghp->X * kghp->Y * kghp->FvrmPhyAddr * kghp->gh_curdipbnk))); + phybas[x + (y * kghp->X)] = pix; + return; +} + +private SInt BGASetXY(void* ghpdev, UInt x, UInt y) +{ + + BGAWriteReg(VBE_DISPI_INDEX_XRES, (U16)(x)); + BGAWriteReg(VBE_DISPI_INDEX_YRES, (U16)(y)); + + return 0; +} + +private SInt BGASetVWH(void* ghpdev, UInt vwt, UInt vhi) +{ + + BGAWriteReg(VBE_DISPI_INDEX_VIRT_WIDTH, (U16)vwt); + BGAWriteReg(VBE_DISPI_INDEX_VIRT_HEIGHT, (U16)vhi); + return 0; +} + +private SInt BGASetXYOffset(void* ghpdev, UInt xoff, UInt yoff) +{ + BGAWriteReg(VBE_DISPI_INDEX_X_OFFSET, (U16)(xoff)); + BGAWriteReg(VBE_DISPI_INDEX_Y_OFFSET, (U16)(yoff)); + return 0; +} + +private SInt BGAGetXY(void* ghpdev, UInt* rx, UInt* ry) +{ + if (rx == NULL || ry == NULL) + { + return -1; + } + U16 retx, rety; + retx = BGAReadReg(VBE_DISPI_INDEX_XRES); + rety = BGAReadReg(VBE_DISPI_INDEX_YRES); + *rx = (UInt)retx; + *ry = (UInt)rety; + return 0; +} + +private SInt BGAGetVWH(void* ghpdev, UInt* rvwt, UInt* rvhi) +{ + if (rvwt == NULL || rvhi == NULL) + { + return -1; + } + U16 retwt, rethi; + retwt = BGAReadReg(VBE_DISPI_INDEX_VIRT_WIDTH); + rethi = BGAReadReg(VBE_DISPI_INDEX_VIRT_HEIGHT); + *rvwt = (UInt)retwt; + *rvhi = (UInt)rethi; + return 0; +} + +private SInt BGAGetXYOffset(void* ghpdev, UInt* rxoff, UInt* ryoff) +{ + if (rxoff == NULL || ryoff == NULL) + { + return -1; + } + U16 retxoff, retyoff; + retxoff = BGAReadReg(VBE_DISPI_INDEX_X_OFFSET); + retyoff = BGAReadReg(VBE_DISPI_INDEX_Y_OFFSET); + *rxoff = (UInt)retxoff; + *ryoff = (UInt)retyoff; + return 0; +} + +private size_t VBERead(void* ghpdev, void* outp, size_t rdsz) +{ + return rdsz; +} + +private size_t VBEWrite(void* ghpdev, void* inp, size_t wesz) +{ + return wesz; +} + +private SInt VBEIoCtrl(void* ghpdev, void* outp, UInt iocode) +{ + return -1; +} + +private void VBEFlush(void* ghpdev) +{ + DefGraph* kghp = (DefGraph* )ghpdev; + + U64* s = (U64* )((UInt)kghp->FvrmPhyAddr); + U64* d = (U64* )((UInt)kghp->FramPhyAddr); + U64 i = 0, j = 0; + U64 e = kghp->X * kghp->Y * kghp->FvrmPhyAddr; + for (; i < e; i += 8) + { + d[j] = s[j]; + j++; + } + return; +} + +private SInt VBESetBank(void* ghpdev, SInt bnr) +{ + return -1; +} + +private Pixl VBEReadPix(void* ghpdev, UInt x, UInt y) +{ + return 0; +} + +private void VBEWritePix(void* ghpdev, Pixl pix, UInt x, UInt y) +{ + DefGraph* kghp = (DefGraph* )ghpdev; + U8* p24bas; + if (kghp->gh_onepixbits == 24) + { + U64 p24adr = (x + (y * kghp->X)) * 3; + p24bas = (U8* )((UInt)(p24adr + kghp->FvrmPhyAddr)); + p24bas[0] = (U8)(pix); + p24bas[1] = (U8)(pix >> 8); + p24bas[2] = (U8)(pix >> 16); + return; + } + U32* phybas = (U32* )((UInt)kghp->FvrmPhyAddr); + phybas[x + (y * kghp->X)] = pix; + return; +} + +private Pixl VBDXReadPix(void* ghpdev, UInt x, UInt y) +{ + + return 0; +} + +private void VBEDXWritePix(void* ghpdev, Pixl pix, UInt x, UInt y) +{ + DefGraph* kghp = (DefGraph* )ghpdev; + U8* p24bas; + if (kghp->gh_onepixbits == 24) + { + U64 p24adr = (x + (y* kghp->X))* 3; + p24bas = (U8* )((UInt)(p24adr + kghp->FramPhyAddr)); + p24bas[0] = (U8)(pix); + p24bas[1] = (U8)(pix >> 8); + p24bas[2] = (U8)(pix >> 16); + return; + } + U32* phybas = (U32* )((UInt)kghp->FramPhyAddr); + phybas[x + (y* kghp->X)] = pix; + return; +} + +private SInt VBESetXY(void* ghpdev, UInt x, UInt y) +{ + return -1; +} + +private SInt VBESetVWH(void* ghpdev, UInt vwt, UInt vhi) +{ + return -1; +} + +private SInt VBESetXYOffset(void* ghpdev, UInt xoff, UInt yoff) +{ + return -1; +} + +private SInt VBEGetXY(void* ghpdev, UInt* rx, UInt* ry) +{ + return -1; +} + +private SInt VBEGetVWH(void* ghpdev, UInt* rvwt, UInt* rvhi) +{ + return -1; +} + +private SInt VBEGetXYOffset(void* ghpdev, UInt* rxoff, UInt* ryoff) +{ + + return -1; +} + +public Bool HalFirmwareInit() +{ + BootVideoDeviceInit(); + return; +} diff --git a/Hal/X86_64/HalIPC.c b/Hal/X86_64/HalIPC.c new file mode 100644 index 0000000..aa71e44 --- /dev/null +++ b/Hal/X86_64/HalIPC.c @@ -0,0 +1,12 @@ +/********************************************************** + 底层IPC通信文件HalIPC.c +*********************************************************** + 彭东 +**********************************************************/ +#include "BaseType.h" +#include "HalIPC.h" + +public Bool HalIPCInit() +{ + return TRUE; +} diff --git a/Hal/X86_64/HalInitEntry.asm b/Hal/X86_64/HalInitEntry.asm new file mode 100755 index 0000000..35724bb --- /dev/null +++ b/Hal/X86_64/HalInitEntry.asm @@ -0,0 +1,107 @@ +;***************************************************************************** +;* 内核初始化入口文件HalInitEntry.asm * +;* 彭东 * +;***************************************************************************** +%define MBSP_ADR 0x100000 +%define IA32_EFER 0C0000080H +%define MSR_IA32_MISC_ENABLE 0x000001a0 +%define PML4T_BADR 0x1000000 +%define KRLVIRADR 0xffff800000000000 +%define KINITSTACK_OFF 16 +global InitEntryStart +extern HalBootStart + +[section .start.text] +[BITS 32] +InitEntryStart: + cli + mov ax, 0x10 + mov ds, ax + mov es, ax + mov ss, ax + mov fs, ax + mov gs, ax + lgdt [EGDTPTR] +;开启 PAE + mov eax, cr4 + bts eax, 5 ; CR4.PAE = 1 + mov cr4, eax + mov eax, PML4T_BADR + mov cr3, eax +;开启SSE + mov eax, cr4 + bts eax, 9 ; CR4.OSFXSR = 1 + bts eax, 10 ; CR4.OSXMMEXCPT = 1 + mov cr4, eax +;开启 64bits long-mode + mov ecx, IA32_EFER + rdmsr + bts eax, 8 ; IA32_EFER.LME =1 + wrmsr + + mov ecx, MSR_IA32_MISC_ENABLE + rdmsr + btr eax, 6 ; L3Cache =1 + wrmsr + +;开启 PE 和 paging + mov eax, cr0 + bts eax, 0 ; CR0.PE =1 + bts eax, 31 + +;开启 CACHE + btr eax, 29 ;CR0.NW=0 + btr eax, 30 ;CR0.CD=0 CACHE + + mov cr0, eax ; IA32_EFER.LMA = 1 + jmp 08:Entry64 +[BITS 64] +Entry64: + mov ax, 0x10 + mov ds, ax + mov es, ax + mov ss, ax + mov fs, ax + mov gs, ax + xor rax, rax + xor rbx, rbx + xor rbp, rbp + xor rcx, rcx + xor rdx, rdx + xor rdi, rdi + xor rsi, rsi + xor r8, r8 + xor r9, r9 + xor r10, r10 + xor r11, r11 + xor r12, r12 + xor r13, r13 + xor r14, r14 + xor r15, r15 + mov rbx, MBSP_ADR + mov rax, KRLVIRADR + mov rcx, [rbx+KINITSTACK_OFF] + add rax, rcx + xor rcx, rcx + xor rbx, rbx + mov rsp, rax + push 0 + push 0x8 + mov rax, HalBootStart ;调用内核主函数 + push rax + dw 0xcb48 + jmp $ + + +[section .start.data] +[BITS 32] +EX64GDT: +ENULLX64DSC: dq 0 +EKRNLC64DSC: dq 0x0020980000000000 ; 64-bit 内核代码段 +EKRNLD64DSC: dq 0x0000920000000000 ; 64-bit 内核数据段 + +EUSERC64DSC: dq 0x0020f80000000000 ; 64-bit 用户代码段 +EUSERD64DSC: dq 0x0000f20000000000 ; 64-bit 用户数据段 +EGDTLEN equ $ - ENULLX64DSC ; GDT长度 +EGDTPTR: dw EGDTLEN - 1 ; GDT界限 + dq EX64GDT \ No newline at end of file diff --git a/Hal/X86_64/HalInterface.c b/Hal/X86_64/HalInterface.c new file mode 100644 index 0000000..c9f0cef --- /dev/null +++ b/Hal/X86_64/HalInterface.c @@ -0,0 +1,34 @@ + +/********************************************************** + 硬件抽象层接口文件HalInterface.c +*********************************************************** + 彭东 +**********************************************************/ +#include "BaseType.h" +#include "KrlMmManage.h" +#include "HalBoot.h" +#include "HalInterface.h" +public PMSAD* HalExPGetKrlOnePMSAD() +{ + return NULL; +} + +public Bool HalExPPutKrlOnePMSAD(PMSAD* msad) +{ + return FALSE; +} + +public MachStartInfo* HalExPGetMachStartInfoAddr() +{ + return HalGetMachStartInfoAddr(); +} + +public Addr HalExPBootAllocMem(Size size) +{ + return HalBootAllocMem(size); +} + +public E820Map* HalExPBootGetNextE820() +{ + return HalBootGetNextE820(); +} \ No newline at end of file diff --git a/Hal/X86_64/HalInterrupt.c b/Hal/X86_64/HalInterrupt.c new file mode 100644 index 0000000..6901ca0 --- /dev/null +++ b/Hal/X86_64/HalInterrupt.c @@ -0,0 +1,81 @@ +/********************************************************** + hal层中断处理文件halInterrupt.c +*********************************************************** + 彭东 +**********************************************************/ +#include "BaseType.h" +#include "HalInterrupt.h" + +DefinedCPUInterData(IERSDT, IERSDTable); + +private Bool IERSDInit(IERSD* init, U32 flags, U32 status, UInt prity, UInt internr) +{ + if(NULL == init) + { + return FALSE; + } + HalSPinLockInit(&init->Lock); + init->Flags = flags; + init->Status = status; + init->Prity = prity; + init->InterNR = internr; + init->Deep = 0; + init->Count = 0; + ListInit(&init->IODLists); + init->IODNR = 0; + ListInit(&init->IODThreadLists); + init->IODThreadNR = 0; + init->OneIODThread = NULL; + init->RBTreeRoot = NULL; + init->MSGMPool = NULL; + init->Priv = NULL; + init->Ext = NULL; + return TRUE; +} + +private Bool IERSDTInit() +{ + for(UInt i = 0; i < IERSD_MAX; i++) + { + IERSDInit(&IERSDTable.IERSDArr[i], 0, 0, 0, 0); + } + return TRUE; +} + +private Bool IODInit(IOD* init, U32 flags, IERSD* parent, void* device, IODCallBack callbackfunc) +{ + if(NULL == init) + { + return; + } + ListInit(&init->Lists); + ListInit(&init->InDeviceLists); + init->Flags = flags; + init->Parent = parent; + init->Device = device; + init->Count = 0; + init->CallBackFunc = callbackfunc; + return TRUE; +} + + +public void HalInterDistributor(UInt internr, void* kistacktop) +{ + return; +} + +public void HalFaultDistributor(UInt faultnr, void* kfstacktop) +{ + return; +} + +public void HalOSAPIDistributor(UInt apinr, void* kistacktop) +{ + return; +} + +public Bool HalInterruptInit() +{ + IERSDTInit(); + return TRUE; +} \ No newline at end of file diff --git a/Hal/X86_64/HalMMU.c b/Hal/X86_64/HalMMU.c new file mode 100644 index 0000000..cf8092c --- /dev/null +++ b/Hal/X86_64/HalMMU.c @@ -0,0 +1,1251 @@ +/********************************************************** + 内存mmu文件HalMMU.c +*********************************************************** + 彭东 +**********************************************************/ +#include "BaseType.h" +#include "List.h" +#include "HalSync.h" +#include "HalCPU.h" +#include "HalMMU.h" +#include "HalInterface.h" +#include "KrlMmManage.h" + +public void CR3Init(CR3* init) +{ + if(NULL == init) + { + return; + } + init->Entry = 0; + return; +} + +public void MMUInit(MMU* init) +{ + if(NULL == init) + { + return; + } + + SPinlockInit(&init->Lock); + init->Status = 0; + init->Flags = 0; + init->TDireArrPtr = NULL; + CR3Init(&init->Cr3); + ListInit(&init->TDirHead); + ListInit(&init->SDirHead); + ListInit(&init->IDirHead); + ListInit(&init->MDirHead); + init->TDirMsaNR = 0; + init->SDirMsaNR = 0; + init->IDirMsaNR = 0; + init->MDirMsaNR = 0; + return; +} + +private UInt TDireIndex(Addr vaddr) +{ + return (UInt)((vaddr >> TDIRE_IV_RSHTBIT) & TDIRE_IV_BITMASK); +} + +private UInt SDireIndex(Addr vaddr) +{ + return (UInt)((vaddr >> SDIRE_IV_RSHTBIT) & SDIRE_IV_BITMASK); +} + +private UInt IDireIndex(Addr vaddr) +{ + return (UInt)((vaddr >> IDIRE_IV_RSHTBIT) & IDIRE_IV_BITMASK); +} + +private UInt MDireIndex(Addr vaddr) +{ + return (UInt)((vaddr >> MDIRE_IV_RSHTBIT) & MDIRE_IV_BITMASK); +} + + +private void TDireArrInit(TDireArr* init) +{ + if(NULL == init) + { + return; + } + HalMemSet((void*)init, 0, sizeof(TDireArr)); + return; +} + +private void SDireArrInit(SDireArr* init) +{ + if(NULL == init) + { + return; + } + HalMemSet((void*)init, 0, sizeof(SDireArr)); + return; +} + +private void IDireArrInit(IDireArr* init) +{ + if(NULL == init) + { + return; + } + HalMemSet((void*)init, 0, sizeof(IDireArr)); + return; +} + +private void MDireArrInit(MDireArr* init) +{ + if(NULL == init) + { + return; + } + HalMemSet((void*)init, 0, sizeof(MDireArr)); + return; +} + +private Bool SDireArrIsAllZero(SDireArr* sdirearr) +{ + for(UInt i = 0; i < SDIRE_MAX; i++) + { + if(0 != sdirearr->SDEArr[i].SEntry) + { + return FALSE; + } + } + return TRUE; +} + +private Bool SDireIsHave(TDire* tdire) +{ + if(0 < tdire->TFlags.TSDIRBit) + { + return TRUE; + } + return FALSE; +} + +private Bool SDireIsPresence(TDire* tdire) +{ + if(1 == tdire->TFlags.TPBit) + { + return TRUE; + } + return FALSE; +} + +private Addr SDireRetPAddr(TDire* tdire) +{ + return (Addr)(tdire->TFlags.TSDIRBit << SDIRE_PADR_LSHTBIT); +} + +private Addr SDireRetVAddr(TDire* tdire) +{ + return HalPAddrToVAddr(SDireRetPAddr(tdire)); +} + +private SDireArr* TDireRetSDireArr(TDire* tdire) +{ + return (SDireArr*)(SDireRetVAddr(tdire)); +} + +private Bool IDireArrIsAllZero(IDireArr* idirearr) +{ + for(UInt i = 0; i < IDIRE_MAX; i++) + { + if(0 != idirearr->IDEArr[i].IEntry) + { + return FALSE; + } + } + return TRUE; +} + +private Bool IDireIsHave(SDire* sdire) +{ + if(0 < sdire->SFlags.SIDIRBit) + { + return TRUE; + } + return FALSE; +} + +private Bool IDireIsPresence(SDire* sdire) +{ + if(1 == sdire->SFlags.SPBit) + { + return TRUE; + } + return FALSE; +} + +private Addr IDireRetPAddr(SDire* sdire) +{ + return (Addr)(sdire->SFlags.SIDIRBit << IDIRE_PADR_LSHTBIT); +} + +private Addr IDireRetVAddr(SDire* sdire) +{ + return HalPAddrToVAddr(IDireRetPAddr(sdire)); +} + +private IDireArr* SDireRetIDireArr(SDire* sdire) +{ + return (IDireArr*)(IDireRetVAddr(sdire)); +} + +private Bool MDireArrIsAllZero(MDireArr* mdirearr) +{ + for(UInt i = 0; i < MDIRE_MAX; i++) + { + if(0 != mdirearr->MDEArr[i].MEntry) + { + return FALSE; + } + } + return TRUE; +} + +private Bool MDireIsHave(IDire* idire) +{ + if(0 < idire->IFlags.IMDIRBit) + { + return TRUE; + } + return FALSE; +} + +private Bool MDireIsPresence(IDire* idire) +{ + if(1 == idire->IFlags.IPBit) + { + return TRUE; + } + return FALSE; +} + +private Addr MDireRetPAddr(IDire* idire) +{ + return (Addr)(idire->IFlags.IMDIRBit << MDIRE_PADR_LSHTBIT); +} + +private Addr MDireRetVAddr(IDire* idire) +{ + return HalPAddrToVAddr(MDireRetPAddr(idire)); +} + +private MDireArr* IDireRetMDireArr(IDire* idire) +{ + return (MDireArr*)(MDireRetVAddr(idire)); +} + +private Bool MMUPMSADIsHave(MDire* mdire) +{ + if(0 < mdire->MFlags.MMSABit) + { + return TRUE; + } + return FALSE; +} + +private Bool MMUPMSADIsPresence(MDire* mdire) +{ + if(1 == mdire->MFlags.MPBit) + { + return TRUE; + } + return FALSE; +} + +private Addr MMUPMSADRetPAddr(MDire* mdire) +{ + return (Addr)(mdire->MFlags.MMSABit << MSA_PADR_LSHTBIT); +} + +private PMSAD* MMUNewTDireArr(MMU* mmulocked) +{ + TDireArr* tdirearr = NULL; + PMSAD* msad = NULL; + if(NULL == mmulocked) + { + return NULL; + } + + msad = HalExPGetKrlOnePMSAD(); + if(NULL == msad) + { + return NULL; + } + + tdirearr = (TDireArr*)PMSADRetVaddr(msa); + + TDireArrInit(tdirearr); + + ListAdd(&msad->Lists, &mmulocked->TDirHead); + mmulocked->TDirMsaNR++; + mmulocked->TDireArrPtr = tdirearr; + + return msad; +} + +private Bool MMUDelTDireArr(MMU* mmulocked, TDireArr* tdirearr, PMSAD* msad) +{ + List* pos; + PMSAD* tmpmsad; + Addr tblphyadr; + if(NULL == mmulocked || NULL == tdirearr) + { + return FALSE; + } + + tblphyadr = HalVAddrToPAddr((Addr)tdirearr); + + if(NULL != msad) + { + if(PMSADRetPAddr(msad) == tblphyadr) + { + ListDel(&msad->Lists); + if(HalExPPutKrlOnePMSAD(msad) == FALSE) + { + system_error("mmu_del_tdirearr err\n"); + return FALSE; + } + mmulocked->TDirMsaNR--; + return TRUE; + } + } + ListForEach(pos, &mmulocked->TDirHead) + { + tmpmsad = ListEntry(pos, PMSAD, Lists); + if(PMSADRetPAddr(tmpmsad) == tblphyadr) + { + ListDel(&tmpmsad->Lists); + if(HalExPPutKrlOnePMSAD(tmpmsad) == FALSE) + { + system_error("mmu_del_tdirearr err\n"); + return FALSE; + } + mmulocked->TDirMsaNR--; + return TRUE; + } + } + return FALSE; +} + +private PMSAD* MMUNewSDireArr(MMU* mmulocked) +{ + SDireArr* sdirearr = NULL; + PMSAD* msad = NULL; + if(NULL == mmulocked) + { + return NULL; + } + + msad = HalExPGetKrlOnePMSAD(); + if(NULL == msad) + { + return NULL; + } + + sdirearr = (SDireArr*)PMSADRetVAddr(msad); + + SDireArrInit(sdirearr); + + ListAdd(&msad->Lists, &mmulocked->SDirHead); + mmulocked->SDirMsaNR++; + return msad; +} + +private Bool MMUDelSDireArr(MMU* mmulocked, SDireArr* sdirearr, PMSAD* msad) +{ + List* pos; + PMSAD* tmpmsad; + Addr tblphyadr; + if(NULL == mmulocked || NULL == sdirearr) + { + return FALSE; + } + + tblphyadr = HalVAddrToPAddr((Addr)sdirearr); + + if(NULL != msad) + { + if(PMSADRetPAddr(msad) == tblphyadr) + { + ListDel(&msad->Lists); + if(HalExPPutKrlOnePMSAD(msad) == FALSE) + { + system_error("mmu_del_tdirearr err\n"); + return FALSE; + } + mmulocked->SDirMsaNR--; + return TRUE; + } + } + ListForEach(pos, &mmulocked->mud_sdirhead) + { + tmpmsad = ListEntry(pos, PMSAD, Lists); + if(PMSADRetPAddr(tmpmsa) == tblphyadr) + { + list_del(&tmpmsad->Lists); + if(HalExPPutKrlOnePMSAD(tmpmsad) == FALSE) + { + system_error("mmu_del_tdirearr err\n"); + return FALSE; + } + mmulocked->SDirMsaNR--; + return TRUE; + } + } + return FALSE; +} + +private PMSAD* MMUNewIDireArr(MMU* mmulocked) +{ + IDireArr* idirearr = NULL; + PMSAD* msad = NULL; + + if(NULL == mmulocked) + { + return NULL; + } + + msad = HalExPGetKrlOnePMSAD(); + if(NULL == msad) + { + return NULL; + } + + idirearr = (IDireArr*)PMSADRetVAddr(msad); + + IDireArrInit(idirearr); + + ListAdd(&msad->Lists, &mmulocked->IDirHead); + mmulocked->IDirMsaNR++; + + return msad; +} + +private Bool MMUDelIDireArr(MMU* mmulocked, IDireArr* idirearr, PMSAD* msad) +{ + List* pos; + PMSAD* tmpmsad; + Addr tblphyadr; + + if(NULL == mmulocked || NULL == idirearr) + { + return FALSE; + } + + tblphyadr = HalVAddrToPAddr((Addr)idirearr); + + if(NULL != msad) + { + if(PMSADRetPAddr(msad) == tblphyadr) + { + ListDel(&msad->Lists); + if(HalExPPutKrlOnePMSAD(msad) == FALSE) + { + system_error("mmu_del_tdirearr err\n"); + return FALSE; + } + mmulocked->IDirMsaNR--; + return TRUE; + } + } + ListForEach(pos, &mmulocked->IDirHead) + { + tmpmsad = ListEntry(pos, PMSAD, Lists); + if(PMSADRetPAddr(tmpmsad) == tblphyadr) + { + ListDel(&tmpmsad->Lists); + if(HalExPPutKrlOnePMSAD(tmpmsad) == FALSE) + { + system_error("mmu_del_tdirearr err\n"); + return FALSE; + } + mmulocked->IDirMsaNR--; + return TRUE; + } + } + return FALSE; +} + +private PMSAD* MMUNewMDireArr(MMU* mmulocked) +{ + MDireArr* mdirearr = NULL; + PMSAD* msad = NULL; + + if(NULL == mmulocked) + { + return NULL; + } + + msad = HalExPGetKrlOnePMSAD(); + if(NULL == msad) + { + return NULL; + } + + mdirearr = (MDireArr*)PMSADRetVAddr(msad); + MDireArrInit(mdirearr); + + ListAdd(&msad->Lists, &mmulocked->MDirHead); + mmulocked->MDirMsaNR++; + + return msad; +} + +private Bool MMUDelMDireArr(MMU* mmulocked, MDireArr* mdirearr, PMSAD* msad) +{ + List* pos; + PMSAD* tmpmsad; + Addr tblphyadr; + + if(NULL == mmulocked || NULL == mdirearr) + { + return FALSE; + } + + tblphyadr = HalVAddrToPAddr((Addr)mdirearr); + + if(NULL != msad) + { + if(PMSADRetPAddr(msad) == tblphyadr) + { + ListDel(&msad->Lists); + if(HalExPPutKrlOnePMSAD(msad) == FALSE) + { + system_error("mmu_del_tdirearr err\n"); + return FALSE; + } + mmulocked->MDirMsaNR--; + return TRUE; + } + } + ListForEach(pos, &mmulocked->MDirHead) + { + tmpmsad = ListEntry(pos, PMSAD, Lists); + if(PMSADRetPAddr(tmpmsad) == tblphyadr) + { + ListDel(&tmpmsad->Lists); + if(HalExPPutKrlOnePMSAD(tmpmsad) == FALSE) + { + system_error("mmu_del_tdirearr err\n"); + return FALSE; + } + mmulocked->MDirMsaNR--; + return TRUE; + } + } + return FALSE; +} + +private Addr MMUUnTranslationPMSAD(MMU* mmulocked, MDireArr* mdirearr, Addr vaddr) +{ + UInt mindex; + MDire mdire; + Addr retadr; + if(NULL == mmulocked || NULL == mdirearr) + { + return NULL; + } + + mindex = MDireIndex(vaddr); + + mdire = mdirearr->MDEArr[mindex]; + if(MMUPMSADIsHave(&mdire) == FALSE) + { + return NULL; + } + + retadr = MMUPMSADRetPAddr(&mdire); + + mdirearr->MDEArr[mindex].MEntry = 0; + return retadr; +} + +private Bool MMUTranslationPMSAD(MMU* mmulocked, MDireArr* mdirearr, Addr vaddr, Addr paddr, U64 flags) +{ + UInt mindex; + if(NULL == mmulocked || NULL == mdirearr) + { + return FALSE; + } + + mindex = MDireIndex(vaddr); + mdirearr->MDEArr[mindex].MEntry = (((U64)paddr) | flags); + + return TRUE; +} + +private Bool MMUUnTranslationMDire(MMU* mmulocked, IDireArr* idirearr, PMSAD* msad, Addr vaddr) +{ + UInt iindex; + IDire idire; + MDireArr* mdirearr = NULL; + if(NULL == mmulocked || NULL == idirearr) + { + return FALSE; + } + + iindex = IDireIndex(vaddr); + + idire = idirearr->IDEArr[iindex]; + if(MDireIsHave(&idire) == FALSE) + { + return TRUE; + } + + mdirearr = IDireRetMDireArr(&idire); + if(MDireArrIsAllZero(mdirearr) == FALSE) + { + return TRUE; + } + + if(MMUDelMDireArr(mmulocked, mdirearr, msad) == FALSE) + { + return FALSE; + } + + idirearr->IDEArr[iindex].IEntry = 0; + + return TRUE; +} + +private MDireArr* MMUTranslationMDire(MMU* mmulocked, IDireArr* idirearr, Addr vaddr, U64 flags, PMSAD** outmsad) +{ + UInt iindex; + IDire idire; + Addr dire; + PMSAD* msad = NULL; + MDireArr* mdirearr = NULL; + if(NULL == mmulocked || NULL == idirearr || NULL == outmsad) + { + return NULL; + } + + iindex = IDireIndex(vaddr); + + idire = idirearr->IDEArr[iindex]; + if(MDireIsHave(&idire) == TRUE) + { + mdirearr = IDireRetMDireArr(&idire); + *outmsad = NULL; + return mdirearr; + } + + msa = MMUNewMDireArr(mmulocked); + if(NULL == msad) + { + *outmsad = NULL; + return NULL; + } + + dire = PMSADRetPAddr(msad); + mdirearr = (MDireArr*)(HalPAddrToVAddr(dire)); + idirearr->IDEArr[iindex].IEntry = (((U64)dire) | flags); + + *outmsad = msad; + + return mdirearr; +} + +private Bool MMUUnTranslationIDire(MMU* mmulocked, SDireArr* sdirearr, PMSAD* msad, Addr vaddr) +{ + UInt sindex; + SDire sdire; + IDireArr* idirearr = NULL; + if(NULL == mmulocked || NULL == sdirearr) + { + return FALSE; + } + + sindex = SDireIndex(vaddr); + + sdire = sdirearr->SDEArr[sindex]; + if(IDireIsHave(&sdire) == FALSE) + { + return TRUE; + } + + idirearr = SDireRetIDireArr(&sdire); + if(IDireArrIsAllZero(idirearr) == FALSE) + { + return TRUE; + } + + if(MMUDelIDireArr(mmulocked, idirearr, msad) == FALSE) + { + return FALSE; + } + + sdirearr->SDEArr[sindex].SEntry = 0; + + return TRUE; +} + +private IDireArr* MMUTranslationIDire(MMU* mmulocked, SDireArr* sdirearr, Addr vaddr, U64 flags, PMSAD** outmsad) +{ + UInt sindex; + SDire sdire; + Addr dire; + PMSAD* msad = NULL; + IDireArr* idirearr = NULL; + if(NULL == mmulocked || NULL == sdirearr || NULL == outmsad) + { + return NULL; + } + + sindex = SDireIndex(vaddr); + + sdire = sdirearr->SDEArr[sindex]; + if(IDireIsHave(&sdire) == TRUE) + { + idirearr = SDireRetIDireArr(&sdire); + *outmsad = NULL; + return idirearr; + } + + msad = MMUNewIDireArr(mmulocked); + if(NULL == msad) + { + *outmsad = NULL; + return NULL; + } + + dire = PMSADRetPAddr(msad); + idirearr = (IDireArr*)(HalPAddrToVAddr(dire)); + sdirearr->SDEArr[sindex].SEntry = (((U64)dire) | flags); + + *outmsad = msad; + + return idirearr; +} + +private Bool MMUUnTranslationSDire(MMU* mmulocked, TDireArr* tdirearr, PMSAD* msad, Addr vaddr) +{ + UInt tindex; + TDire tdire; + SDireArr* sdirearr = NULL; + + if(NULL == mmulocked || NULL == tdirearr) + { + return FALSE; + } + + tindex = TDireIndex(vaddr); + + tdire = tdirearr->tde_arr[tindex]; + if(SDireIsHave(&tdire) == FALSE) + { + return TRUE; + } + + sdirearr = TDireRetSDireArr(&tdire); + if(SDireArrIsAllZero(sdirearr) == FALSE) + { + return TRUE; + } + + if(MMUDelSDireArr(mmulocked, sdirearr, msad) == FALSE) + { + return FALSE; + } + + tdirearr->TDEArr[tindex].TEntry = 0; + + return TRUE; +} + +private SDireArr* MMUTranslationSDire(MMU* mmulocked, TDireArr* tdirearr, Addr vaddr, U64 flags, PMSAD** outmsad) +{ + UInt tindex; + TDire tdire; + Addr dire; + SDireArr* sdirearr = NULL; + PMSAD* msad = NULL; + if(NULL == mmulocked || NULL == tdirearr || NULL == outmsad) + { + return NULL; + } + + tindex = TDireIndex(vaddr); + + tdire = tdirearr->TDEArr[tindex]; + if(SDireIsHave(&tdire) == TRUE) + { + sdirearr = TDireRetSDireArr(&tdire); + *outmsad = NULL; + return sdirearr; + } + + msad = MMUNewSDireArr(mmulocked); + if(NULL == msad) + { + *outmsad = NULL; + return NULL; + } + + dire = PMSADRetPAddr(msad); + sdirearr = (SDireArr*)(HalPAddrToVAddr(dire)); + tdirearr->TDEArr[tindex].TEntry = (((U64)dire) | flags); + + *outmsad = msad; + + return sdirearr; +} + +private Addr MMUFindPMSADAddress(MDireArr* mdirearr, Addr vaddr) +{ + UInt mindex; + MDire dire; + if(NULL == mdirearr) + { + return NULL; + } + + mindex = MDireIndex(vaddr); + + dire = mdirearr->MDEArr[mindex]; + + if(MMUPMSADIsHave(&dire) == FALSE) + { + return NULL; + } + + return MMUPMSADRetPAddr(&dire); +} + + +private MDireArr* MMUFindMDireArr(IDireArr* idirearr, Addr vaddr) +{ + UInt iindex; + IDire dire; + if(NULL == idirearr) + { + return NULL; + } + + iindex = IDireIndex(vaddr); + + dire = idirearr->IDEArr[iindex]; + + if(MDireIsHave(&dire) == FALSE) + { + return NULL; + } + + return IDireRetMDireArr(&dire); +} + + +private IDireArr* MMUFindIDireArr(SDireArr* sdirearr, Addr vaddr) +{ + UInt sindex; + SDire dire; + if(NULL == sdirearr) + { + return NULL; + } + + sindex = SDireIndex(vaddr); + + dire = sdirearr->SDEArr[sindex]; + + if(IDireIsHave(&dire) == FALSE) + { + return NULL; + } + + return SDireRetIDireArr(&dire); +} + +private SDireArr* MMUFindSDireArr(TDireArr* tdirearr, Addr vaddr) +{ + UInt tindex; + TDire dire; + if(NULL == tdirearr) + { + return NULL; + } + + tindex = TDireIndex(vaddr); + + dire = tdirearr->TDEArr[tindex]; + + if(SDireIsHave(&dire) == FALSE) + { + return NULL; + } + + return TDireRetSDireArr(&dire); +} + +public void HalMMULoad(MMU* mmu) +{ + if(NULL == mmu) + { + return; + } + + HalSPinLock(&mmu->Lock); + if(NULL == mmu->TDireArrPtr || 0 != (((U64)(mmu->TDireArrPtr)) & 0xfff)) + { + goto out; + } + + mmu->CR3.Entry = HalVAddrToPAddr((Addr)mmu->TDireArrPtr); + HalWriteCR3((UInt)(mmu->CR3.Entry)); + +out: + HalUnSPinLock(&mmu->Lock); + return; +} + +private void HalMMUInnerRefresh(MMU* mmulocked) +{ + CR3 cr3; + if(NULL == mmulocked) + { + cr3.Entry = (U64)HalReadCR3(); + HalWriteCR3(cr3.Entry); + return; + } + if(NULL == mmulocked->TDireArrPtr || 0 != (((U64)(mmulocked->TDireArrPtr)) & 0xfff)) + { + return; + } + + mmulocked->CR3.Entry = HalVAddrToPAddr((Addr)mmulocked->TDireArrPtr); + HalWriteCR3((UInt)(mmulocked->CR3.Entry)); + return; +} + + + +public void HalMMURefresh(MMU* mmu) +{ + CR3 cr3; + if(NULL == mmu) + { + cr3.Entry = (U64)HalReadCR3(); + HalWriteCR3(cr3.Entry); + return; + } + HalMMULoad(mmu); + return; +} + +private Addr HalUnMMUTranslationCore(MMU* mmu, Addr vaddr) +{ + Addr retadr; + SDireArr* sdirearr; + IDireArr* idirearr; + MDireArr* mdirearr; + HalSPinLock(&mmu->Lock); + sdirearr = MMUFindSDireArr(mmu->TDireArrPtr, vaddr); + if(NULL == sdirearr) + { + retadr = NULL; + goto OUTLabel; + } + + idirearr = MMUFindIDireArr(sdirearr, vaddr); + if(NULL == idirearr) + { + retadr = NULL; + goto ERRLabelSDireArr; + } + + mdirearr = MMUFindMDireArr(idirearr, vaddr); + if(NULL == mdirearr) + { + retadr = NULL; + goto ERRLabelIDireArr; + } + + retadr = MMUUnTranslationPMSAD(mmu, mdirearr, vaddr); + + MMUUnTranslationMDire(mmu, idirearr, NULL, vaddr); +ERRLabelIDireArr: + MMUUnTranslationIDire(mmu, sdirearr, NULL, vaddr); +ERRLabelSDireArr: + MMUUnTranslationSDire(mmu, mmu->TDireArrPtr, NULL, vaddr); +OUtLabel: + HalMMUInnerRefresh(mmu); + HalUnSPinLock(&mmu->Lock); + return retadr; +} + +public Addr HalUnMMUTranslation(MMU* mmu, Addr vaddr) +{ + if(NULL == mmu) + { + return EPARAM; + } + return HalUnMMUTranslationCore(mmu, vaddr); +} + +private Bool HalMMUTranslationCore(MMU* mmu, Addr vaddr, Addr paddr, U64 flags) +{ + Bool rets = FALSE; + TDireArr* tdirearr = NULL; + SDireArr* sdirearr = NULL; + IDireArr* idirearr = NULL; + MDireArr* mdirearr = NULL; + PMSAD* smsad = NULL; + PMSAD* imsad = NULL; + PMSAD* mmsad = NULL; + + HalSPinLock(&mmu->Lock); + + tdirearr = mmu->TDireArrPtr; + if(NULL == tdirearr) + { + rets = FALSE; + goto OUTLabel; + } + + sdirearr = MMUTranslationSDire(mmu, tdirearr, vaddr, flags, &smsad); + if(NULL == sdirearr) + { + rets = FALSE; + goto ERRLabelSDire; + } + + idirearr = MMUTranslationIDire(mmu, sdirearr, vaddr, flags, &imsad); + if(NULL == idirearr) + { + rets = FALSE; + goto ERRLabelIDire; + } + + mdirearr = MMUTranslationMDire(mmu, idirearr, vaddr, flags, &mmsad); + if(NULL == mdirearr) + { + rets = FALSE; + goto ERRLabelMDire; + } + + rets = MMUTranslationPMSAD(mmu, mdirearr, vaddr, paddr, flags); + if(TRUE == rets) + { + rets = TRUE; + HalMMUInnerRefresh(mmu); + goto out; + } + + rets = FALSE; + + MMUUnTranslationPMSAD(mmu, mdirearr, vaddr); +ERRLabelMDire: + MMUUnTranslationMDire(mmu, idirearr, mmsad, vaddr); +ERRLabelIDire: + MMUUnTranslationIDire(mmu, sdirearr, imsad, vaddr); +ERRLabelSDire: + MMUUnTranslationSDire(mmu, tdirearr, smsad, vaddr); +OUTLabel: + HalUnSPinLock(&mmu->Lock); + return rets; +} + +public Bool HalMMUTranslation(MMU* mmu, Addr vaddr, Addr paddr, U64 flags) +{ + if(NULL == mmu) + { + return NULL; + } + return HalMMUTranslationCore(mmu, vaddr, paddr, flags); +} + + +private Bool MMUCleanMDireArrAllPMSAD(MMU* mmulocked) +{ + List* pos; + PMSAD* msad = NULL; + if(NULL == mmulocked) + { + return FALSE; + } + ListForEachDeleteOneList(pos, &mmulocked->MDirHead) + { + msad = ListEntry(pos, PMSAD, md_list); + ListDel(&msad->Lists); + if(HalExPPutKrlOnePMSAD(msad) == FALSE) + { + system_error("mmu_clean_mdirearrmsas"); + return FALSE; + } + mmulocked->MDirMsaNR--; + } + return TRUE; +} + +private Bool MMUCleanIDireArrAllPMSAD(MMU* mmulocked) +{ + List* pos; + PMSAD* msad = NULL; + if(NULL == mmulocked) + { + return FALSE; + } + ListForEachDeleteOneList(pos, &mmulocked->IDirHead) + { + msad = ListEntry(pos, PMSAD, Lists); + ListDel(&msad->Lists); + if(HalExPPutKrlOnePMSAD(msad) == FALSE) + { + system_error("mmu_clean_idirearrmsas"); + return FALSE; + } + mmulocked->IDirMsaNR--; + } + return TRUE; +} + +private Bool MMUCleanSDireArrAllPMSAD(MMU* mmulocked) +{ + List* pos; + PMSAD* msad = NULL; + if(NULL == mmulocked) + { + return FALSE; + } + ListForEachDeleteOneList(pos, &mmulocked->SDirHead) + { + msad = ListEntry(pos, PMSAD, Lists); + ListDel(&msad->Lists); + if(HalExPPutKrlOnePMSAD(msad) == FALSE) + { + system_error("MMUCleanSDireArrAllPMSAD"); + return FALSE; + } + mmulocked->SDirMsaNR--; + } + return TRUE; +} + +private Bool MMUCleanTDireArrAllPMSAD(MMU* mmulocked) +{ + List* pos; + PMSAD* msad = NULL; + if(NULL == mmulocked) + { + return FALSE; + } + ListForEachDeleteOneList(pos, &mmulocked->TDirHead) + { + msad = ListEntry(pos, PMSAD, Lists); + ListDel(&msad->Lists); + if(HalExPPutKrlOnePMSAD(msad) == FALSE) + { + system_error("MMUCleanTDireArrAllPMSAD"); + return FALSE; + } + mmulocked->TDirMsaNR--; + } + return TRUE; +} + +public Bool HalMMUClean() +{ + Bool rets = FALSE; + Addr pcr3 = NULL, vcr3 = NULL; + CR3 cr3; + if(NULL == mmu) + { + return FALSE; + } + + HalSPinlock(&mmu->Lock); + + cr3.Entry = (U64)HalReadCR3(); + + pcr3 = (Addr)(cr3.Flags.Plm4a << 12); + vcr3 = HalPAddrToVAddr(pcr3); + + if(vcr3 == (Addr)(mmu->TDireArrPtr)) + { + rets = FALSE; + goto OUTLabel; + } + + if(MMUCleanMDireArrAllPMSAD(mmu) == FALSE) + { + rets = FALSE; + goto OUTLabel; + } + + if(MMUCleanIDireArrAllPMSAD(mmu) == FALSE) + { + rets = FALSE; + goto OUTLabel; + } + + if(MMUCleanSDireArrAllPMSAD(mmu) == FALSE) + { + rets = FALSE; + goto OUTLabel; + } + + if(MMUCleanTDireArrAllPMSAD(mmu) == FALSE) + { + rets = FALSE; + goto OUTLabel; + } + + rets = TRUE; + +OUTLabel: + HalUnSPinLock(&mmu->Lock); + return rets; +} + +public Bool HalMMUInitExecutorTDireArr(MMU* mmu) +{ + Bool rets = FALSE; + Addr vcr3 = NULL; + if(NULL == mmu) + { + return FALSE; + } + HalSPinLock(&mmu->Lock); + + if(MMUNewTDireArr(mmu) == NULL) + { + rets = FALSE; + goto OUTLable; + } + + vcr3 = HalPAddrToVAddr(kmachbsp.mb_pml4padr); + + HalMemCopy((void*)vcr3, (void*)mmu->TDireArrPtr, sizeof(TDireArr)); + + mmu->Cr3.Entry = (U64)HalVAddrToPAddr((Addr)mmu->TDireArrPtr); + mmu->TDireArrPtr->TDEArr[0].TEntry = 0; + + rets = TRUE; + +OUTLable: + HalUnSPinLock(&mmu->Lock); + return rets; +} + +public Bool HalMMUEnable() +{ + //x86_64下没法单纯的开启MMU + return TRUE; +} + +public Bool HalMMUDisable() +{ + //x86_64下没法单纯的关闭MMU + return FALSE; +} + +public Bool HalMMUInit() +{ + return HalMMUEnable(); +} \ No newline at end of file diff --git a/Hal/X86_64/HalSync.c b/Hal/X86_64/HalSync.c new file mode 100644 index 0000000..76f4aef --- /dev/null +++ b/Hal/X86_64/HalSync.c @@ -0,0 +1,124 @@ +/********************************************************** + 同步文件HalSync.c +*********************************************************** + 彭东 +**********************************************************/ +#include "BaseType.h" +#include "HalCPU.h" +#include "HalSync.h" + +public void HalHalt() +{ + HALT(); +} + +public void HalCliHalt() +{ + CLIHALT(); +} + +public void HalStiHalt() +{ + STIHALT(); +} + +public void HalSti() +{ + STI(); +} + +public void HalCli() +{ + CLI(); +} + + +public void HalStiFlags(CPUFlg* cpuflg) +{ + HalRestoreFlagsSti(cpuflg); +} + +public void HalCliFlags(CPUFlg* cpuflg) +{ + HalSaveFlagsCli(cpuflg); +} + +public void HalFlagsSti(CPUFlg* cpuflg) +{ + HalSaveFlagsSti(cpuflg); +} + +public void HalFlagsCli(CPUFlg* cpuflg) +{ + HalRestoreFlagsCli(cpuflg); +} + +public void SPinLockInit(SPinLock *init) +{ + init->Lock = 0; + return; +} + +public void HalSPinLock(SPinLock *lock) +{ + __asm__ __volatile__( + "1: \n" + "lock; xchg %0, %1 \n" + "cmpl $0, %0 \n" + "jnz 2f \n" + ".section .spinlock.text," + "\"ax\"" + "\n" // 重新定义一个代码段所以jnz 2f下面并不是 + "2: \n" //cmpl $0,%1 事实上下面的代码不会常常执行, + "cmpl $0, %1 \n" //这是为了不在cpu指令高速缓存中填充无用代码 + "jne 2b \n" //要知道那可是用每位6颗晶体管做的双极性静态 + "jmp 1b \n" //储存器,比内存条快几千个数量级 + ".previous \n" + : + : "r"(1), "m"(*lock)); + return; +} + +public void HalUnSPinLock(SPinLock *lock) +{ + __asm__ __volatile__( + "movl $0, %0\n" + : + : "m"(*lock)); + return; +} + +public void HalSPinLockSaveFlagsCli(SPinLock *lock, CPUFlg *cpuflg) +{ + __asm__ __volatile__( + "pushfq \n\t" + "cli \n\t" + "popq %0 \n\t" + + "1: \n\t" + "lock; xchg %1, %2 \n\t" + "cmpl $0,%1 \n\t" + "jnz 2f \n\t" + ".section .spinlock.text," + "\"ax\"" + "\n\t" //重新定义一个代码段所以jnz 2f下面并不是 + "2: \n\t" //cmpl $0,%1 事实上下面的代码不会常常执行, + "cmpl $0,%2 \n\t" //这是为了不在cpu指令高速缓存中填充无用代码 + "jne 2b \n\t" + "jmp 1b \n\t" + ".previous \n\t" + : "=m"(*cpuflg) + : "r"(1), "m"(*lock)); + return; +} + +public void HalUnSPinLockRestoreFlagsSti(SPinLock *lock, CPUFlg *cpuflg) +{ + __asm__ __volatile__( + "movl $0, %0\n\t" + "pushq %1 \n\t" + "popfq \n\t" + : + : "m"(*lock), "m"(*cpuflg)); + return; +} \ No newline at end of file diff --git a/Hal/X86_64/HalVirtual.c b/Hal/X86_64/HalVirtual.c new file mode 100644 index 0000000..e69de29 diff --git a/Hal/X86_64/OSLinker.S b/Hal/X86_64/OSLinker.S new file mode 100644 index 0000000..40a8233 --- /dev/null +++ b/Hal/X86_64/OSLinker.S @@ -0,0 +1,101 @@ +/****************************************************************** +* ld自动化链接脚本文件OSLinker.S * +* 彭东 * +******************************************************************/ + +#include "OSLinker.h" +OUTPUT_ARCH(OSONARCH) +OUTPUT_FORMAT(OSONFORMAT) +ENTRY(OSSTARTPOINT) + +SECTIONS +{ + + . = LINEAR_ADDRESS; + StartKernel = . + VIRTUAL_ADDRESS; + BeginStartText = .; + .start.text : ALIGN(4) { *(.start.text) } + EndStartText = .; + + BeginStartData = .; + .start.data : ALIGN(0x4) { *(.start.data) } + EndStartData = .; + + . +=VIRTUAL_ADDRESS; + BeginEntry64Text = .; + .entry64.text ALIGN(4) : AT(ADDR(.entry64.text)-VIRTUAL_ADDRESS){ *(.entry64.text) } + EndEntry64Text = .; + + BeginCPUCoreArchData = .; + .cpu.core.arch.data ALIGN(4) : AT(ADDR(.cpu.core.arch.data)-VIRTUAL_ADDRESS){ *(.cpu.core.arch.data) } + EndCPUCoreArchData = .; + + BeginCPUCoreInterruptData = .; + .cpu.core.interrupt.data ALIGN(4) : AT(ADDR(.cpu.core.interrupt.data)-VIRTUAL_ADDRESS){ *(.cpu.core.interrupt.data) } + EndCPUCoreInterruptData = .; + + BeginHWINTText = .; + .hwint.text ALIGN(4) : AT(ADDR(.hwint.text)-VIRTUAL_ADDRESS){ *(.hwint.text) } + EndHWINTText = .; + + BeginEIRSText = .; + .eirs.text ALIGN(4) : AT(ADDR(.eirs.text)-VIRTUAL_ADDRESS) { *(.eirs.text) } + EndEIRSText = .; + + BeginSYSCallText = .; + .syscall.text ALIGN(4) : AT(ADDR(.syscall.text)-VIRTUAL_ADDRESS) {*(.syscall.text) } + EndSYSCallText = .; + + BeginSchedText = .; + .sched.text ALIGN(4) : AT(ADDR(.sched.text)-VIRTUAL_ADDRESS) { *(.sched.text) } + EndSchedText = .; + + BeginFsText = .; + .fs.text ALIGN(4) : AT(ADDR(.fs.text)-VIRTUAL_ADDRESS) { *(.fs.text) } + EndFsText = .; + + BeginDriverText = .; + .driver.text ALIGN(4) : AT(ADDR(.driver.text)-VIRTUAL_ADDRESS) { *(.driver.text)} + EndDriverText = .; + + BeginText = .; + .text ALIGN(4) : AT(ADDR(.text)-VIRTUAL_ADDRESS) { *(.text) } + EndText = .; + + BeginSPinLockText = .; + .spinlock.text ALIGN(4) : AT(ADDR(.spinlock.text)-VIRTUAL_ADDRESS) { *(.spinlock.text) } + EndSPinLockText = .; + + BeginDriverEntryText = .; + .drventry.text ALIGN(4) : AT(ADDR(.drventry.text)-VIRTUAL_ADDRESS) { *(.drventry.text)} + EndDriverEntryText = .; + + BeginMEMData = .; + .mem.data ALIGN(4) : AT(ADDR(.mem.data)-VIRTUAL_ADDRESS) { *(.mem.data) } + EndMEMData = .; + + BeginData = .; + .data ALIGN(4) : AT(ADDR(.data)-VIRTUAL_ADDRESS) { *(.data) *(.bss) } + EndData = .; + + BeginRoData = .; + .rodata ALIGN(4) : AT(ADDR(.rodata)-VIRTUAL_ADDRESS) { *(.rodata) *(.rodata.*) } + EndRRoData = .; + + BeginKStrTab = .; + .kstrtab ALIGN(4) : AT(ADDR(.kstrtab)-VIRTUAL_ADDRESS) { *(.kstrtab) } + EndKStrTab = .; + + BeginAPBootText = .; + .apboot.text ALIGN(4) : AT(ADDR(.apboot.text)-VIRTUAL_ADDRESS) { *(.apboot.text) } + EndAPBootText = .; + + BeginAPBootData = .; + .apboot.data ALIGN(4) : AT(ADDR(.apboot.data)-VIRTUAL_ADDRESS) { *(.apboot.data) } + EndAPBootData = .; + + BeginBss = .; + .bss ALIGN(4) : AT(ADDR(.bss)-VIRTUAL_ADDRESS) { *(.bss) } + EndBss = .; + EndKernel = .; +} \ No newline at end of file diff --git a/Include/APILibInc/APILib.h b/Include/APILibInc/APILib.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/BaseInc/Atomic.h b/Include/BaseInc/Atomic.h new file mode 100755 index 0000000..0cec3db --- /dev/null +++ b/Include/BaseInc/Atomic.h @@ -0,0 +1,117 @@ +/********************************************************** + 原子操作头文件Atomic.h +*********************************************************** + 彭东 +**********************************************************/ +#ifndef _ATOMICHEAD +#define _ATOMICHEAD + +typedef struct ATOMIC{ + volatile S32 Count; +}Atomic; + +typedef struct REFCOUNT +{ + Atomic ARef; +}RefCount; + + +KLINE S32 AtomicRead(const Atomic *A) +{ + return (*(volatile U32 *)&(A)->Count); +} + +KLINE void AtomicSet(Atomic *A, S32 Val) +{ + A->Count = Val; +} + +KLINE void AtomicAdd(S32 Val, Atomic *A) +{ + __asm__ __volatile__("lock;" + "addl %1,%0" + : "+m"(A->Count) + : "ir"(I)); +} + +KLINE void AtomicSub(S32 Val, Atomic *A) +{ + __asm__ __volatile__("lock;" + "subl %1,%0" + : "+m"(A->Count) + : "ir"(Val)); +} + +KLINE S32 AtomicSubAndTest(S32 Val, Atomic *A) +{ + unsigned char c; + + __asm__ __volatile__("lock;" + "subl %2,%0; sete %1" + : "+m"(A->Count), "=qm"(c) + : "ir"(Val) + : "memory"); + return c; +} + +KLINE void AtomicInc(Atomic *A) +{ + __asm__ __volatile__("lock;" + "incl %0" + : "+m"(A->Count)); +} + +KLINE void AtomicDec(Atomic *A) +{ + __asm__ __volatile__("lock;" + "decl %0" + : "+m"(A->Count)); +} + +KLINE S32 AtomicDecAndTest(Atomic *A) +{ + unsigned char c; + + __asm__ __volatile__("lock;" + "decl %0; sete %1" + : "+m"(A->Count), "=qm"(c) + : + : "memory"); + return c != 0; +} + +KLINE S32 AtomicIncAndTest(Atomic *A) +{ + unsigned char c; + + __asm__ __volatile__("lock;" + "incl %0; sete %1" + : "+m"(A->Count), "=qm"(c) + : + : "memory"); + return c != 0; +} + +KLINE void RefCountInit(RefCount *init) +{ + AtomicSet(&init->ARef, 0); + return; +} + +KLINE void RefCountInc(RefCount *Ref) +{ + AtomicInc(&Ref->ARef); + return; +} + +KLINE void RefCountDec(RefCount *Ref) +{ + AtomicDec(&Ref->ARef); +} + +KLINE S32 RefCountRead(RefCount *Ref) +{ + return AtomicRead(&Ref->ARef); +} + +#endif diff --git a/Include/BaseInc/BaseType.h b/Include/BaseInc/BaseType.h new file mode 100644 index 0000000..0ad778a --- /dev/null +++ b/Include/BaseInc/BaseType.h @@ -0,0 +1,91 @@ +/********************************************************** + 基本数据类型文件BaseType.h +*********************************************************** + 彭东 +**********************************************************/ +#ifndef _BASETYPEHEAD +#define _BASETYPEHEAD +//无符号整数类型 +typedef unsigned char U8; +typedef unsigned short U16; +typedef unsigned int U32; +typedef unsigned long U64; +//有符号整数类型 +typedef char S8; +typedef short S16; +typedef int S32; +typedef long S64; +//通用有/无符号整数类型 +typedef long SInt; +typedef unsigned long UInt; +//CPU标志寄存器类型 +typedef U64 CPUFlg; +//地址类型 +typedef unsigned long Addr; +//布尔类型 +typedef SInt Bool; +//字符串类型 +typedef const char* String; +//字符类型 +typedef char Char; +//句柄类型 +typedef SInt Hand; +//缓冲区地址类型 +typedef void* Buff; +//大小类型 +typedef unsigned long Size; + +typedef SInt DrvStus; +#define KLINE static inline +#define public +#define private static +#define EXTERN extern +#define KEXTERN extern +#define NULL (0UL) +#define TRUE (1UL) +#define FALSE (0UL) + +#define ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1)) + +#define IF_NULL_RETURN(ptr) do{if(NULL == ptr){return;}}while(0); +#define IF_NULL_RETURN_FALSE(ptr) do{if(NULL == ptr){return FALSE;}}while(0) +#define IF_NULL_RETURN_NULL(ptr) do{if(NULL == ptr){return NULL;}}while(0) +#define IF_ZERO_RETURN_NULL(x) do{if(0 == x){return NULL;}}while(0) +#define IF_ZERO_RETURN_FALSE(x) do{if(0 == x){return FALSE;}}while(0) +#define IF_NULL_RETURN_ZERO(ptr) do{if(NULL == ptr){return 0;}}while(0) +#define IF_NULL_DEAD(ptr) do{if(NULL == ptr){KrlErrorCrashDead("OBJ PTR IS NULL!!");}}while(0) + +#define INIT_OBJOFPTR_ZERO(ptr) do{HalMemSet((void*)ptr, 0, sizeof(typeof(*ptr)));}while(0) + +#define TEST_FAIL_STRING(fmt, ...) fmt,##__VA_ARGS__ +#define TEST_FAIL_DEAD_ESTMFUNC(str) KrlErrorCrashDead(TEST_FAIL_STRING("%s,%d,%s,%s",__FILE__,__LINE__,__FUNCTION__,str)) + +#define IF_TEST_OP(cmpsrc, tester, op, excstmfunc) do{if(cmpsrc op tester) {excstmfunc;}}while(0) + +#define IF_RET_OP(cmpsrc, tester, op, rets) do{if(cmpsrc op tester) {return rets;}}while(0) + +#define IF_LTN_DEAD(cmp, test, str) IF_TEST_OP(cmp, test, <, TEST_FAIL_DEAD_ESTMFUNC(str)) +#define IF_GTN_DEAD(cmp, test, str) IF_TEST_OP(cmp, test, >, TEST_FAIL_DEAD_ESTMFUNC(str)) +#define IF_EQT_DEAD(cmp, test, str) IF_TEST_OP(cmp, test, ==, TEST_FAIL_DEAD_ESTMFUNC(str)) +#define IF_NEQ_DEAD(cmp, test, str) IF_TEST_OP(cmp, test, !=, TEST_FAIL_DEAD_ESTMFUNC(str)) + +#define IF_LTN_RETURN(cmp, test, rets) IF_RET_OP(cmp, test, <, rets) +#define IF_GTN_RETURN(cmp, test, rets) IF_RET_OP(cmp, test, >, rets) +#define IF_EQT_RETURN(cmp, test, rets) IF_RET_OP(cmp, test, ==, rets) +#define IF_NEQ_RETURN(cmp, test, rets) IF_RET_OP(cmp, test, !=, rets) + +#define IF_LTNZERO_RETRUN_NULL(test) IF_LTN_RETURN(test, 0, NULL) +#define IF_LTNONE_RETRUN_NULL(test) IF_LTN_RETURN(test, 1, NULL) +#define IF_GTNZERO_RETRUN_NULL(test) IF_GTN_RETURN(test, 0, NULL) +#define IF_GTNONE_RETRUN_NULL(test) IF_GTN_RETURN(test, 1, NULL) +#define IF_NEQZERO_RETRUN_NULL(test) IF_NEQ_RETURN(test, 0, NULL) +#define IF_NEQONE_RETRUN_NULL(test) IF_NEQ_RETURN(test, 1, NULL) + +#define IF_LTNZERO_RETRUN_FALSE(test) IF_LTN_RETURN(test, 0, FALSE) +#define IF_LTNONE_RETRUN_FALSE(test) IF_LTN_RETURN(test, 1, FALSE) +#define IF_GTNZERO_RETRUN_FALSE(test) IF_GTN_RETURN(test, 0, FALSE) +#define IF_GTNONE_RETRUN_FALSE(test) IF_GTN_RETURN(test, 1, FALSE) +#define IF_NEQZERO_RETRUN_FALSE(test) IF_NEQ_RETURN(test, 0, FALSE) +#define IF_NEQONE_RETRUN_FALSE(test) IF_NEQ_RETURN(test, 1, FALSE) + +#endif \ No newline at end of file diff --git a/Include/BaseInc/List.h b/Include/BaseInc/List.h new file mode 100755 index 0000000..b030418 --- /dev/null +++ b/Include/BaseInc/List.h @@ -0,0 +1,129 @@ +/********************************************************** + 链表头文件list.h +*********************************************************** + 彭东 +**********************************************************/ +#ifndef _LISTHEAD +#define _LISTHEAD + +typedef struct LIST { + struct LIST *Prev; + struct LIST *Next; +}List; + +KLINE void ListInit(List *list) +{ + list->Prev = list; + list->Next = list; + return; +} + +KLINE void ListDelRealize(List *prev, List *next) +{ + next->Prev = prev; + prev->Next = next; + return; +} + +KLINE void ListAddRealize(List *new, List *prev, List *next) +{ + next->Prev = new; + new->Next = next; + new->Prev = prev; + prev->Next = new; + return; +} + +KLINE void ListAdd(List *new, List *head) +{ + ListAddRealize(new, head, head->Next); + return; +} + +KLINE void ListAddTail(List *new, List *head) +{ + ListAddRealize(new, head->Prev, head); + return; +} + +KLINE void ListDelEntryRealize(List *entry) +{ + ListDelRealize(entry->Prev, entry->Next); + return; +} + +KLINE void ListDel(List *entry) +{ + ListDelRealize(entry->Prev, entry->Next); + ListInit(entry); + return; +} + +KLINE void ListMove(List *list, List *head) +{ + ListDel(list); + ListAdd(list, head); + return; +} +KLINE void ListMoveTail(List *list, List *head) +{ + ListDel(list); + ListAddTail(list, head); + return; +} + +KLINE Bool ListIsEmpty(const List *head) +{ + if (head->Next == head) + { + return TRUE; + } + return FALSE; +} + +KLINE Bool ListIsFirst(const List* list, const List* head) +{ + if(list->Prev == head) + { + return TRUE; + } + return FALSE; +} + +KLINE Bool ListIsLast(const List* list, const List* head) +{ + if(list->Next == head) + { + return TRUE; + } + return FALSE; +} + +KLINE Bool ListIsEmptyCareful(const List *head) +{ + List *Next = head->Next; + if (Next == head && Next == head->Prev) + { + return TRUE; + } + return FALSE; +} + +#define ListForEach(pos, head) for (pos = (head)->Next; pos != (head); pos = pos->Next) + +#define ListForEachDeleteOneList(pos, head) for (pos = (head)->Next; pos != (head); pos = (head)->Next) + +#define ListEntry(ptr, type, member) \ + ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member))) + +#define ListFirstOne(head, o_type, o_member) ListEntry((head)->Next, o_type, o_member) + +#define ListNextEntry(pos, type, member) \ + ListEntry((pos)->member.Next, type, member) + + +#define ListPrevEntry(pos, type, member) \ + ListEntry((pos)->member.Prev, type, member) + + +#endif diff --git a/Include/BaseInc/Queue.h b/Include/BaseInc/Queue.h new file mode 100644 index 0000000..d96cfce --- /dev/null +++ b/Include/BaseInc/Queue.h @@ -0,0 +1,141 @@ +/********************************************************** + 队列头文件Queue.h +*********************************************************** + 彭东 +**********************************************************/ +#ifndef _QUEUEHEAD +#define _QUEUEHEAD +typedef struct QNODE +{ + List Node; + void* Obj; + void* Ext; +}QNode; + +typedef struct QUEUE +{ + List QHead; + QNode* QCurr; +}Queue; + +KLINE void QnodeInit(QNode* init) +{ + if(NULL == init) + { + return; + } + ListInit(&init->Node); + init->Obj = NULL; + init->Ext = NULL; + return; +} + +KLINE void QueueInit(Queue* init) +{ + if(NULL == init) + { + return; + } + ListInit(&init->QHead); + init->QCurr = NULL; + return; +} + +KLINE Bool QueueIsEmpty(Queue* q) +{ + if(NULL == q) + { + return TRUE; + } + if(ListIsEmptyCareful(&q->QHead) == TRUE) + { + return TRUE; + } + return FALSE; +} + +KLINE QNode* QueuePop(Queue* q) +{ + List* prev; + QNode* qn; + if(NULL == q) + { + return NULL; + } + if(NULL == q->QCurr || ListIsEmptyCareful(&q->QHead) == TRUE) + { + return NULL; + } + + qn = q->QCurr; + prev = qn->Node.Prev; + + ListDel(&qn->Node); + if(ListIsEmptyCareful(&q->QHead) == TRUE) + { + q->QCurr = NULL; + return qn; + } + q->QCurr = ListEntry(prev, QNode, Node); + return qn; +} + +KLINE QNode* QueuePush(Queue* q, QNode* qn) +{ + if(NULL == q || NULL == qn) + { + return NULL; + } + ListAddTail(&qn->Node, &q->QHead); + q->QCurr = qn; + return qn; +} + +KLINE QNode* QueueAdd(Queue* q, QNode* qn) +{ + if(NULL == q || NULL == qn) + { + return NULL; + } + ListAddTail(&qn->Node, &q->QHead); + return qn; +} + +KLINE QNode* QueuePoll(Queue* q) +{ + QNode* qn; + if(NULL == q) + { + return NULL; + } + if(ListIsEmptyCareful(&q->QHead) == TRUE) + { + return NULL; + } + qn = ListFirstOneObj(&q->QHead, QNode, Node); + ListDel(&qn->Node); + return qn; +} + +KLINE QNode* NewQNode(void* obj) +{ + QNode* qn = (QNode*)kmsob_new(sizeof(QNode)); + if(NULL == qn) + { + return NULL; + } + QNodeInit(qn); + qn->qn_obj = obj; + return qn; +} + +KLINE Bool DelQonde(QNode* qn) +{ + if(NULL == qn) + { + return FALSE; + } + return kmsob_delete((void*)qn, sizeof(QNode)); +} + +#endif diff --git a/Include/BaseInc/RBTree.h b/Include/BaseInc/RBTree.h new file mode 100644 index 0000000..48bd7a4 --- /dev/null +++ b/Include/BaseInc/RBTree.h @@ -0,0 +1,1034 @@ +/********************************************************** + 红黑树头文件RBTree.h +*********************************************************** + 彭东 +**********************************************************/ +#ifndef _RBTREEHEAD +#define _RBTREEHEAD + +#define RBRED (0) +#define RBBLACK (1) + + +#define RBERR (0) +#define RBLEFT (1) +#define RBRIGHT (2) + +typedef struct RBTFLAGS +{ + U16 Type; + U16 Color; + U32 Hight; +}__attribute__((packed)) RBTFlags; + + +typedef struct RBTREE +{ + RBTFlags Flags; + struct RBTREE* Left; + struct RBTREE* Right; + struct RBTREE* Parent; +}RBTree; + +typedef struct RBROOT +{ + UInt Count; + RBTree* MostLeft; + RBTree* Node; + RBTree* MostRight; +}RBRoot; + +typedef UInt (*RBPathCMP)(RBTree* srcrb, RBTree* cmprb); +typedef UInt (*RBRePlace)(RBTree* srcrb, RBTree* reprb); +typedef UInt (*RBDelAfter)(RBTree* delrb); + +KLINE void RBTreeInit(RBTree* init) +{ + if(NULL == init) + { + return; + } + init->Flags.Color = RBRED; + init->Flags.Type = 0; + init->Flags.Hight = 0; + init->Left = NULL; + init->Right = NULL; + init->Parent = NULL; + return; +} + +KLINE void RBRootInit(RBRoot* init) +{ + if(NULL == init) + { + return; + } + init->Count = 0; + init->MostLeft = NULL; + init->Node = NULL; + init->MostRight = NULL; + return; +} + +KLINE void RBTreeSetColor(RBTree* rbtree, U16 color) +{ + if(NULL == rbtree) + { + return; + } + rbtree->Flags.Color = color; + return; +} + +KLINE Bool RBTreeColorIsRed(RBTree* rbtree) +{ + if(NULL == rbtree) + { + return FALSE; + } + if(RBRED == rbtree->Flags.Color) + { + return TRUE; + } + return FALSE; +} + +KLINE Bool RBTreeColorIsBlack(RBTree* rbtree) +{ + if(NULL == rbtree) + { + return TRUE; + } + if(RBBLACK == rbtree->Flags.Color) + { + return TRUE; + } + return FALSE; +} + +KLINE RBTree* RBTreeSibling(RBTree* rbtree) +{ + RBTree* parent; + if(NULL == rbtree) + { + return NULL; + } + parent = rbtree->Parent; + if(NULL == parent) + { + return NULL; + } + if(parent->Left == rbtree) + { + return parent->Right; + } + else + { + return parent->Left; + } +} + +KLINE RBTree* RBTreeUncle(RBTree* rbtree) +{ + if(NULL == rbtree) + { + return NULL; + } + if(NULL == rbtree->Parent) + { + return NULL; + } + return RBTreeSibling(rbtree->Parent); +} + +KLINE RBTree* RBTreeParent(RBTree* rbtree) +{ + if(NULL == rbtree) + { + return NULL; + } + return rbtree->Parent; +} + +KLINE Bool RBTreeIsRight(RBTree* rbtree) +{ + RBTree* parent; + if(NULL == rbtree) + { + return FALSE; + } + parent = rbtree->Parent; + if(NULL == parent) + { + return FALSE; + } + if(parent->Right == rbtree) + { + return TRUE; + } + else + { + return FALSE; + } +} + + +KLINE bool_t RBTreeIsLeft(RBTree* rbtree) +{ + RBTree* parent; + if(NULL == rbtree) + { + return FALSE; + } + parent = rbtree->Parent; + if(NULL == parent) + { + return FALSE; + } + if(parent->Left == rbtree) + { + return TRUE; + } + else + { + return FALSE; + } +} + +KLINE Bool RBTreeIsRoot(RBTree* rbtree) +{ + if(NULL == rbtree) + { + return FALSE; + } + if(NULL == rbtree->Parent) + { + return TRUE; + } + return FALSE; +} + +KLINE Bool RBTreeIsLeaf(RBTree* rbtree) +{ + if(NULL == rbtree) + { + return FALSE; + } + if((NULL == rbtree->Left) && (NULL == rbtree->Right)) + { + return TRUE; + } + return FALSE; +} + + +KLINE RBTree* RBTreeGrand(RBTree* rbtree) +{ + if(NULL == rbtree) + { + return NULL; + } + if(NULL == rbtree->Parent) + { + return NULL; + } + return rbtree->Parent->Parent; +} + +/* +查找前驱节点 +即 查找小于当前节点的最大节点 +*/ + +KLINE RBTree* RBTreeFindPrecursor(RBTree* rbtree) +{ + RBTree* rbt; + RBTree* p; + if(NULL == rbtree) + { + return NULL; + } + else if(NULL != rbtree->Left) + { + rbt = rbtree->Left; + while(NULL != rbt->Right) + { + rbt = rbt->Right; + } + return rbt; + } + else + { + rbt = rbtree; + p = rbt->Parent; + while (NULL != p && rbt == p->Left) + { + rbt = p; + p = p->Parent; + } + return p; + } + return NULL; +} + +/* +查找后继节点 +即 查找大于当前节点的最小节点 +*/ +KLINE RBTree* RBTreeFindSuccessor(RBTree* rbtree) +{ + RBTree* rbt; + RBTree* p; + if(NULL == rbtree) + { + return NULL; + } + else if(NULL != rbtree->Right) + { + rbt = rbtree->Right; + while(NULL != rbt->Left) + { + rbt = rbt->Left; + } + return rbt; + } + else + { + rbt = rbtree; + p = rbt->Parent; + while (NULL != p && rbt == p->Right) + { + rbt = p; + p = p->Parent; + } + return p; + } + return NULL; +} + + +/* + P 12 + / / + PLA 8 + / \ / \ + ALB ARC 7 10 + / \ / \ + CLE CRF 9 11 + + P 12 + / / + ARC 10 + / \ / \ + PLA CRF 8 11 + / \ / \ + ALB CLE 7 9 + +第1：变色 +条件： + （1）当前节点是红色 + （2）当前节点的父亲节点是红色 + （3）当前节点的叔叔节点是红色 +操作： + （1）当前节点的父亲节点变黑色 + （2）当前节点的叔叔节点变黑色 + （3）当前节点的爷爷节点变红色 + （4）当前节点的爷爷节点设为当前节点 + + +第2：左旋 +条件： + （1）当前节点的父亲节点是红色 + （2）当前节点的叔叔节点是黑色 + （3）当前节点是父亲节点的右子树 +操作： + （1）当前节点的父亲节点为基础进行左旋 + +第3：右旋 +条件： + （1）当前节点的父亲节点是红色 + （2）当前节点的叔叔节点是黑色 + （3）当前节点是父亲节点的左子树 +操作： + （1）当前节点的父亲节点变成黑色 + （2）当前节点的爷爷节点变成红色 + （3）当前节点的爷爷节点为基础进行右旋 +*/ + + + +KLINE RBTree* RBTreeRightRotate(RBRoot* rbroot, RBTree* rbtree) +{ + RBTree* P; + RBTree* R; + RBTree* RLN; + RBTree* TR; + if(NULL == rbtree || NULL == rbroot) + { + return NULL; + } + + R = rbtree; + P = R->Parent; + RLN = R->Left; + TR = RLN->Right; + if(NULL == RLN) + { + return NULL; + } + if(NULL != TR) + { + TR->Parent = R; + } + R->Left = TR; + RLN->Right = R; + R->Parent = RLN; + RLN->Parent = P; + + if(NULL == P) + { + rbroot->Node = RLN; + return R; + } + else + { + if(R == P->Left) + { + P->Left = RLN; + } + else + { + P->Right = RLN; + } + return R; + } + return NULL; +} + +KLINE RBTree* RBTreeLeftRotate(RBRoot* rbroot, RBTree* rbtree) +{ + RBTree* P; + RBTree* R; + RBTree* RRN; + RBTree* TL; + if(NULL == rbtree || NULL == rbroot) + { + return NULL; + } + + R = rbtree; + P = R->Parent; + RRN = R->Right; + TL = RRN->Left; + + if(NULL == RRN) + { + return NULL; + } + + if(NULL != TL) + { + TL->Parent = R; + } + + R->Right = TL; + RRN->Left = R; + R->Parent = RRN; + RRN->Parent = P; + + if(NULL == P) + { + rbroot->Node = RRN; + return R; + } + else + { + if(R == P->Left) + { + P->Left = RRN; + } + else + { + P->Right = RRN; + } + return R; + } + return NULL; +} + + + +KLINE RBTree* RBTreeFixColorReal(RBRoot* rbroot, RBTree* rbtree) +{ + RBTree* rbt; + if(NULL == rbtree || NULL == rbroot) + { + return NULL; + } + rbt = rbtree; + while(rbt) + { + if(RBTreeIsRoot(rbt) == TRUE) + { + RBTreeSetColor(rbt, RBBLACK); + return rbt; + } + + if(RBTreeColorIsBlack(RBTreeParent(rbt)) == TRUE) + { + return rbt; + } + + if((RBTreeColorIsRed(rbt) == TRUE) && + (RBTreeColorIsRed(RBTreeParent(rbt)) == TRUE) && + (RBTreeColorIsRed(RBTreeUncle(rbt)) == TRUE)) + { + RBTreeSetColor(RBTreeParent(rbt), RBBLACK); + RBTreeSetColor(RBTreeUncle(rbt), RBBLACK); + RBTreeSetColor(RBTreeGrand(rbt), RBRED); + rbt = RBTreeGrand(rbt); + } + else + { + return rbt; + } + } + return NULL; +} + + + +/* +(LL) + 4B + / + 2R + / + 1R +父节点变成黑色，爷爷节点变成红色 + 4R + / + 2B + / + 1R +爷爷节点右旋 + 2B + / \ + 1R 4R + +(RR) + 2B + \ + 3R + \ + 4R +父节点变成黑色，爷爷节点变成红色 + 2R + \ + 3B + \ + 4R +爷爷节点左旋 + 3B + / \ + 2R 4R + +(LR) + 4B + / + 2R + \ + 3R +当前节点变成黑色，爷爷节点变成红色 + 4R + / + 2R + \ + 3B +父节点左旋 + 4R + / + 3B + / + 2R +爷爷节点右旋 + 3B + / \ + 2R 4R + +(RL) + 2B + \ + 4R + / + 3R +当前节点变成黑色，爷爷节点变成红色 + 2R + \ + 4R + / + 3B +父节点右旋 + 2R + \ + 3B + \ + 4R +爷爷节点左旋 + 3B + / \ + 2R 4B +*/ + +KLINE RBTree* RBTreeFixRotate(RBRoot* rbroot, RBTree* rbtree) +{ + if(NULL == rbtree || NULL == rbroot) + { + return NULL; + } + + if(RBTreeColorIsRed(RBTreeParent(rbtree)) == FALSE || + RBTreeColorIsBlack(RBTreeUncle(rbtree)) == FALSE) + { + return NULL; + } + + if(RBTreeIsLeft(RBTreeParent(rbtree)) == TRUE)//L + { + + if(RBTreeIsLeft(rbtree) == TRUE)//LL父节点变成黑色，爷爷节点变成红色,爷爷节点右旋 + { + RBTreeSetColor(RBTreeParent(rbtree), RBBLACK); + RBTreeSetColor(RBTreeGrand(rbtree), RBRED); + RBTreeRightRotate(rbroot, RBTreeGrand(rbtree)); + return rbtree; + } + else //LR 当前节点变成黑色，爷爷节点变成红色,父节点左旋,爷爷节点右旋 + { + RBTreeSetColor(rbtree, RBBLACK); + RBTreeSetColor(RBTreeGrand(rbtree), RBRED); + RBTreeLeftRotate(rbroot, RBTreeParent(rbtree)); + RBTreeRightRotate(rbroot, RBTreeGrand(rbtree)); + return rbtree; + } + } + else//R + { + if(RBTreeIsLeft(rbtree) == TRUE)//RL当前节点变成黑色，爷爷节点变成红色,父节点右旋,爷爷节点左旋 + { + RBTreeSetColor(rbtree, RBBLACK); + RBTreeSetColor(RBTreeGrand(rbtree), RBRED); + RBTreeRightRotate(rbroot, RBTreeParent(rbtree)); + RBTreeLeftRotate(rbroot, RBTreeGrand(rbtree)); + return rbtree; + } + else//RR 父节点变成黑色，爷爷节点变成红色,爷爷节点左旋 + { + RBTreeSetColor(RBTreeParent(rbtree), RBBLACK); + RBTreeSetColor(RBTreeGrand(rbtree), RBRED); + RBTreeLeftRotate(rbroot, RBTreeGrand(rbtree)); + return rbtree; + } + } + return NULL; +} + + + +KLINE RBTree* RBTreeAdd(RBRoot* root, RBTree* rbtree, RBPathCMP cmper) +{ + RBTree* srcrb; + uint_t rets; + if(NULL == root || NULL == rbtree || NULL == cmper) + { + return NULL; + } + if(NULL == root->Node) + { + root->Node = rbtree; + rbtree->Parent = NULL; + RBTreeSetColor(rbtree, RBBLACK); + return rbtree; + } + srcrb = root->Node; + while(NULL != srcrb) + { + rets = cmper(srcrb, rbtree); + if(RBLEFT == rets) + { + if(NULL == srcrb->Left) + { + srcrb->Left = rbtree; + rbtree->Parent = srcrb; + break; + } + srcrb = srcrb->Left; + } + else if(RBRIGHT == rets) + { + if(NULL == srcrb->Right) + { + srcrb->Right = rbtree; + rbtree->Parent = srcrb; + break; + } + srcrb = srcrb->Right; + } + else + { + return NULL; + } + } + return rbtree; +} + +KLINE RBTree* RBTreeSerch(RBRoot* root, u32_t key) +{ + RBTree* srcrb; + // uint_t rets; + if(NULL == root) + { + return NULL; + } + if(NULL == root->Node) + { + + return NULL; + } + srcrb = root->Node; + while(NULL != srcrb) + { + // rets = cmper(srcrb, rbtree); + if(key == srcrb->Flags.Hight) + { + return srcrb; + } + if(key < srcrb->Flags.Hight) + { + srcrb = srcrb->Left; + } + else + { + srcrb = srcrb->Right; + } + } + return NULL; +} + +KLINE RBTree* RBTreeAddAfterFix(RBRoot* rbroot, RBTree* rbtree) +{ + RBTree* node; + RBTree* uncle; + if(NULL == rbroot || NULL == rbtree) + { + return NULL; + } + node = rbtree; + while((NULL != node) && (rbroot->Node != node) && (RBTreeColorIsRed(RBTreeParent(node)) == TRUE)) + { + if(RBTreeIsLeft(RBTreeParent(node)) == TRUE) + { + uncle = RBTreeGrand(node)->Right; + if(RBTreeColorIsRed(uncle) == TRUE) + { + RBTreeSetColor(RBTreeParent(node), RBBLACK); + RBTreeSetColor(uncle, RBBLACK); + RBTreeSetColor(RBTreeGrand(node), RBRED); + node = RBTreeGrand(node); + } + else + { + if(RBTreeIsRight(node) == TRUE) + { + node = RBTreeParent(node); + RBTreeLeftRotate(rbroot, node); + } + RBTreeSetColor(RBTreeParent(node), RBBLACK); + RBTreeSetColor(RBTreeGrand(node), RBRED); + RBTreeRightRotate(rbroot, RBTreeGrand(node)); + } + } + else + { + uncle = RBTreeGrand(node)->Left; + if(RBTreeColorIsRed(uncle) == TRUE) + { + RBTreeSetColor(RBTreeParent(node), RBBLACK); + RBTreeSetColor(uncle, RBBLACK); + RBTreeSetColor(RBTreeGrand(node), RBRED); + node = RBTreeGrand(node); + } + else + { + if(RBTreeIsLeft(node) == TRUE) + { + node = RBTreeParent(node); + RBTreeRightRotate(rbroot, node); + } + RBTreeSetColor(RBTreeParent(node), RBBLACK); + RBTreeSetColor(RBTreeGrand(node), RBRED); + RBTreeLeftRotate(rbroot, RBTreeGrand(node)); + } + } + } + RBTreeSetColor(rbroot->Node, RBBLACK); + return rbtree; +} + +KLINE RBTree* RBTreeAddAfter(RBRoot* rbroot, RBTree* rbtree) +{ + RBTree* rbt; + if(NULL == rbtree) + { + return NULL; + } + rbt = rbtree; + while(NULL != rbt) + { + rbt = RBTreeFixColorReal(rbroot, rbt); + + rbt = RBTreeFixRotate(rbroot, rbt); + } + return rbtree; +} + +KLINE RBTree* RBTreeInsert(RBRoot* root, RBTree* rbtree, RBPathCMP cmper) +{ + RBTree* rbt; + rbt = RBTreeAdd(root, rbtree, cmper); + return RBTreeAddAfterFix(root, rbtree); +} + +KLINE RBTree* RBTreeRemoveAfterFix(RBRoot* root, RBTree* rbtree) +{ + RBTree* rsib; + RBTree* rbnode; + if(NULL == rbtree || NULL == root) + { + return NULL; + } + rbnode = rbtree; + while((rbnode != root->Node) && (RBTreeColorIsBlack(rbnode) == TRUE)) + { + if(RBTreeIsLeft(rbnode) == TRUE) + { + rsib = rbnode->Parent->Right; + if((RBTreeColorIsRed(rsib) == TRUE)) + { + RBTreeSetColor(rsib, RBBLACK); + RBTreeSetColor(rbnode->Parent, RBRED); + RBTreeLeftRotate(root, rbnode->Parent); + rsib = rbnode->Parent->Right; + } + + if((RBTreeColorIsBlack(rsib->Left) == TRUE)&& + (RBTreeColorIsBlack(rsib->Right) == TRUE)) + { + RBTreeSetColor(rsib, RBRED); + rbnode = rbnode->Parent; + } + else + { + if((RBTreeColorIsBlack(rsib->Right) == TRUE)) + { + RBTreeSetColor(rsib->Left, RBBLACK); + RBTreeSetColor(rsib, RBRED); + RBTreeRightRotate(root, rsib); + rsib = rbnode->Parent->Right; + } + RBTreeSetColor(rsib, rbnode->Parent->Flags.Color); + RBTreeSetColor(rbnode->Parent, RBBLACK); + RBTreeSetColor(rsib->Right, RBBLACK); + RBTreeLeftRotate(root, rbnode->Parent); + rbnode = root->Node; + } + } + else + { + rsib = rbnode->Parent->Left; + if((RBTreeColorIsRed(rsib) == TRUE)) + { + RBTreeSetColor(rsib, RBBLACK); + RBTreeSetColor(rbnode->Parent, RBRED); + RBTreeRightRotate(root, rbnode->Parent); + rsib = rbnode->Parent->Left; + } + + if((RBTreeColorIsBlack(rsib->Right) == TRUE)&& + (RBTreeColorIsBlack(rsib->Left) == TRUE)) + { + RBTreeSetColor(rsib, RBRED); + rbnode = rbnode->Parent; + } + else + { + if((RBTreeColorIsBlack(rsib->Left) == TRUE)) + { + RBTreeSetColor(rsib->Right, RBBLACK); + RBTreeSetColor(rsib, RBRED); + RBTreeLeftRotate(root, rsib); + rsib = rbnode->Parent->Left; + } + RBTreeSetColor(rsib, rbnode->Parent->Flags.Color); + RBTreeSetColor(rbnode->Parent, RBBLACK); + RBTreeSetColor(rsib->Left, RBBLACK); + RBTreeRightRotate(root, rbnode->Parent); + rbnode = root->Node; + } + } + } + RBTreeSetColor(rbnode, RBBLACK); + return rbnode; +} + +KLINE RBTree* RBTreeRemove(RBRoot* root, RBTree* rbtree, RBRePlace reper, RBDelAfter deler) +{ + RBTree* p; + RBTree* after; + RBTree* rbtnode; + RBTree* rbtrepl; + if(NULL == rbtree || NULL == root || NULL == reper || NULL == deler) + { + return NULL; + } + rbtnode = rbtree; + p = rbtnode->Parent; + + if((NULL != rbtnode->Left) && (NULL != rbtnode->Right)) + { + after = RBTreeFindSuccessor(rbtnode); + if(NULL == after) + { + return NULL; + } + reper(rbtnode, after); + rbtnode = after; + } + + rbtrepl = rbtnode->Left != NULL ? rbtnode->Left : rbtnode->Right; + + if(NULL != rbtrepl) + { + rbtrepl->Parent = rbtnode->Parent; + if(NULL == rbtrepl->Parent) + { + root->Node = rbtrepl; + } + else if(RBTreeIsLeft(rbtnode) == TRUE) + { + rbtnode->Parent->Left = rbtrepl; + } + else + { + rbtnode->Parent->Right = rbtrepl; + } + + rbtnode->Right = rbtnode->Left = rbtnode->Parent = NULL; + + if(RBTreeColorIsBlack(rbtnode) == TRUE) + { + RBTreeRemoveAfterFix(root, rbtrepl); + } + deler(rbtnode); + } + else if(NULL == rbtnode->Parent) + { + root->Node = NULL; + deler(rbtnode); + } + else + { + if(RBTreeColorIsBlack(rbtnode) == TRUE) + { + RBTreeRemoveAfterFix(root, rbtnode); + } + if(NULL != rbtnode->Parent) + { + if(RBTreeIsLeft(rbtnode) == TRUE) + { + rbtnode->Parent->Left = NULL; + } + else if(RBTreeIsRight(rbtnode) == TRUE) + { + rbtnode->Parent->Right = NULL; + } + rbtnode->Parent = NULL; + deler(rbtnode); + } + } + return NULL; +} + +KLINE RBTree* RBTreeDelete(RBRoot* root, RBTree* rbtree, RBRePlace reper, RBDelAfter deler) +{ + RBTree* rbt; + rbt = RBTreeRemove(root, rbtree, reper, deler); + return rbt; +} + +KLINE RBTree* RBTreeMostLeft(RBRoot* root) +{ + RBTree* rbtree; + if(NULL == root) + { + return NULL; + } + rbtree = root->Node; + if(NULL == rbtree) + { + return NULL; + } + while(NULL != rbtree) + { + if(NULL != rbtree->Left) + { + rbtree = rbtree->Left; + } + else if(NULL != rbtree->Right) + { + rbtree = rbtree->Right; + } + else + { + return rbtree; + } + } + return NULL; +} + +KLINE RBTree* RBTreeMostRight(RBRoot* root) +{ + RBTree* rbtree; + if(NULL == root) + { + return NULL; + } + rbtree = root->Node; + if(NULL == rbtree) + { + return NULL; + } + while(NULL != rbtree) + { + if(NULL != rbtree->Right) + { + rbtree = rbtree->Right; + } + else if(NULL != rbtree->Left) + { + rbtree = rbtree->Left; + } + else + { + return rbtree; + } + } + return NULL; +} + + +#define RBTreeEntry(ptr, type, member) \ + ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member))) + + +#endif diff --git a/Include/HalInc/PsiInc/HalBoot.h b/Include/HalInc/PsiInc/HalBoot.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/HalInc/PsiInc/HalCPU.h b/Include/HalInc/PsiInc/HalCPU.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/HalInc/PsiInc/HalCache.h b/Include/HalInc/PsiInc/HalCache.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/HalInc/PsiInc/HalFirmware.h b/Include/HalInc/PsiInc/HalFirmware.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/HalInc/PsiInc/HalIPC.h b/Include/HalInc/PsiInc/HalIPC.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/HalInc/PsiInc/HalInterface.h b/Include/HalInc/PsiInc/HalInterface.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/HalInc/PsiInc/HalInterrupt.h b/Include/HalInc/PsiInc/HalInterrupt.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/HalInc/PsiInc/HalMMU.h b/Include/HalInc/PsiInc/HalMMU.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/HalInc/PsiInc/HalSync.h b/Include/HalInc/PsiInc/HalSync.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/HalInc/PsiInc/HalVirtual.h b/Include/HalInc/PsiInc/HalVirtual.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/HalInc/X86_64Inc/HalBoot.h b/Include/HalInc/X86_64Inc/HalBoot.h new file mode 100644 index 0000000..d16d571 --- /dev/null +++ b/Include/HalInc/X86_64Inc/HalBoot.h @@ -0,0 +1,160 @@ +/********************************************************** + 底层引导初始化头文件HalBoot.h +*********************************************************** + 彭东 +**********************************************************/ + +#ifndef _HALBOOTHEAD +#define _HALBOOTHEAD + +#define KRNL_INRAM_START 0x30000000 +#define LINK_VIRT_ADDR 0x30008000 +#define LINK_LINE_ADDR 0x30008000 +#define KERNEL_VIRT_ADDR 0x30008000 +#define KERNEL_PHYI_ADDR 0x30008000 +#define PAGE_TLB_DIR 0x30004000 +#define PAGE_TLB_SIZE 4096 +#define INIT_HEAD_STACK_ADDR 0x34000000 + +#define CPU_VECTOR_PHYADR 0x30000000 +#define CPU_VECTOR_VIRADR 0 + + +#define PTE_SECT_AP (3<<10) +#define PTE_SECT_DOMAIN (0<<5) +#define PTE_SECT_NOCW (0<<2) +#define PTE_SECT_BIT (2) + +#define PLFM_ADRSPCE_NR 29 + +#define INTSRC_MAX 32 + +#define KRNL_MAP_VIRTADDRESS_SIZE 0x400000000 +#define KRNL_VIRTUAL_ADDRESS_START 0xffff800000000000 +#define KRNL_VIRTUAL_ADDRESS_END 0xffffffffffffffff +#define USER_VIRTUAL_ADDRESS_START 0 +#define USER_VIRTUAL_ADDRESS_END 0x00007fffffffffff +#define KRNL_MAP_PHYADDRESS_START 0 +#define KRNL_MAP_PHYADDRESS_END 0x400000000 +#define KRNL_MAP_PHYADDRESS_SIZE 0x400000000 +#define KRNL_MAP_VIRTADDRESS_START KRNL_VIRTUAL_ADDRESS_START +#define KRNL_MAP_VIRTADDRESS_END (KRNL_MAP_VIRTADDRESS_START+KRNL_MAP_VIRTADDRESS_SIZE) +#define KRNL_ADDR_ERROR 0xf800000000000 + +#define MSI_PADR ((MachStartInfio*)(0x100000)) + +#define BFH_RW_R 1 +#define BFH_RW_W 2 + +#define BFH_BUF_SZ 0x1000 +#define BFH_ONERW_SZ 0x1000 +#define BFH_RWONE_OK 1 +#define BFH_RWONE_ER 2 +#define BFH_RWALL_OK 3 + +#define FDSC_NMAX 192 +#define FDSC_SZMAX 256 +#define KIMAGE_ENDMAGIC 0xaaffaaffaaffaaff +#define KIMAGE_RVMAGIC 0xffaaffaaffaaffaa + +#define KIMAGEINFO_OFF (0x1000) +#define RAM_USABLE 1 +#define RAM_RESERV 2 +#define RAM_ACPIREC 3 +#define RAM_ACPINVS 4 +#define RAM_AREACON 5 + +#define MSI_MAGIC (U64)((((U64)'C')<<56)|(((U64)'o')<<48)|(((U64)'s')<<40)|(((U64)'m')<<32)|(((U64)'o')<<24)|(((U64)'s')<<16)|(((U64)'O')<<8)|((U64)'S')) + +//Machine start-up information +typedef struct MACHSTARTINFO +{ + U64 Magic; //CosmosOS//0 + U64 CheckSum;//8 + U64 KrlInitStack;//16 + U64 KrkInitStackSZ;//24 + U64 KrlImgFilePAddr; + U64 KrlImgFileSZ; + U64 krlCoreFilePAddr; + U64 krlCoreFileSZ; + U64 krlCoreFileVec; + U64 krlCoreFileRunMode; + U64 FontPAddr; + U64 FontSZ; + U64 FramVRamPAddr; + U64 FramVRamSZ; + U64 CPUMode; + U64 MemSZ; + U64 E820PAddr; + U64 E820NR; + U64 E820SZ; + U64 E820Curr; + U64 PMSPaceAreaPAddr; + U64 PMSPaceAreaNR; + U64 PMSPaceAreaSZ; + U64 PMSPaceAreaCurr; + U64 MNodePAddr; + U64 MNodeNR; + U64 MNodeSZ; + U64 MNodeCurr; + U64 TDireArrPAddr; + U64 SubDireLen; + U64 MAPPhyMemSZ; + U64 EndPhyAddr; + U64 BrkStartAddr; + U64 BrkCurrAddr; + U64 BrkEndAddr; + Graph GraphParm; +}__attribute__((packed)) MachStartInfo; + +typedef struct E820{ + U64 Addr; /* start of memory segment8 */ + U64 Size; /* size of memory segment8 */ + U32 Type; /* type of memory segment 4*/ +}__attribute__((packed)) E820Map; + +typedef struct FILEDESC +{ + U64 Type; + U64 SubType; + U64 Status; + U64 ID; + U64 Offset; + U64 End; + U64 RealSZ; + U64 Sum; + char Name[FDSC_NMAX]; +}FileDESC; + +//Kernel Image Information +typedef struct KIMAGEINFO +{ + U64 Magic; + U64 SelfSum; + U64 SelfStart; + U64 SelfEnd; + U64 SelfSZ; + U64 LDRBlockStart; + U64 LDRBlockEnd; + U64 LDRBlockSZ; + U64 LDRBlockSum; + U64 FileDescBlockStart; + U64 FileDescBlockEnd; + U64 FileDescBlockSZ; + U64 FileDescBlockSum; + U64 FileBlockStart; + U64 FileBlockEnd; + U64 FileBlockSZ; + U64 FileBlockSum; + U64 LDRCodeNR; + U64 FileDescNR; + U64 FileNR; + U64 EndMagic; + U64 Rescv; +}KImageInfo; +public MachStartInfo* HalGetMachStartInfoAddr(); +public Addr HalBootAllocMem(Size size); +public E820Map* HalBootGetNextE820(); +private Bool HalBootInit(); +public void HalBootStart(); +#endif diff --git a/Include/HalInc/X86_64Inc/HalCPU.h b/Include/HalInc/X86_64Inc/HalCPU.h new file mode 100644 index 0000000..8c47b0e --- /dev/null +++ b/Include/HalInc/X86_64Inc/HalCPU.h @@ -0,0 +1,519 @@ +/********************************************************** + CPU头文件HalCPU.h +*********************************************************** + 彭东 +**********************************************************/ +#ifndef _HALCPUHEAD +#define _HALCPUHEAD + +#define KRNL_MAP_VIRTADDRESS_SIZE 0x400000000 +#define KRNL_VIRTUAL_ADDRESS_START 0xffff800000000000 +#define KRNL_VIRTUAL_ADDRESS_END 0xffffffffffffffff +#define USER_VIRTUAL_ADDRESS_START 0 +#define USER_VIRTUAL_ADDRESS_END 0x00007fffffffffff +#define KRNL_MAP_PHYADDRESS_START 0 +#define KRNL_MAP_PHYADDRESS_END 0x400000000 +#define KRNL_MAP_PHYADDRESS_SIZE 0x400000000 +#define KRNL_MAP_VIRTADDRESS_START KRNL_VIRTUAL_ADDRESS_START +#define KRNL_MAP_VIRTADDRESS_END (KRNL_MAP_VIRTADDRESS_START+KRNL_MAP_VIRTADDRESS_SIZE) +#define KRNL_ADDR_ERROR 0xf800000000000 + +#define NORETURN __attribute__((noreturn)) +#define SYSRCALL __attribute__((regparm(3))) +#define HINTCALL __attribute__((regparm(2))) +#define FAUTCALL __attribute__((regparm(2))) + +#define REGCALL __attribute__((regparm(3))) //让GCC使用(EAX, EDX, ECX)寄存器传递参数 + +#define SAVECPUFLAGS(x) __asm__ __volatile__("pushfl ; popl %0" : "=g"(x) : "memory") +#define RESTORECPUFLAGS(x) __asm__ __volatile__("pushl %0 ; popfl" : "g"(x) : "memory") +#define CLI() __asm__ __volatile__("cli" : : : "memory") +#define STI() __asm__ __volatile__("sti" : : : "memory") + +#define HALT() __asm__ __volatile__("hlt": : : "memory") +#define STIHALT() __asm__ __volatile__("sti; hlt": : : "memory") +#define CLIHALT() __asm__ __volatile__("cli; hlt": : : "memory") + +#define DefinedCPUArchData(vartype,varname) __attribute__((section(".cpu.core.arch.data"))) vartype varname + +#define DEVCLASSMAX 256 +#define GDTMAX 10 +#define IDTMAX 256 +#define STACKMAX 0x400 + + +#define K_CS_IDX 0x08 +#define K_DS_IDX 0x10 +#define U_CS_IDX 0x1b +#define U_DS_IDX 0x23 +#define K_TAR_IDX 0x28 +#define UMOD_EFLAGS 0x1202 + + + +/* GDT */ +/* 描述符索引 */ +#define PRIVILEGE_KRNL 0 +#define PRIVILEGE_TASK 1 +#define PRIVILEGE_USER 3 + +#define INDEX_DUMMY 0 +#define INDEX_FLAT_C 1 +#define INDEX_FLAT_RW 2 +/* 选择子 */ +#define SELECTOR_DUMMY 0 +#define SELECTOR_FLAT_C 0x08 +#define SELECTOR_FLAT_RW 0x10 + + +#define SELECTOR_KERNEL_CS SELECTOR_FLAT_C +#define SELECTOR_KERNEL_DS SELECTOR_FLAT_RW + +//TR寄存器的数据，X64TSS必须设置在GDTable中第6个段描述符的位置 +#define X64TSS_INDEX (0x30) + +/* 描述符类型值说明 */ +#define DA_64 0x2000 +#define DA_32 0x4000 /* 32 位段 */ +#define DA_LIMIT_4K 0x8000 /* 段界限粒度为 4K 字节 */ +#define DA_DPL0 0x00 /* DPL = 0 */ +#define DA_DPL1 0x20 /* DPL = 1 */ +#define DA_DPL2 0x40 /* DPL = 2 */ +#define DA_DPL3 0x60 /* DPL = 3 */ +/* 存储段描述符类型值说明 */ +#define DA_DR 0x90 /* 存在的只读数据段类型值 */ +#define DA_DRW 0x92 /* 存在的可读写数据段属性值 */ +#define DA_DRWA 0x93 /* 存在的已访问可读写数据段类型值 */ +#define DA_C 0x98 /* 存在的只执行代码段属性值 */ +#define DA_CR 0x9A /* 存在的可执行可读代码段属性值 */ +#define DA_CCO 0x9C /* 存在的只执行一致代码段属性值 */ +#define DA_CCOR 0x9E /* 存在的可执行可读一致代码段属性值 */ +/* 系统段描述符类型值说明 */ +#define DA_LDT 0x82 /* 局部描述符表段类型值 */ +#define DA_TaskGate 0x85 /* 任务门类型值 */ +#define DA_386TSS 0x89 /* 可用 386 任务状态段类型值 */ +#define DA_386CGate 0x8C /* 386 调用门类型值 */ +#define DA_386IGate 0x8E /* 386 中断门类型值 */ +#define DA_386TGate 0x8F /* 386 陷阱门类型值 */ + +/* 中断向量 */ +#define INT_VECTOR_DIVIDE 0x0 +#define INT_VECTOR_DEBUG 0x1 +#define INT_VECTOR_NMI 0x2 +#define INT_VECTOR_BREAKPOINT 0x3 +#define INT_VECTOR_OVERFLOW 0x4 +#define INT_VECTOR_BOUNDS 0x5 +#define INT_VECTOR_INVAL_OP 0x6 +#define INT_VECTOR_COPROC_NOT 0x7 +#define INT_VECTOR_DOUBLE_FAULT 0x8 +#define INT_VECTOR_COPROC_SEG 0x9 +#define INT_VECTOR_INVAL_TSS 0xA +#define INT_VECTOR_SEG_NOT 0xB +#define INT_VECTOR_STACK_FAULT 0xC +#define INT_VECTOR_PROTECTION 0xD +#define INT_VECTOR_PAGE_FAULT 0xE +#define INT_VECTOR_COPROC_ERR 0x10 +#define INT_VECTOR_ALIGN_CHEK 0x11 +#define INT_VECTOR_MACHI_CHEK 0x12 +#define INT_VECTOR_SIMD_FAULT 0x13 + +/* 中断向量 */ +#define INT_VECTOR_IRQ0 0x20 +#define INT_VECTOR_IRQ8 0x28 + +#define INT_VECTOR_APIC_IPI_SCHEDUL 0xe0 +#define INT_VECTOR_APIC_SVR 0xef +#define INT_VECTOR_APIC_TIMER 0xf0 +#define INT_VECTOR_APIC_THERMAL 0xf1 +#define INT_VECTOR_APIC_PERFORM 0xf2 +#define INT_VECTOR_APIC_LINTO 0xf3 +#define INT_VECTOR_APIC_LINTI 0xf4 +#define INT_VECTOR_APIC_ERROR 0xf5 + +#define INT_VECTOR_SYSCALL 0xFF + +typedef struct SEGMENTDESC /* 共 8 个字节 */ +{ + U16 LimitLow; /* Limit */ + U16 BaseLow; /* Base */ + U8 BaseMiddle; /* Base */ + U8 Attr1; /* P(1) DPL(2) DT(1) TYPE(4) */ + U8 LimitHighAttr2; /* G(1) D(1) 0(1) AVL(1) LimitHigh(4) */ + U8 BaseHigh; /* Base */ +}__attribute__((packed)) SegmentDesc; +/* 门描述符 */ +typedef struct GATEDESC +{ + U16 OffsetLow; /* Offset Low */ + U16 Selector; /* Selector */ + U8 DCount; /* 该字段只在调用门描述符中有效。如果在利用 + 调用门调用子程序时引起特权级的转换和堆栈 + 的改变，需要将外层堆栈中的参数复制到内层 + 堆栈。该双字计数字段就是用于说明这种情况 + 发生时，要复制的双字参数的数量。*/ + U8 Attr; /* P(1) DPL(2) DT(1) TYPE(4) */ + U16 OffsetHigh; /* Offset High */ + U32 OffsetHighH; + U32 OffsetResv; +}__attribute__((packed)) GateDesc; + +typedef struct GDTPTR +{ + U16 GDTLen; + U64 GDTBass; +}__attribute__((packed)) GDTPTR; + +typedef struct IDTPTR +{ + U16 IDTLen; + U64 IDTBass; +}__attribute__((packed)) IDTPTR; + +typedef struct X64TSS +{ + U32 Reserv0; + U64 RSP0; + U64 RSP1; + U64 RSP2; + U64 Reserv28; + U64 IST[7]; + U64 Reserv92; + U16 Reserv100; + U16 IOBase; +}__attribute__((packed)) X64TSS; + +typedef struct TSS +{ + X64TSS TSSArr[1]; +}TSS; + +typedef struct GDT +{ + SegmentDesc SegmentDescArr[GDTMAX]; +}__attribute__((packed)) GDT; + +typedef struct IDT +{ + GateDesc GateDescArr[IDTMAX]; +}__attribute__((packed)) IDT; + +typedef void (*IDTHandler)(); + + +KLINE void HalOutU8(const U16 port, const U8 val) +{ + + __asm__ __volatile__("outb %1, %0\n" + : + : "dN"(port), "a"(val)); +} + +KLINE void HalOutU8NOP(const U16 port, const U8 val) +{ + + __asm__ __volatile__("outb %1, %0\n\t" + "nop \n\t" + "nop \n\t" + "nop \n\t" + "nop \n\t" + : + : "dN"(port), "a"(val)); +} + +KLINE U8 HalInU8(const U16 port) +{ + U8 tmp; + __asm__ __volatile__("inb %1, %0\n" + : "=a"(tmp) + : "dN"(port)); + return tmp; +} + +KLINE void HalOutU16(const U16 port, const U16 val) +{ + + __asm__ __volatile__("outw %1, %0\n" + : + : "dN"(port), "a"(val)); +} + +KLINE U16 HalInU16(const U16 port) +{ + U16 tmp; + + __asm__ __volatile__("inw %1, %0\n" + : "=a"(tmp) + : "dN"(port)); + return tmp; +}; + +KLINE void HalOutU32(const U16 port, const U32 val) +{ + + __asm__ __volatile__("outl %1, %0\n" + : + : "dN"(port), "a"(val)); +} + +KLINE U32 HalInU32(const U16 port) +{ + U32 tmp; + + __asm__ __volatile__("inl %1, %0\n" + : "=a"(tmp) + : "dN"(port)); + return tmp; +} + +KLINE U64 HalReadMsr(const U32 reg) +{ + U32 eax, edx; + + __asm__ __volatile__( + "rdmsr" + : "=a"(eax), "=d"(edx) + : "c"(reg)); + + return (((U64)edx) << 32) | (U64)eax; +} + +KLINE void HalWriteMsr(const U32 reg, const U64 val) +{ + __asm__ __volatile__( + "wrmsr" + : + : "a"((U32)val), "d"((U32)(val >> 32)), "c"(reg)); +} + +KLINE void HalMemCopy(void* src, void* dest, UInt count) +{ + + U8 *ss = src, *sd = dest; + for (UInt i = 0; i < count; i++) + { + sd[i] = ss[i]; + } + return; +} + +KLINE SInt HalM2MCopy(void* sadr, void* dadr, SInt len) +{ + if (NULL == sadr || NULL == dadr || 1 > len) + { + return 0; + } + U8 *s = (U8 *)sadr, *d = (U8 *)dadr; + if (s < d) + { + for (SInt i = (len - 1); i >= 0; i--) + { + d[i] = s[i]; + } + return len; + } + if (s > d) + { + for (SInt j = 0; j < len; j++) + { + d[j] = s[j]; + } + return len; + } + if (s == d) + { + return len; + } + return 0; +} + +KLINE void HalMemSet(void *s, U8 c, UInt count) +{ + U8 *st = s; + for (UInt i = 0; i < count; i++) + { + st[i] = c; + } + return; +} + +KLINE void HalSaveFlagsCli(CPUFlg *flags) +{ + __asm__ __volatile__( + "pushfq \t\n" + "cli \t\n" + "popq %0 \t\n" + + : "=m"(*flags) + : + : "memory"); + return; +} + +KLINE void HalRestoreFlagsSti(CPUFlg *flagsres) +{ + __asm__ __volatile__( + "pushq %0 \t\n" + "popfq \t\n" + : + : "m"(*flagsres) + : "memory"); + return; +} + +KLINE void HalRestoreFlagsCli(CPUFlg *flags) +{ + __asm__ __volatile__( + "pushq %0 \t\n" + "popfq \t\n" + : "=m"(*flags) + : + : "memory"); + return; +} + +KLINE void HalSaveFlagsSti(CPUFlg *flags) +{ + __asm__ __volatile__( + "pushfq \t\n" + "popq %0\t\n" + "sti\t\n" + : + : "m"(*flags) + : "memory"); + return; +} + +KLINE U64 HalReadX86RDPMC(const int ctrsel) +{ + U32 eax, edx; + + __asm__ __volatile__( + "rdpmc" + : "=a"(eax), "=d"(edx) + : "c"(ctrsel)); + + return (((U64)edx) << 32) | (U64)eax; +} + +KLINE U64 HalReadX86RDTSC(void) +{ + U32 leax, ledx; + + __asm__ __volatile__( + "rdtsc" + : "=a"(leax), "=d"(ledx)); + + return (((U64)ledx) << 32) | (U64)leax; +} + +KLINE SInt HalSearch64RLBits(U64 val) +{ + SInt count = -1; + __asm__ __volatile__( + "bsrq %1,%q0 \t\n" + "jnz 1f \t\n" + "movq $-1,%q0 \t\n" + "1:" + : "=q"(count) + : "q"(val)); + return count; +} + +KLINE SInt HalSearch32RLBits(U32 val) +{ + SInt count = -1; + __asm__ __volatile__( + "bsrl %1,%0 \t\n" + "jnz 1f \t\n" + "movl $-1,%0 \t\n" + "1:" + : "=r"(count) + : "r"(val)); + return count; +} + +KLINE U32 HalReadKESP() +{ + U32 esp; + + __asm__ __volatile__( + "movl %%esp,%0" + : "=g"(esp) + : + : "memory"); + + return esp; +} + +KLINE U64 HalReadRSP() +{ + U64 rsp; + + __asm__ __volatile__( + "movq %%rsp,%0" + : "=g"(rsp) + : + : "memory"); + + return rsp; +} + + +KLINE void HalSetCR3(U64 val) +{ + __asm__ __volatile__( + + "movq %0,%%cr3 \n\t" + : + : "r"(val) + : "memory" + ); + return; +} + +KLINE UInt HalReadCR2() +{ + UInt regtmp = 0; + __asm__ __volatile__( + "movq %%cr2,%0\n\t" + : "=r"(regtmp) + : + : "memory"); + return regtmp; +} + +KLINE UInt HalReadCR3() +{ + UInt regtmp = 0; + __asm__ __volatile__( + "movq %%cr3,%0\n\t" + : "=r"(regtmp) + : + : "memory"); + return regtmp; +} + +KLINE void HalWriteCR3(UInt val) +{ + __asm__ __volatile__( + "movq %0,%%cr3 \n\t" + : + : "r"(val) + : "memory" //, "edx" + ); + return; +} + +public void __attribute__((optnone)) HalDead(UInt count); +public Addr HalVAddrToPAddr(Addr kvaddr); +public Addr HalPAddrToVAddr(Addr kpaddr); +private Bool SetOneGateDesc(GateDesc* gate, U8 type, IDTHandler handler, U8 privilege); +private Bool SetOneSegmentDesc(SegmentDesc* desc, U32 base, U32 limit, U16 attribute); +private Bool SetOneX64TSSAttrInSegmentDesc(SegmentDesc* desc, U64 base, U32 limit, U16 attribute); +private void CPULoadGDT(GDTPTR* gdtptr); +private void CPULoadIDT(IDTPTR* idtptr); +private void CPULoadTr(U16 trindx); +private Bool CPUInitIDT(); +private Bool CPUInitGDT(); +public Bool HalCPUInit(); +#endif diff --git a/Include/HalInc/X86_64Inc/HalCache.h b/Include/HalInc/X86_64Inc/HalCache.h new file mode 100644 index 0000000..da7c7e9 --- /dev/null +++ b/Include/HalInc/X86_64Inc/HalCache.h @@ -0,0 +1,20 @@ +/********************************************************** + Cache控制头文件HalCache.h +*********************************************************** + 彭东 +**********************************************************/ +#ifndef _HALCACHEHEAD +#define _HALCACHEHEAD +private void CacheWbinvd(); +private void CacheInvd(); +private void CacheCLFlush(void* addr); +private void CacheEnable(); +private void CacheDisable(); +public Bool HalCacheEnable(); +public Bool HalCacheDisable(); +public Bool HalCacheRefresh(); +public Bool HalCacheRefreshLine(Addr vaddr); +public Bool HalCacheInvalid(); +public Bool HalCacheInvalidLine(Addr vaddr); +public Bool HalCacheInit(); +#endif \ No newline at end of file diff --git a/Include/HalInc/X86_64Inc/HalEIIntoPoint.h b/Include/HalInc/X86_64Inc/HalEIIntoPoint.h new file mode 100644 index 0000000..b72e828 --- /dev/null +++ b/Include/HalInc/X86_64Inc/HalEIIntoPoint.h @@ -0,0 +1,308 @@ +extern syscalls_table +extern hal_hwint_allocator +extern hal_fault_allocator +extern hal_syscl_allocator + +global HalExCDivideError +global HalExCSingleStepException +global HalExCNMI +global HalExCBreakPointException +global HalExCOverflow +global HalExCBoundsCheck +global HalExCInvalOPCode +global HalExCCoprNotAvailable +global HalExCDoubleFault +global HalExCCoprSegOverrun +global HalExCInvalTSS +global HalExCSegmentNotPresent +global HalExCStackException +global HalExCGeneralProtection +global HalExCPageFault +global HalExCCoprError +global HalExCAlignmentCheck +global HalExCMachineCheck +global HalExCSimdFault +global HalExCOSDefaultFaultHandle +global HalExIHWINT00 +global HalExIHWINT01 +global HalExIHWINT02 +global HalExIHWINT03 +global HalExIHWINT04 +global HalExIHWINT05 +global HalExIHWINT06 +global HalExIHWINT07 +global HalExIHWINT08 +global HalExIHWINT09 +global HalExIHWINT10 +global HalExIHWINT11 +global HalExIHWINT12 +global HalExIHWINT13 +global HalExIHWINT14 +global HalExIHWINT15 +global HalExIHWINT16 +global HalExIHWINT17 +global HalExIHWINT18 +global HalExIHWINT19 +global HalExIHWINT20 +global HalExIHWINT21 +global HalExIHWINT22 +global HalExIHWINT23 +global HalExIApicSVR +global HalExIApicIPISchedul +global HalExIApicTimer +global HalExIApicThermal +global HalExIApicPerformonitor +global HalExIApicLint0 +global HalExIApicLint1 +global HalExIApicError +global HalExSAPICall +global HalASMRetFromUserMode +%define INT_VECTOR_IRQ0 0x20 +%define INT_VECTOR_IRQ8 0x28 +%define INT_VECTOR_APIC_IPI_SCHEDUL 0xe0 +%define INT_VECTOR_APIC_SVR 0xef +%define INT_VECTOR_APIC_TIMER 0xf0 +%define INT_VECTOR_APIC_THERMAL 0xf1 +%define INT_VECTOR_APIC_PERFORM 0xf2 +%define INT_VECTOR_APIC_LINTO 0xf3 +%define INT_VECTOR_APIC_LINTI 0xf4 +%define INT_VECTOR_APIC_ERROR 0xf5 + +%define _KERNEL_DS 0x10 +%define _NOERRO_CODE 0xffffffffffffffff + + +%macro SAVEALL 0 + + push rax + push rbx + push rcx + push rdx + push rbp + push rsi + push rdi + + push r8 + push r9 + push r10 + push r11 + push r12 + push r13 + push r14 + push r15 + + xor r14,r14 + + mov r14w,ds + push r14 + mov r14w,es + push r14 + mov r14w,fs + push r14 + mov r14w,gs + push r14 +%endmacro + +%macro RESTOREALL 0 + pop r14 + mov gs,r14w + pop r14 + mov fs,r14w + pop r14 + mov es,r14w + pop r14 + mov ds,r14w + + + pop r15 + pop r14 + pop r13 + pop r12 + pop r11 + pop r10 + pop r9 + pop r8 + + pop rdi + pop rsi + pop rbp + pop rdx + pop rcx + pop rbx + pop rax + + iretq +%endmacro + +%macro SAVEALLFAULT 0 + push rax + push rbx + push rcx + push rdx + push rbp + push rsi + push rdi + + push r8 + push r9 + push r10 + push r11 + push r12 + push r13 + push r14 + push r15 + xor r14,r14 + mov r14w,ds + push r14 + mov r14w,es + push r14 + mov r14w,fs + push r14 + mov r14w,gs + push r14 + +%endmacro + +%macro RESTOREALLFAULT 0 + + pop r14 + mov gs,r14w + pop r14 + mov fs,r14w + pop r14 + mov es,r14w + pop r14 + mov ds,r14w + + pop r15 + pop r14 + pop r13 + pop r12 + pop r11 + pop r10 + pop r9 + pop r8 + + pop rdi + pop rsi + pop rbp + pop rdx + pop rcx + pop rbx + pop rax + + add rsp,8 + iretq +%endmacro + +%macro SRFTFAULT 1 + push _NOERRO_CODE + SAVEALLFAULT + mov r14w,0x10 + mov ds,r14w + mov es,r14w + mov fs,r14w + mov gs,r14w + + mov rdi,%1 ;rdi, rsi + mov rsi,rsp + call hal_fault_allocator + RESTOREALLFAULT +%endmacro + +%macro SRFTFAULT_ECODE 1 + SAVEALLFAULT + mov r14w,0x10 + mov ds,r14w + mov es,r14w + mov fs,r14w + mov gs,r14w + + mov rdi,%1 + mov rsi,rsp + call hal_fault_allocator + RESTOREALLFAULT +%endmacro + + +%macro HARWINT 1 + SAVEALL + + mov r14w,0x10 + mov ds,r14w + mov es,r14w + mov fs,r14w + mov gs,r14w + + mov rdi, %1 + mov rsi,rsp + call hal_hwint_allocator + + RESTOREALL +%endmacro + + + +%macro EXSAPICALL 0 + + push rbx + push rcx + push rdx + push rbp + push rsi + push rdi + push r8 + push r9 + push r10 + push r11 + push r12 + push r13 + push r14 + push r15 + + xor r14,r14 + + mov r14w,ds + push r14 + mov r14w,es + push r14 + mov r14w,fs + push r14 + mov r14w,gs + push r14 + + mov r14w,0x10 + mov ds,r14w + mov es,r14w + mov fs,r14w + mov gs,r14w + + mov rdi, rax + mov rsi, rsp + call hal_syscl_allocator + + pop r14 + mov gs,r14w + pop r14 + mov fs,r14w + pop r14 + mov es,r14w + pop r14 + mov ds,r14w + pop r15 + pop r14 + pop r13 + pop r12 + pop r11 + pop r10 + pop r9 + pop r8 + + pop rdi + pop rsi + pop rbp + pop rdx + pop rcx + pop rbx + iretq +%endmacro diff --git a/Include/HalInc/X86_64Inc/HalFirmware.h b/Include/HalInc/X86_64Inc/HalFirmware.h new file mode 100644 index 0000000..e6feb0c --- /dev/null +++ b/Include/HalInc/X86_64Inc/HalFirmware.h @@ -0,0 +1,320 @@ +/********************************************************** + 固件头文件HalFirmware.h +*********************************************************** + 彭东 +**********************************************************/ + +#ifndef _HALFIRMWAREHEAD +#define _HALFIRMWAREHEAD + +typedef struct VBEINFO +{ + char VBESignature[4]; + U16 VBEVersion; + U32 OEMStringPtr; + U32 Capabilities; + U32 VideoModePtr; + U16 TotalMemory; + U16 OEMSoftWareRev; + U32 OEMVendorNamePtr; + U32 OEMProductnamePtr; + U32 OEMProductRevPtr; + U8 Reserved[222]; + U8 OEMData[256]; +}__attribute__((packed)) VBEInfo; + +typedef struct VBEOMINFO +{ + U16 ModeAttributes; + U8 WinAAttributes; + U8 WinBAttributes; + U16 WinGranularity; + U16 WinSize; + U16 WinASegment; + U16 WinBSegment; + U32 WinFuncPtr; + U16 BytesPerScanLine; + U16 XResolution; + U16 YResolution; + U8 XCharSize; + U8 YCharSize; + U8 NumberOfPlanes; + U8 BitsPerPixel; + U8 NumberOfBanks; + U8 MemoryModel; + U8 BankSize; + U8 NumberOfImagePages; + U8 Reserved; + U8 RedMaskSize; + U8 RedFieldPosition; + U8 GreenMaskSize; + U8 GreenFieldPosition; + U8 BlueMaskSize; + U8 BlueFieldPosition; + U8 RsvdMaskSize; + U8 RsvdFieldPosition; + U8 DirectColorModeInfo; + U32 PhysBasePtr; + U32 Reserved1; + U16 Reserved2; + U16 LinBytesPerScanLine; + U8 BnkNumberOfImagePages; + U8 LinNumberOfImagePages; + U8 LinRedMaskSize; + U8 LinRedFieldPosition; + U8 LinGreenMaskSize; + U8 LinGreenFieldPosition; + U8 LinBlueMaskSize; + U8 LinBlueFieldPosition; + U8 LinRsvdMaskSize; + U8 LinRsvdFieldPosition; + U32 MaxPixelClock; + U8 Reserved3[189]; +}__attribute__((packed)) VBEOMInfo; + + +#define BGRA(r,g,b) ((0|(r<<16)|(g<<8)|b)) +typedef U32 Pixl; + +#define VBEMODE 1 +#define GPUMODE 2 +#define BGAMODE 3 +typedef struct GRAPH +{ + U32 Mode; + U32 X; + U32 y; + U32 FramPHYAddr; + U32 OnePixBits; + U32 VBEModeNR; + U32 VIFPHYAddr; + U32 VMIFPHYAdrr; + U32 Bank; + U32 CurrDispBank; + U32 NextBank; + U32 BankSZ; + U32 LogoPHYAddrStart; + U32 LogoPHYAddrEnd; + U32 FontAddr; + U32 FontSectAddr; + U32 FontSectNR; + U32 FontHigh; + U32 NextCharsX; + U32 NextCharsY; + U32 LineSZ; + vbeinfo_t vbeinfo; + vbeominfo_t vminfo; +}__attribute__((packed)) Graph; + +typedef struct BMFHEAD +{ + U16 BFTag; //0x4d42 + U32 BFSize; + U16 BFResd1; + U16 BFResd2; + U32 BFOff; +}__attribute__((packed)) BMFHead; + +typedef struct BITMINFO +{ + U32 BISize; + s32_t BIWidth; + s32_t BIHigh; + U16 BIPlanes; + U16 BIBCount; + U32 BIComp; + U32 BISZImg; + s32_t BIXPelsper; + s32_t BIYPelsper; + U32 BIClrUserd; + U32 BIClrImport; +}__attribute__((packed)) BitMInfo; + +typedef struct BMDBGR +{ + U8 Blue; + U8 Green; + U8 Red; +}__attribute__((packed)) BMDBGR; + +typedef struct UTF8 +{ + U8 UByte1; + U8 UByte2; + U8 UByte3; + U8 UByte4; + U8 UByte5; + U8 UByte6; +}__attribute__((packed)) UTF8; + +typedef struct FONTFHEAD +{ + U8 fh_mgic[4]; + U32 fh_fsize; + U8 fh_sectnr; + U8 fh_fhght; + U16 fh_wcpflg; + U16 fh_nchars; + U8 fh_rev[2]; +}__attribute__((packed)) FontFHead; + +typedef struct FTSECTIF +{ + U16 Fistuc; + U16 Lastuc; + U32 Off; +}__attribute__((packed)) FTSectIF; + +typedef struct UFTINDX +{ + U32 UICharOff:26; + U32 UICharWidth:6; +}__attribute__((packed)) UTFIndx; + +#define MAX_CHARBITBY 32 + +typedef struct FONTDATA +{ + U8 FontByteSZ; + U8 FontHigh; + U8 FontWidth; + U8 FontCharMap[MAX_CHARBITBY]; +}__attribute__((packed)) FontData; + +//typedef drvstus_t (*dftghp_ops_t)(void* ghpdevp,void* inp,void* outp,UInt x,UInt y,UInt iocode); + +typedef struct GRAPHOPS +{ + Size (*GOpRead)(void* dev,void* out,Size rdsz); + Size (*GOpWrite)(void* dev,void* in,Size wesz); + SInt (*GOpIoCtrl)(void* dev,void* out,UInt iocode); + void (*GOpFlush)(void* dev); + SInt (*GOpSetBank)(void* dev, SInt bnr); + Pixl (*GOpReadpix)(void* dev,UInt x,UInt y); + void (*GOpWritePix)(void* dev,Pixl pix,UInt x,UInt y); + Pixl (*GOpDXReadPix)(void* dev,UInt x,UInt y); + void (*GOpDXWritePix)(void* dev,Pixl pix,UInt x,UInt y); + SInt (*GOpSetXY)(void* dev,UInt x,UInt y); + SInt (*GOpSetVWH)(void* dev,UInt vwt,UInt vhi); + SInt (*GOpSetXYOffset)(void* dev,UInt xoff,UInt yoff); + SInt (*GOpGetXY)(void* dev,UInt* rx,UInt* ry); + SInt (*GOpGetVWH)(void* dev,UInt* rvwt,UInt* rvhi); + SInt (*GOpGetXYOffset)(void* dev,UInt* rxoff,UInt* ryoff); +}GraphOPS; + +typedef struct DEFGRAPH +{ + SPinLock Lock; + U64 Mode; + U64 X; + U64 Y; + U64 FramPhyAddr; + U64 FvrmPhyAddr; + U64 FvrmSZ; + U64 OnePixBits; + U64 OnePixByte; + U64 VBEModeNR; + U64 Bank; + U64 CurrDispBank; + U64 NextBank; + U64 BankSZ; + U64 FontAddr; + U64 FontSZ; + U64 FontHigh; + U64 NextCharsX; + U64 NextCharsY; + U64 LineSZ; + Pixl DefFontPX; + U64 CharDefXW; + U64 Flush; + U64 FramNR; + U64 FSHData; + GraphOPS OpFunc; +}DefGraph; + +#define VBE_DISPI_IOPORT_INDEX (0x01CE) +#define VBE_DISPI_IOPORT_DATA (0x01CF) +#define VBE_DISPI_INDEX_ID (0) +#define VBE_DISPI_INDEX_XRES (1) +#define VBE_DISPI_INDEX_YRES (2) +#define VBE_DISPI_INDEX_BPP (3) +#define VBE_DISPI_INDEX_ENABLE (4) +#define VBE_DISPI_INDEX_BANK (5) +#define VBE_DISPI_INDEX_VIRT_WIDTH (6) +#define VBE_DISPI_INDEX_VIRT_HEIGHT (7) +#define VBE_DISPI_INDEX_X_OFFSET (8) +#define VBE_DISPI_INDEX_Y_OFFSET (9) +#define BGA_DEV_ID0 (0xB0C0) //- setting X and Y resolution and bit depth (8 BPP only), banked mode +#define BGA_DEV_ID1 (0xB0C1) //- virtual width and height, X and Y offset0 +#define BGA_DEV_ID2 (0xB0C2) //- 15, 16, 24 and 32 BPP modes, support for linear frame buffer, support for retaining memory contents on mode switching +#define BGA_DEV_ID3 (0xB0C3) //- support for getting capabilities, support for using 8 bit DAC +#define BGA_DEV_ID4 (0xB0C4) //- VRAM increased to 8 MB +#define BGA_DEV_ID5 (0xB0C5) //- VRAM increased to 16 MB? [TODO: verify and check for other changes] +#define VBE_DISPI_BPP_4 (0x04) +#define VBE_DISPI_BPP_8 (0x08) +#define VBE_DISPI_BPP_15 (0x0F) +#define VBE_DISPI_BPP_16 (0x10) +#define VBE_DISPI_BPP_24 (0x18) +#define VBE_DISPI_BPP_32 (0x20) +#define VBE_DISPI_DISABLED (0x00) +#define VBE_DISPI_ENABLED (0x01) +#define VBE_DISPI_LFB_ENABLED (0x40) + +private void DefGraphInit(); +private Pixl SetDefFontPx(Pixl px); +private void SetNextCharsXY(U64 x, U64 y); +private void SetCharsDXWFlush(U64 chardxw, U64 flush); +public void HalShowVersion(); +private void FillRect(Pixl pix, UInt x, UInt y, UInt tx, UInt ty); +private void FillBitMAPFile(Char* bmfname); +private void SlouSreen(UInt hy); +private void HalBackGround(); +public void HalLogo(); +public void BootVideoDeviceInit(); +private void BGAInit(); +private void VBEInit(); +private void FillGraph(DefGraph* kghp, Pixl pix); +private void WritePixColor(DefGraph* kghp, U32 x, U32 y, Pixl pix); +private void DRXWPixColor(DefGraph* kghp, U32 x, U32 y, Pixl pix); +private void FlushVideoRam(DefGraph* kghp); +private U32 Utf8ToUnicode(UTF8* utf, int* retuib); +private U8* GetCharsInfo(DefGraph* kghp, U32 unicode, int* retchwx, int* retchhx, int* retlinb); +public void PutPixOneChar(DefGraph* kghp, U32 unicode, Pixl pix); +public void DRXPutPixOneChar(DefGraph* kghp, U32 unicode, Pixl pix); +public void HalDefStringWrite(Char* buf); +private void BGAWriteReg(U16 index, U16 data); +private U16 BGAReadReg(U16 index); +private Size BGARead(void* ghpdev, void* outp, Size rdsz); +private Size BGAWrite(void* ghpdev, void* inp, Size wesz); +private SInt BGAIoCtrl(void* ghpdev, void* outp, UInt iocode); +private U64* GetVRamAddrInBank(void* ghpdev); +private void BGADispNextBank(void* ghpdev); +private void BGAFlush(void* ghpdev); +private SInt BGASetBank(void* ghpdev, SInt bnr); +private Pixl BGAReadPix(void* ghpdev, UInt x, UInt y); +private void BGAWritePix(void* ghpdev, Pixl pix, UInt x, UInt y); +private Pixl BGADXReadPix(void* ghpdev, UInt x, UInt y); +private void BGADXWritePix(void* ghpdev, Pixl pix, UInt x, UInt y); +private SInt BGASetXY(void* ghpdev, UInt x, UInt y); +private SInt BGASetVWH(void* ghpdev, UInt vwt, UInt vhi); +private SInt BGASetXYOffset(void* ghpdev, UInt xoff, UInt yoff); +private SInt BGAGetXY(void* ghpdev, UInt* rx, UInt* ry); +private SInt BGAGetVWH(void* ghpdev, UInt* rvwt, UInt* rvhi); +private SInt BGAGetXYOffset(void* ghpdev, UInt* rxoff, UInt* ryoff); +private Size VBERead(void* ghpdev, void* outp, Size rdsz); +private Size VBEWrite(void* ghpdev, void* inp, Size wesz); +private SInt VBEIoCtrl(void* ghpdev, void* outp, UInt iocode); +private void VBEFlush(void* ghpdev); +private SInt VBESetBank(void* ghpdev, SInt bnr); +private Pixl VBEReadPix(void* ghpdev, UInt x, UInt y); +private void VBEWritePix(void* ghpdev, Pixl pix, UInt x, UInt y); +private Pixl VBDXReadPix(void* ghpdev, UInt x, UInt y); +private void VBEDXWritePix(void* ghpdev, Pixl pix, UInt x, UInt y); +private SInt VBESetXY(void* ghpdev, UInt x, UInt y); +private SInt VBESetVWH(void* ghpdev, UInt vwt, UInt vhi); +private SInt VBESetXYOffset(void* ghpdev, UInt xoff, UInt yoff); +private SInt VBEGetXY(void* ghpdev, UInt* rx, UInt* ry); +private SInt VBEGetVWH(void* ghpdev, UInt* rvwt, UInt* rvhi); +private SInt VBEGetXYOffset(void* ghpdev, UInt* rxoff, UInt* ryoff); +public Bool HalFirmwareInit(); +#endif diff --git a/Include/HalInc/X86_64Inc/HalIPC.h b/Include/HalInc/X86_64Inc/HalIPC.h new file mode 100644 index 0000000..7ab142d --- /dev/null +++ b/Include/HalInc/X86_64Inc/HalIPC.h @@ -0,0 +1,9 @@ +/********************************************************** + 底层IPC通信头文件HalIPC.h +*********************************************************** + 彭东 +**********************************************************/ +#ifndef _HALIPCHEAD +#define _HALIPCHEAD +public Bool HalIPCInit(); +#endif \ No newline at end of file diff --git a/Include/HalInc/X86_64Inc/HalInterface.h b/Include/HalInc/X86_64Inc/HalInterface.h new file mode 100644 index 0000000..2bb155b --- /dev/null +++ b/Include/HalInc/X86_64Inc/HalInterface.h @@ -0,0 +1,13 @@ +/********************************************************** + 硬件抽象层接口头文件HalInterface.h +*********************************************************** + 彭东 +**********************************************************/ +#ifndef _HALINTERFACEHEAD +#define _HALINTERFACEHEAD +public PMSAD* HalExPGetKrlOnePMSAD(); +public Bool HalExPPutKrlOnePMSAD(PMSAD* msad); +public MachStartInfo* HalExPGetMachStartInfoAddr(); +public Addr HalExPBootAllocMem(Size size); +public E820Map* HalExPBootGetNextE820(); +#endif \ No newline at end of file diff --git a/Include/HalInc/X86_64Inc/HalInterrupt.h b/Include/HalInc/X86_64Inc/HalInterrupt.h new file mode 100644 index 0000000..b02a5c0 --- /dev/null +++ b/Include/HalInc/X86_64Inc/HalInterrupt.h @@ -0,0 +1,115 @@ +/********************************************************** + hal层中断处理头文件halInterrupt.h +*********************************************************** + 彭东 +**********************************************************/ +#ifndef _HALINTERRUPTHEAD +#define _HALINTERRUPTHEAD + +#define IERSD_MAX (256) +#define DefinedCPUInterData(vartype,varname) __attribute__((section(".cpu.core.interrupt.data"))) vartype varname + +typedef DrvStus (*IODCallBack)(UInt inr, void* device, void* kistacktop); + +//Interrupt exception request service descriptor +typedef struct IERSD +{ + SPinLock lock; + U32 Flags; + U32 Status; + UInt Prity; //中断优先级 + UInt InterNR; //中断号 + UInt Deep; //中断嵌套深度 + U64 Count; //中断计数 + List IODLists; + UInt IODNR; + List IODThreadLists; //中断线程链表头 + UInt IODThreadNR; //中断线程个数 + void* OneIODThread; //只有一个中断线程时直接用指针 + void* RBTreeRoot; //如果中断线程太多则按优先级组成红黑树 + void* MSGMPool; //可能的中断消息池 + void* Priv; + void* Ext; +}IERSD; + +//Interrupt object descriptor +typedef struct IOD +{ + List Lists; + List InDeviceLists; + U32 Flags; + IERSD* Parent; + void* Device; + UInt Count; + IODCallBack CallBackFunc; +}IOD; + +typedef struct IERSDT +{ + IERSD IERSDArr[IERSD_MAX]; +}IERSDT; + + +void HalExCDivideError(); +void HalExCSingleStepException(); +void HalExCNMI(); +void HalExCBreakPointException(); +void HalExCOverflow(); +void HalExCBoundsCheck(); +void HalExCInvalOPCode(); +void HalExCCoprNotAvailable(); +void HalExCDoubleFault(); +void HalExCCoprSegOverrun(); +void HalExCInvalTSS(); +void HalExCSegmentNotPresent(); +void HalExCStackException(); +void HalExCGeneralProtection(); +void HalExCPageFault(); +void HalExCCoprError(); +void HalExCAlignmentCheck(); +void HalExCMachineCheck(); +void HalExCSimdFault(); +void HalExCOSDefaultFaultHandle(); +void HalExIHWINT00(); +void HalExIHWINT01(); +void HalExIHWINT02(); +void HalExIHWINT03(); +void HalExIHWINT04(); +void HalExIHWINT05(); +void HalExIHWINT06(); +void HalExIHWINT07(); +void HalExIHWINT08(); +void HalExIHWINT09(); +void HalExIHWINT10(); +void HalExIHWINT11(); +void HalExIHWINT12(); +void HalExIHWINT13(); +void HalExIHWINT14(); +void HalExIHWINT15(); +void HalExIHWINT16(); +void HalExIHWINT17(); +void HalExIHWINT18(); +void HalExIHWINT19(); +void HalExIHWINT20(); +void HalExIHWINT21(); +void HalExIHWINT22(); +void HalExIHWINT23(); +void HalExIApicSVR(); +void HalExIApicIPISchedul(); +void HalExIApicTimer(); +void HalExIApicThermal(); +void HalExIApicPerformonitor(); +void HalExIApicLint0(); +void HalExIApicLint1(); +void HalExIApicError(); +void HalExSAPICall(); +void HalASMRetFromUserMode(); + +private Bool IERSDInit(IERSD* init, U32 flags, U32 status, UInt prity, UInt internr); +private Bool IERSDTInit(); +private Bool IODInit(IOD* init, U32 flags, IERSD* parent, void* device, IODCallBack callbackfunc); +public void HalInterDistributor(UInt internr, void* kistacktop); +public void HalFaultDistributor(UInt faultnr, void* kfstacktop); +public void HalOSAPIDistributor(UInt apinr, void* kistacktop); +public Bool HalInterruptInit(); +#endif diff --git a/Include/HalInc/X86_64Inc/HalMMU.h b/Include/HalInc/X86_64Inc/HalMMU.h new file mode 100644 index 0000000..6442c11 --- /dev/null +++ b/Include/HalInc/X86_64Inc/HalMMU.h @@ -0,0 +1,304 @@ +/********************************************************** + MMU头文件HalMMU.h +*********************************************************** + 彭东 +**********************************************************/ +#ifndef _HALMMUHEAD +#define _HALMMUHEAD + +#define TDIRE_MAX (512) +#define SDIRE_MAX (512) +#define IDIRE_MAX (512) +#define MDIRE_MAX (512) + +#define MDIRE_IV_RSHTBIT (12) +#define MDIRE_IV_BITMASK (0x1ffUL) +#define MSA_PADR_LSHTBIT (12) +#define MDIRE_PADR_LSHTBIT (12) +#define IDIRE_IV_RSHTBIT (21) +#define IDIRE_IV_BITMASK (0x1ffUL) +#define IDIRE_PADR_LSHTBIT (12) +#define SDIRE_IV_RSHTBIT (30) +#define SDIRE_IV_BITMASK (0x1ffUL) +#define SDIRE_PADR_LSHTBIT (12) +#define TDIRE_IV_RSHTBIT (39) +#define TDIRE_IV_BITMASK (0x1ffUL) + +#define PML4E_P (1 << 0) +#define PML4E_RW (1 << 1) +#define PML4E_US (1 << 2) +#define PML4E_PWT (1 << 3) +#define PML4E_PCD (1 << 4) + +#define PDPTE_P (1 << 0) +#define PDPTE_RW (1 << 1) +#define PDPTE_US (1 << 2) +#define PDPTE_PWT (1 << 3) +#define PDPTE_PCD (1 << 4) +#define PDPTE_PS (1 << 7) + +#define PDTE_P (1 << 0) +#define PDTE_RW (1 << 1) +#define PDTE_US (1 << 2) +#define PDTE_PWT (1 << 3) +#define PDTE_PCD (1 << 4) +#define PDTE_PS (1 << 7) + +#define PTE_P (1 << 0) +#define PTE_RW (1 << 1) +#define PTE_US (1 << 2) +#define PTE_PWT (1 << 3) +#define PTE_PCD (1 << 4) +#define PTE_PAT (1 << 7) +#define PDPTEPHYADR_IP_LSHTBIT (12) +#define PDTEPHYADR_IP_LSHTBIT (12) +#define PTEPHYADR_IP_LSHTBIT (12) +#define PFMPHYADR_IP_LSHTBIT (12) +#define PTE_HAVE_MASK (~0xfff) +#define PDE_HAVE_MASK (~0xfff) +#define PDPTE_HAVE_MASK (~0xfff) +#define PML4E_HAVE_MASK (~0xfff) + +//MSA目录项标志位 +typedef struct MDIREFLAGS +{ + U64 MPBit : 1; //0 + U64 MRWBit : 1; //1 + U64 MUSBit : 1; //2 + U64 MPWTBit : 1; //3 + U64 MPCDBit : 1; //4 + U64 MABit : 1; //5 + U64 MDBit : 1; //6 + U64 MPATBit : 1; //7 + U64 MGBit : 1; //8 + U64 MIG1Bit : 3; //9\10\11 + U64 MMSABit : 40; //12 + U64 MIG2Bit : 11; //52 + U64 MXDBit : 1; //63 +} __attribute__((packed)) MDireFlags; + +//MSA目录项 +typedef struct MDIRE +{ + union + { + MDireFlags MFlags; + U64 MEntry; + } __attribute__((packed)); + +} __attribute__((packed)) MDire; + +//中级目录项标志位 +typedef struct IDIREFLAGS +{ + U64 IPBit : 1; //0 + U64 IRWBit : 1; //1 + U64 IUSBit : 1; //2 + U64 IPWTBit : 1; //3 + U64 IPCDBit : 1; //4 + U64 IABit : 1; //5 + U64 IIG1Bit : 1; //6 + U64 IPSBit : 1; //74kb==0 + U64 IIG2Bit : 4; //8\9\10\11 + U64 IMDIRBit : 40; //12 + U64 IIG3Bit : 11; //52 + U64 IXDBit : 1; //63 +} __attribute__((packed)) IDireFlags; + +//中级目录项 +typedef struct IDIRE +{ + union + { + IDireFlags IFlags; + U64 IEntry; + } __attribute__((packed)); + +} __attribute__((packed)) IDire; + +//次级目录项标志位 +typedef struct SDIREFLAGS +{ + U64 SPBit : 1; //0 + U64 SRWBit : 1; //1 + U64 SUSBit : 1; //2 + U64 SPWTBit : 1; //3 + U64 SPCDBit : 1; //4 + U64 SABit : 1; //5 + U64 SIG1Bit : 1; //6 + U64 SPSBit : 1; //74kb==0 + U64 SIG2Bit : 4; //8\9\10\11 + U64 SIDIRBit : 40; //12 + U64 SIG3Bit : 11; //52 + U64 SXDBit : 1; //63 +} __attribute__((packed)) SDireFlags; + +//次级目录项 +typedef struct SDIRE +{ + union + { + SDireFlags SFlags; + U64 SEntry; + } __attribute__((packed)); + +} __attribute__((packed)) SDire; + +//顶级目录项标志位 +typedef struct TDIREFLAGS +{ + U64 TPBit : 1; //0 + U64 TRWBit : 1; //1 + U64 TUSBit : 1; //2 + U64 TPWTBit : 1; //3 + U64 TPCDBit : 1; //4 + U64 TABit : 1; //5 + U64 TIG1Bit : 1; //6 + U64 TRV1Bit : 1; //74kb==0 + U64 TIG2Bit : 4; //8\9\10\11 + U64 TSDIRBit : 40; //12 + U64 TIG3Bit : 11; //52 + U64 TXDBit : 1; //63 +} __attribute__((packed)) TDireFlags; + +//顶级目录项 +typedef struct TDIRE +{ + union + { + TDireFlags TFlags; + U64 TEntry; + } __attribute__((packed)); + +} __attribute__((packed)) TDire; + +//MSA目录 +typedef struct MDIREARR +{ + MDire MDEArr[MDIRE_MAX]; +} __attribute__((packed)) MDireArr; + +//中级目录 +typedef struct IDIREARR +{ + IDire IDEArr[IDIRE_MAX]; +} __attribute__((packed)) IDireArr; + +//次级目录 +typedef struct SDIREARR +{ + SDire SDEArr[SDIRE_MAX]; +} __attribute__((packed)) SDireArr; + +//顶级目录 +typedef struct TDIREARR +{ + TDire TDEArr[TDIRE_MAX]; +} __attribute__((packed)) TDireArr; + +//CR3寄存器标志位 +typedef struct CR3FLAGS +{ + U64 Pcid : 12; //0 + U64 Plm4a : 40; //12 + U64 Rv : 11; //52 + U64 Tbc : 1; //63 +} __attribute__((packed)) CR3Flags; + +//CR3寄存器 +typedef struct CR3 +{ + union + { + CR3Flags Flags; + U64 Entry; + } __attribute__((packed)); + +} __attribute__((packed)) CR3; + +typedef struct MMU +{ + SPinLock Lock; + U64 Status; + U64 Flags; + TDireArr *TDireArrPtr; + CR3 Cr3; + List TDirHead; + List SDirHead; + List IDirHead; + List MDirHead; + UInt TDirMsaNR; + UInt SDirMsaNR; + UInt IDirMsaNR; + UInt MDirMsaNR; +} MMU; + + +public void CR3Init(CR3* init); +public void MMUInit(MMU* init); +private UInt TDireIndex(Addr vaddr); +private UInt SDireIndex(Addr vaddr); +private UInt IDireIndex(Addr vaddr); +private UInt MDireIndex(Addr vaddr); +private void TDireArrInit(TDireArr* init); +private void SDireArrInit(SDireArr* init); +private void IDireArrInit(IDireArr* init); +private void MDireArrInit(MDireArr* init); +private Bool SDireArrIsAllZero(SDireArr* sdirearr); +private Bool SDireIsHave(TDire* tdire); +private Bool SDireIsPresence(TDire* tdire); +private Addr SDireRetPAddr(TDire* tdire); +private Addr SDireRetVAddr(TDire* tdire); +private SDireArr* TDireRetSDireArr(TDire* tdire); +private Bool IDireArrIsAllZero(IDireArr* idirearr); +private Bool IDireIsHave(SDire* sdire); +private Bool IDireIsPresence(SDire* sdire); +private Addr IDireRetPAddr(SDire* sdire); +private Addr IDireRetVAddr(SDire* sdire); +private IDireArr* SDireRetIDireArr(SDire* sdire); +private Bool MDireArrIsAllZero(MDireArr* mdirearr); +private Bool MDireIsHave(IDire* idire); +private Bool MDireIsPresence(IDire* idire); +private Addr MDireRetPAddr(IDire* idire); +private Addr MDireRetVAddr(IDire* idire); +private MDireArr* IDireRetMDireArr(IDire* idire); +private Bool MMUPMSADIsHave(MDire* mdire); +private Bool MMUPMSADIsPresence(MDire* mdire); +private Addr MMUPMSADRetPAddr(MDire* mdire); +private PMSAD* MMUNewTDireArr(MMU* mmulocked); +private Bool MMUDelTDireArr(MMU* mmulocked, TDireArr* tdirearr, PMSAD* msad); +private PMSAD* MMUNewSDireArr(MMU* mmulocked); +private Bool MMUDelSDireArr(MMU* mmulocked, SDireArr* sdirearr, PMSAD* msad); +private PMSAD* MMUNewIDireArr(MMU* mmulocked); +private Bool MMUDelIDireArr(MMU* mmulocked, IDireArr* idirearr, PMSAD* msad); +private PMSAD* MMUNewMDireArr(MMU* mmulocked); +private Bool MMUDelMDireArr(MMU* mmulocked, MDireArr* mdirearr, PMSAD* msad); +private Addr MMUUnTranslationPMSAD(MMU* mmulocked, MDireArr* mdirearr, Addr vaddr); +private Bool MMUTranslationPMSAD(MMU* mmulocked, MDireArr* mdirearr, Addr vaddr, Addr paddr, U64 flags); +private Bool MMUUnTranslationMDire(MMU* mmulocked, IDireArr* idirearr, PMSAD* msad, Addr vaddr); +private MDireArr* MMUTranslationMDire(MMU* mmulocked, IDireArr* idirearr, Addr vaddr, U64 flags, PMSAD** outmsad); +private Bool MMUUnTranslationIDire(MMU* mmulocked, SDireArr* sdirearr, PMSAD* msad, Addr vaddr); +private IDireArr* MMUTranslationIDire(MMU* mmulocked, SDireArr* sdirearr, Addr vaddr, U64 flags, PMSAD** outmsad); +private Bool MMUUnTranslationSDire(MMU* mmulocked, TDireArr* tdirearr, PMSAD* msad, Addr vaddr); +private SDireArr* MMUTranslationSDire(MMU* mmulocked, TDireArr* tdirearr, Addr vaddr, U64 flags, PMSAD** outmsad); +private Addr MMUFindPMSADAddress(MDireArr* mdirearr, Addr vaddr); +private MDireArr* MMUFindMDireArr(IDireArr* idirearr, Addr vaddr); +private IDireArr* MMUFindIDireArr(SDireArr* sdirearr, Addr vaddr); +private SDireArr* MMUFindSDireArr(TDireArr* tdirearr, Addr vaddr); +public void HalMMULoad(MMU* mmu); +private void HalMMUInnerRefresh(MMU* mmulocked); +public void HalMMURefresh(MMU* mmu); +private Addr HalUnMMUTranslationCore(MMU* mmu, Addr vaddr); +public Addr HalUnMMUTranslation(MMU* mmu, Addr vaddr); +private Bool HalMMUTranslationCore(MMU* mmu, Addr vaddr, Addr paddr, U64 flags); +public Bool HalMMUTranslation(MMU* mmu, Addr vaddr, Addr paddr, U64 flags); +private Bool MMUCleanMDireArrAllPMSAD(MMU* mmulocked); +private Bool MMUCleanIDireArrAllPMSAD(MMU* mmulocked); +private Bool MMUCleanSDireArrAllPMSAD(MMU* mmulocked); +private Bool MMUCleanTDireArrAllPMSAD(MMU* mmulocked); +public Bool HalMMUClean(); +public Bool HalMMUInitExecutorTDireArr(MMU* mmu); +public Bool HalMMUEnable(); +public Bool HalMMUDisable(); +public Bool HalMMUInit(); +#endif diff --git a/Include/HalInc/X86_64Inc/HalSync.h b/Include/HalInc/X86_64Inc/HalSync.h new file mode 100644 index 0000000..60be885 --- /dev/null +++ b/Include/HalInc/X86_64Inc/HalSync.h @@ -0,0 +1,29 @@ +/********************************************************** + 同步头文件HalSync.h +*********************************************************** + 彭东 +**********************************************************/ +#ifndef _HALSYNCHEAD +#define _HALSYNCHEAD + + +typedef struct SPINLOCK +{ + volatile U32 Lock; +}SPinLock; + +public void HalHalt(); +public void HalCliHalt(); +public void HalStiHalt(); +public void HalSti(); +public void HalCli(); +public void HalStiFlags(CPUFlg* cpuflg); +public void HalCliFlags(CPUFlg* cpuflg); +public void HalFlagsSti(CPUFlg* cpuflg); +public void HalFlagsCli(CPUFlg* cpuflg); +public void SPinLockInit(SPinLock *init); +public void HalSPinLock(SPinLock *lock); +public void HalUnSPinLock(SPinLock *lock); +public void HalSPinLockSaveFlagsCli(SPinLock *lock, CPUFlg *cpuflg); +public void HalUnSPinLockRestoreFlagsSti(SPinLock *lock, CPUFlg *cpuflg); +#endif \ No newline at end of file diff --git a/Include/HalInc/X86_64Inc/HalVirtual.h b/Include/HalInc/X86_64Inc/HalVirtual.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/HalInc/X86_64Inc/OSLinker.h b/Include/HalInc/X86_64Inc/OSLinker.h new file mode 100644 index 0000000..78bfbf6 --- /dev/null +++ b/Include/HalInc/X86_64Inc/OSLinker.h @@ -0,0 +1,14 @@ +/****************************************************************** +* ld自动化链接脚本头文件OSLinker.h * +* 彭东 * +******************************************************************/ +#ifndef _OSLINKERHEAD +#define _OSLINKERHEAD + +#define LINEAR_ADDRESS 0x2000000 +#define VIRTUAL_ADDRESS 0xffff800000000000 +#define OSONARCH i386:x86-64 +#define OSONFORMAT elf64-x86-64 +#define OSSTARTPOINT InitEntryStart + +#endif diff --git a/Include/KernelInc/ExecutorInc/KrlExecutor.c b/Include/KernelInc/ExecutorInc/KrlExecutor.c new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/ExecutorInc/KrlExecutorCom.c b/Include/KernelInc/ExecutorInc/KrlExecutorCom.c new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/ExecutorInc/KrlExecutorInterface.c b/Include/KernelInc/ExecutorInc/KrlExecutorInterface.c new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/ExecutorInc/KrlExecutorManage.c b/Include/KernelInc/ExecutorInc/KrlExecutorManage.c new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/ExecutorInc/KrlExecutorRes.c b/Include/KernelInc/ExecutorInc/KrlExecutorRes.c new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/ExecutorInc/KrlExecutorSync.c b/Include/KernelInc/ExecutorInc/KrlExecutorSync.c new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/ExecutorInc/KrlThread.c b/Include/KernelInc/ExecutorInc/KrlThread.c new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/ExecutorInc/KrlTransfer.c b/Include/KernelInc/ExecutorInc/KrlTransfer.c new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/KrlInit.h b/Include/KernelInc/KrlInit.h new file mode 100644 index 0000000..4a8d652 --- /dev/null +++ b/Include/KernelInc/KrlInit.h @@ -0,0 +1,9 @@ +/**************************************************************** + Kernel层初始化头文件KrlInit.h +***************************************************************** + 彭东 +****************************************************************/ +#ifndef _KRLINITHEAD +#define _KRLINITHEAD +public void KrlCoreInit(); +#endif diff --git a/Include/KernelInc/KrlLog.h b/Include/KernelInc/KrlLog.h new file mode 100644 index 0000000..403d3b3 --- /dev/null +++ b/Include/KernelInc/KrlLog.h @@ -0,0 +1,23 @@ +/**************************************************************** + Kernel层日志头文件KrlLog.h +***************************************************************** + 彭东 +****************************************************************/ + +#ifndef _KRLLOGHEAD +#define _KRLLOGHEAD + +typedef __builtin_va_list VAList; +#define VA_START(ap,np) __builtin_va_start(ap,np) +#define VA_END(ap) __builtin_va_end(ap) +#define VA_ARG(ap,ty) __builtin_va_arg(ap,ty) + +private Char* FmtNumber(Char* str, UInt n, SInt base); +private Char* FmtStrCopy(Char* buf, Char* str); +private void FmtCore(Char* buf, const Char* fmt, VAList args); +public void KrlPrint(const Char* fmt, ...); +public void KrlLog(UInt level, const Char* fmt, ...); +public void KrlErrorCrashDead(const Char* fmt, ...); +public Bool KrlLogInit(); + +#endif \ No newline at end of file diff --git a/Include/KernelInc/MemoryInc/KrlMmAlloc.h b/Include/KernelInc/MemoryInc/KrlMmAlloc.h new file mode 100644 index 0000000..b177bde --- /dev/null +++ b/Include/KernelInc/MemoryInc/KrlMmAlloc.h @@ -0,0 +1,46 @@ +/********************************************************** + 物理内存分配头文件KrlMmAlloc.h +*********************************************************** + 彭东 +**********************************************************/ + +#ifndef _KRLMMALLOCHEAD +#define _KRLMMALLOCHEAD + +#define KMAF_DEFAULT (0) +#define DEFAULT_NODE_ID (0) +#define INIT_AREA_ID (MA_TYPE_INIT) +#define HWAD_AREA_ID (MA_TYPE_HWAD) +#define KERN_AREA_ID (MA_TYPE_KRNL) +#define USER_AREA_ID (MA_TYPE_PROC) +#define SHAR_AREA_ID (MA_TYPE_SHAR) +private SInt ForPmsadNrRetOrder(UInt msadnr); +private PABHList* ForPmsadNrRetPABListOnMArea(MNode* node, MArea* area, UInt msadnr); +private PABHList* ForPmsadNrRetAllocPABListOnMArea(MNode* node, MArea* area, UInt msadnr); +private PMSAD* PickPMSADsOnPABHList(PABHList* abhlist); +private Bool PutsPMSADsOnPABHList(PABHList* abhlist, PMSAD* msad, PMSAD* msadend, UInt order); +private PMSAD* OperationAfterAllocPMSADs(PABHList* abhlist, PMSAD* start, PMSAD* end); +private PMSAD* AllocPMSADsOnPABHList(MNode* node, MArea* area, PABHList* abhlist, PABHList* allocbhlist, UInt msadnr); +private PMSAD* KrlMmAllocPMSADsRealizeCore(GMemManage* gmm, MNode* node, MArea* area, UInt msadnr, U64 flags); +private PMSAD* KrlMmAllocPMSADsRealize(UInt nodeid, UInt areaid, UInt msadnr, U64 flags); +public U64 KrlMmGetPMSADsLen(PMSAD* msad); +public U64 KrlMmGetPMSADsSize(PMSAD* msad); +public PMSAD* KrlMmGetPMSADsEnd(PMSAD* msad); +public Addr KrlMmGetPMSADsRangeVStart(PMSAD* msad); +public Addr KrlMmGetPMSADsRangeVEnd(PMSAD* msad); +public PMSAD* KrlMmAllocPMSADs(UInt nodeid, UInt areaid, UInt msadnr, U64 flags); +public PMSAD* KrlMmAllocKernPMSADs(UInt msadnr); +public PMSAD* KrlMmAllocUserPMSADs(UInt msadnr); +private UInt OperationBeforeFreePMSADs(PABHList* abhlist, PMSAD* start, PMSAD* end); +private Bool CheckOnePMSADBlock(PABHList* abhlist, PMSAD* mblockstart, PMSAD* mblockend); +private Bool ClearPMSADTowBlockFlags(PABHList* abhlist, PMSAD* _1mblocks, PMSAD* _1mblocke, PMSAD* _2mblocks, PMSAD* _2mblocke); +private UInt PMSADTowBlockIsOk(PABHList* abhlist, PMSAD* _1mblocks, PMSAD* _1mblocke, PMSAD* _2mblocks, PMSAD* _2mblocke); +private UInt FindContinuousPMSADsBlock(PABHList* abhlist, PMSAD** msadstart, PMSAD** msadend); +private Bool FreePMSADsOnPABHList(MNode* node, MArea* area, PABHList* abhlist, PABHList* freebhlist, PMSAD* msad, UInt msadnr); +private Bool KrlMmFreePMSADsRealizeCore(GMemManage* gmm, MNode* node, MArea* area, PMSAD* msad, U64 flags); +private Bool KrlMmFreePMSADsRealize(PMSAD* msad, U64 flags); +public Bool KrlMmFreePMSADs(PMSAD* msad, U64 flags); +public Bool KrlMmFreeKernPMSADs(PMSAD* msad); +public Bool KrlMmFreeUserPMSADs(PMSAD* msad); + +#endif diff --git a/Include/KernelInc/MemoryInc/KrlMmCache.h b/Include/KernelInc/MemoryInc/KrlMmCache.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/MemoryInc/KrlMmInterface.h b/Include/KernelInc/MemoryInc/KrlMmInterface.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/MemoryInc/KrlMmManage.h b/Include/KernelInc/MemoryInc/KrlMmManage.h new file mode 100644 index 0000000..2d32914 --- /dev/null +++ b/Include/KernelInc/MemoryInc/KrlMmManage.h @@ -0,0 +1,764 @@ +/********************************************************** + 物理内存管理头文件KrlMmManage.h +*********************************************************** + 彭东 +**********************************************************/ +#ifndef _KRLMMMANAGEHEAD +#define _KRLMMMANAGEHEAD + +#include "HalSync.h" +#include "HalBoot.h" + +#define MSAD_PADR_SLBITS (12) +#define MSAD_PAGE_MAX (8) +#define MSAD_SIZE (1 << MSAD_PADR_SLBITS) +#define MSAD_ALIGN(n) ALIGN(n, MSAD_SIZE) +#define MSAD_MASK (~(MSAD_SIZE-1)) + +#define MF_P_INIT (0) +#define MF_P_PRESENT (1) + + +#define MF_OLKTY_INIT (0) +#define MF_OLKTY_ODER (1) +#define MF_OLKTY_BAFH (2) +#define MF_OLKTY_TOBJ (3) + +#define MF_LSTTY_LIST (0) +#define MF_MOCTY_FREE (0) +#define MF_MOCTY_KRNL (1) +#define MF_MOCTY_USER (2) +#define MF_MRV1_VAL (0) +#define MF_UINDX_INIT (0) +#define MF_UINDX_MAX (0xffffff) +#define MF_MARTY_INIT (0) +#define MF_MARTY_HWD (1) +#define MF_MARTY_KRL (2) +#define MF_MARTY_PRC (3) +#define MF_MARTY_SHD (4) + +#define PAF_ALLOC (1) +#define PAF_NO_ALLOC (0) +#define PAF_SHARED (1) +#define PAF_NO_SHARED (0) +#define PAF_SWAP (1) +#define PAF_NO_SWAP (0) +#define PAF_CACHE (1) +#define PAF_NO_CACHE (0) +#define PAF_KMPOOL (1) +#define PAF_NO_KMPOOL (0) +#define PAF_LOCK (1) +#define PAF_NO_LOCK (0) +#define PAF_RV2_VAL (0) +#define PAF_INIT_PADRS (0) + +#define MA_TYPE_INIT 0 +#define MA_TYPE_HWAD 1 +#define MA_TYPE_KRNL 2 +#define MA_TYPE_PROC 3 +#define MA_TYPE_SHAR 4 +#define MEMAREA_MAX 5 +#define MA_HWAD_LSTART 0 +#define MA_HWAD_LSZ 0x2000000 +#define MA_HWAD_LEND (MA_HWAD_LSTART+MA_HWAD_LSZ-1) +#define MA_KRNL_LSTART 0x2000000 +#define MA_KRNL_LSZ (0x400000000-0x2000000) +#define MA_KRNL_LEND (MA_KRNL_LSTART+MA_KRNL_LSZ-1) +#define MA_PROC_LSTART 0x400000000 +#define MA_PROC_LSZ (0xffffffffffffffff-0x400000000) +#define MA_PROC_LEND (MA_PROC_LSTART+MA_PROC_LSZ) + +#define PABH_STUS_INIT 0 +#define PABH_STUS_ONEM 1 +#define PABH_STUS_DIVP 2 +#define PABH_STUS_DIVM 3 + +#define MSPLMER_ARR_LMAX 52 +#define MSPLMER_ARR_BMAX 11 +#define MSPLMER_ARR_OMAX 9 + +#define PMSA_T_OSAPUSERRAM 1 +#define PMSA_T_RESERVRAM 2 +#define PMSA_T_HWUSERRAM 8 +#define PMSA_T_ARACONRAM 0xf +#define PMSA_T_BUGRAM 0xff +#define PMSA_F_X86_32 (1<<0) +#define PMSA_F_X86_64 (1<<1) +#define PMSA_F_ARM_32 (1<<2) +#define PMSA_F_ARM_64 (1<<3) +#define PMSA_F_HAL_MASK 0xff + +#define MEMDATA_SECTION __attribute__((section(".mem.data"))) +#define DefinedMEMData(vartype,varname) MEMDATA_SECTION vartype varname + +#define PMSADDIRE_MAX (1 << 18) +#define PMSADDIRE_INDEX_BITS (30) +#define PMSADDIRE_SIZE (1 << PMSADDIRE_INDEX_BITS) +#define PMSADDIRE_PMSAD_NR (PMSADDIRE_SIZE >> MSAD_PADR_SLBITS) +//PMSAD标志 +typedef struct PMSADFLAGS +{ + U32 OLTypeBit:2; + U32 InListBit:1; + U32 OccupancyTypeBit:2; + U32 AreaTypeBit:3; + U32 PresentBit:2; + U32 RefCountBit:22; +}__attribute__((packed)) PMSADFlags; + +//物理地址及其标志 +typedef struct PHYADDRFLAGS +{ + U64 AllocBit:1; + U64 SharedBit:1; + U64 SwapBit:1; + U64 CacheBit:1; + U64 LockBit:1; + U64 KMPoolBit:1; + U64 ReservedBit:6; + U64 PAddrBit:52; +}__attribute__((packed)) PhyAddrFlags; + +//物理内存空间地址描述述 +//Physical memory space address descriptor +typedef struct PMSAD +{ + List Lists;//16 + SPinLock Lock; //4 + PMSADFlags CountFlags;//4 + PhyAddrFlags PhyAddr;//8 + void* BlockLink;//8 +}__attribute__((packed)) PMSAD;//16+24 + +typedef struct MLOCK +{ + SPinLock Locks; + //SEM +}MLock; + +//Physical memory space area +//物理内存空间区域 +typedef struct PHYMSPACEAREA +{ + U32 Type; + U32 SubType; + U32 DevType; + U32 Flags; + U32 Status; + U64 Start; + U64 Size; + U64 End; + U64 ResvMemStart; + U64 ResvMemEnd; + void* Pri; + void* Ext; +}PHYMSPaceArea; + +//Physical Address Block Head List +//物理地址块头链 +typedef struct PABHLIST +{ + MLock Lock; + U32 Status; + UInt Order; + UInt InOrderPmsadNR; + UInt FreePmsadNR; + UInt PmsadNR; + UInt AllocCount; + UInt FreeCount; + List FreeLists; + List AllocLists; + List OveLists; +}PABHList; + +//Memory Splitting and Merging +//内存拆分合并结构 +typedef struct MSPLITMER +{ + MLock Lock; + U32 Status; + UInt MaxSMNR; + UInt PhySMNR; + UInt PreSMNR; + UInt SPlitNR; + UInt MerNR; + PABHList PAddrBlockArr[MSPLMER_ARR_LMAX]; + PABHList OnePAddrBlock; +}MSPlitMer; + + +//0x400000000 0x40000000 +//Memory Area +//物理内存区 +typedef struct MAREA +{ + List Lists; + MLock Lock; + U64 AreaId; + UInt Status; + UInt Flags; + UInt Type; + UInt MaxPMSAD; + UInt AllocPMSAD; + UInt FreePMSAD; + UInt ResvPMSAD; + UInt HorizLine; + Addr LogicStart; + Addr LogicEnd; + UInt LogicSZ; + Addr EffectStart; + Addr EffectEnd; + UInt EffectSZ; + List AllPMSADLists; + UInt AllPMSADNR; + MSPlitMer MSPLMerData; + void* Priv; + void* Ext; + /* + *这个结构至少占用一个页面，当然 + *也可以是多个连续的的页面，但是 + *该结构从第一个页面的首地址开始 + *存放，后面的空间用于存放实现分 + *配算法的数据结构，这样每个区可 + *方便的实现不同的分配策略，或者 + *有天你觉得我的分配算法是渣渣， + *完全可以替换mafuncobjs_t结构 + *中的指针，指向你的函数。 + */ +}MArea; + +//PMSAD 目录项 +typedef struct PMSADDIRE +{ + union + { + PMSAD* DireStart; + U64 Entry; + }__attribute__((packed)); +}__attribute__((packed)) PMSADDire; + +//PMSAD 目录数组 +typedef struct PMSADDIREARR +{ + PMSADDire PMSADEArr[PMSADDIRE_MAX]; +}PMSADDireArr; + + +/* +Memory Node +内存节点 +*/ +typedef struct MNode +{ + List Lists; + MLock Lock; + UInt Status; + UInt Flags; + UInt NodeID; + UInt CPUID; + Addr NodeMemAddrStart; + Addr NodeMemAddrEnd; + PHYMSPaceArea* PMSAreaPtr; + U64 PMSAreaNR; + U64 NodeMemSize; + Addr NodeMemResvAddrStart; + Addr NodeMemResvAddrEnd; + U64 NodeMemResvSize; + MArea MAreaArr[MEMAREA_MAX]; + PMSADDireArr PMSADDir; +}MNode; +//Global Memory Manage +//全局内存管理 +typedef struct GMEMMANAGE +{ + MLock Lock; + U64 Status; + U64 Flags; + U64 MemroySZ; + U64 MaxPMSAD; + U64 FreePMSAD; + U64 AllocPMSAD; + U64 ResvPMSAD; + PHYMSPaceArea* PAreaStart; + U64 PAreaNR; + MNode* MNodeStart; + U64 MNodeNR; + void* Priv; + void* Ext; +}GMemManage; + +DefinedMEMData(GMemManage, GMemManageData); + + +KLINE Addr PMSADRetPAddr(PMSAD* msad) +{ + if(NULL == msad) + { + return NULL; + } + return (msad->PhyAddr.PAddrBit << MSAD_PADR_SLBITS); +} + +KLINE Addr PMSADRetVAddr(PMSAD* msad) +{ + if(NULL == msad) + { + return NULL; + } + return HalPAddrToVAddr(PMSADRetPAddr(msad)); +} + +KLINE Bool PMSADIsAdjacent(PMSAD* curr, PMSAD* next) +{ + Addr curraddr = 0; + Addr nextaddr = 0; + + if((curr + 1) != next) + { + return FALSE; + } + curraddr = PMSADRetPAddr(curr); + nextaddr = PMSADRetPAddr(next); + if((nextaddr - curraddr) != MSAD_SIZE) + { + return FALSE; + } + return TRUE; +} + +KLINE Bool PMSADIsFree(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + if(MF_MOCTY_FREE != msad->CountFlags.OccupancyTypeBit || + 0 != msad->CountFlags.RefCountBit || PAF_NO_ALLOC != msad->PhyAddr.AllocBit) + { + return FALSE; + } + return TRUE; +} + +KLINE Bool PMSADIsFreeAlsoAdjacent(PMSAD* curr, PMSAD* next) +{ + if((PMSADIsFree(curr) == TRUE) && (PMSADIsFree(next) == TRUE)) + { + if(PMSADIsAdjacent(curr, next) == TRUE) + { + return TRUE; + } + } + return FALSE; +} + +KLINE Bool PMSADIsEQAreaType(PMSAD* msad, UInt areatype) +{ + UInt type = 0; + IF_NULL_DEAD(msad); + type = (UInt)(msad->CountFlags.AreaTypeBit); + if(type == areatype) + { + return TRUE; + } + return FALSE; +} + +KLINE Bool PMSADIsMArea(PMSAD* msad, MArea* area) +{ + Addr phyaddr = 0; + IF_NULL_RETURN_FALSE(msad); + IF_NULL_RETURN_FALSE(area); + if(PMSADIsEQAreaType(msad, area->Type) == FALSE) + { + return FALSE; + } + + phyaddr = PMSADRetPAddr(msad); + if(area->LogicStart <= phyaddr && phyaddr < area->LogicEnd) + { + return TRUE; + } + return FALSE; +} + +KLINE Bool PMSADIsPresent(PMSAD* msad) +{ + IF_NULL_RETURN_FALSE(msad); + if(MF_P_PRESENT == msad->CountFlags.PresentBit) + { + return TRUE; + } + return FALSE; +} + +KLINE void SetPMSADPresent(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + msad->CountFlags.PresentBit = MF_P_PRESENT; + return; +} + +KLINE void ClearPMSADPresent(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + msad->CountFlags.PresentBit = MF_P_INIT; + return; +} + +KLINE void SetPMSADOLType(PMSAD* msad, U32 oltype) +{ + IF_NULL_DEAD(msad); + if(MF_OLKTY_TOBJ < oltype) + { + return; + } + msad->CountFlags.OLTypeBit = oltype; + return; +} + +KLINE U32 RetPMSADOLType(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + return (U32)(msad->CountFlags.OLTypeBit); +} + +KLINE void SetPMSADOccupancyType(PMSAD* msad, U32 occupancytype) +{ + IF_NULL_DEAD(msad); + if(MF_MOCTY_USER < occupancytype) + { + return; + } + msad->CountFlags.OccupancyTypeBit = occupancytype; + return; +} + +KLINE void SetPMSADPAddr(PMSAD* msad, U64 paddr) +{ + U64 phyaddr = 0; + PhyAddrFlags* pf = NULL; + IF_NULL_DEAD(msad); + + phyaddr = paddr; + pf = (PhyAddrFlags*)(&phyaddr); + msad->PhyAddr.PAddrBit = pf->PAddrBit; + return; +} + +KLINE void SetPMSADAlloc(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + msad->PhyAddr.AllocBit = PAF_ALLOC; + return; +} + +KLINE void ClearPMSADAlloc(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + msad->PhyAddr.AllocBit = 0; + return; +} + +KLINE void SetPMSADShare(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + msad->PhyAddr.SharedBit = PAF_SHARED; + return; +} + +KLINE void ClearPMSADShare(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + msad->PhyAddr.SharedBit = PAF_NO_SHARED; + return; +} + +KLINE Bool PMSADIsShare(PMSAD* msad) +{ + IF_NULL_RETURN_FALSE(msad); + if(PAF_SHARED == msad->PhyAddr.SharedBit) + { + return TRUE; + } + return FALSE; +} + +KLINE void SetPMSADSwap(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + msad->PhyAddr.SwapBit = PAF_SWAP; + return; +} + +KLINE void ClearPMSADSwap(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + msad->PhyAddr.SwapBit = PAF_NO_SWAP; + return; +} + +KLINE Bool PMSADIsSwap(PMSAD* msad) +{ + IF_NULL_RETURN_FALSE(msad); + if(PAF_SWAP == msad->PhyAddr.SwapBit) + { + return TRUE; + } + return FALSE; +} + +KLINE void SetPMSADCache(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + msad->PhyAddr.CacheBit = PAF_CACHE; + return; +} + +KLINE void ClearPMSADCache(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + msad->PhyAddr.CacheBit = PAF_NO_CACHE; + return; +} + +KLINE Bool PMSADIsCache(PMSAD* msad) +{ + IF_NULL_RETURN_FALSE(msad); + if(PAF_CACHE == msad->PhyAddr.CacheBit) + { + return TRUE; + } + return FALSE; +} + +KLINE void SetPMSADLock(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + msad->PhyAddr.LockBit = PAF_LOCK; + return; +} + +KLINE void ClearPMSADLock(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + msad->PhyAddr.LockBit = PAF_NO_LOCK; + return; +} + +KLINE Bool PMSADIsLock(PMSAD* msad) +{ + IF_NULL_RETURN_FALSE(msad); + if(PAF_LOCK == msad->PhyAddr.LockBit) + { + return TRUE; + } + return FALSE; +} + +KLINE void SetPMSADKMPool(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + msad->PhyAddr.KMPoolBit = PAF_KMPOOL; + return; +} + +KLINE void ClearPMSADKMPool(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + msad->PhyAddr.KMPoolBit = PAF_NO_KMPOOL; + return; +} + +KLINE Bool PMSADIsKMPool(PMSAD* msad) +{ + IF_NULL_RETURN_FALSE(msad); + if(PAF_KMPOOL == msad->PhyAddr.KMPoolBit) + { + return TRUE; + } + return FALSE; +} + +KLINE void SetPMSADBlockLink(PMSAD* msad, void* link) +{ + IF_NULL_DEAD(msad); + msad->BlockLink = link; + return; +} + +KLINE void ClearPMSADBlockLink(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + msad->BlockLink = NULL; + return; +} + +KLINE void* RetPMSADBlockLink(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + return msad->BlockLink; +} + +KLINE void GetPMSAD(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + if(MF_UINDX_MAX <= msad->CountFlags.RefCountBit) + { + return; + } + msad->CountFlags.RefCountBit++; + return; +} + +KLINE void PutPMSAD(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + if(1 > msad->CountFlags.RefCountBit) + { + return; + } + msad->CountFlags.RefCountBit--; + return; +} + +KLINE UInt RetPMSADRefCount(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + return (UInt)msad->CountFlags.RefCountBit; +} + + +KLINE GMemManage* KrlMmGetGMemManageAddr() +{ + return &GMemManageData; +} + +KLINE UInt PMSADDireIndex(U64 phyaddr) +{ + return (UInt)(phyaddr >> PMSADDIRE_INDEX_BITS); +} + +KLINE UInt PMSADIndex(U64 phyaddr) +{ + return (UInt)((phyaddr & (PMSADDIRE_SIZE -1)) >> MSAD_PADR_SLBITS); +} + +KLINE MNode* PHYAddrRetMNode(U64 phyaddr) +{ + GMemManage* gmm = NULL; + MNode* node = NULL; + gmm = KrlMmGetGMemManageAddr(); + for(U64 i = 0; i < gmm->MNodeNR; i++) + { + node = &gmm->MNodeStart[i]; + if(phyaddr < node->NodeMemAddrEnd && phyaddr > node->NodeMemAddrStart) + { + return node; + } + } + return NULL; +} + +KLINE PMSADDire* PHYAddrRetPMSADDire(U64 phyaddr) +{ + PMSADDire* dire = NULL; + MNode* node = NULL; + UInt index = PMSADDIRE_MAX; + node = PHYAddrRetMNode(phyaddr); + IF_NULL_RETURN_NULL(node); + index = PMSADDireIndex(phyaddr); + return &(node->PMSADDir.PMSADEArr[index]); +} + +KLINE PMSAD* PHYAddrRetPMSAD(U64 phyaddr) +{ + PMSADDire* dire = NULL; + dire = PHYAddrRetPMSADDire(phyaddr); + IF_NULL_RETURN_NULL(dire); + return &dire->DireStart[PMSADIndex(phyaddr)]; +} + +KLINE MNode* PMSADRetItsMNode(PMSAD* msad) +{ + U64 phyaddr = 0; + MNode* node = NULL; + IF_NULL_RETURN_NULL(msad); + phyaddr = PMSADRetPAddr(msad); + node = PHYAddrRetMNode(phyaddr); + return node; +} + +KLINE MArea* PMSADRetItsMArea(PMSAD* msad) +{ + MNode* node = NULL; + MArea* area = NULL; + IF_NULL_RETURN_NULL(msad); + node = PMSADRetMNode(msad); + IF_NULL_RETURN_NULL(node); + area = node->MAreaArr; + for(UInt i = 0; i < MEMAREA_MAX; i++) + { + if(PMSADIsMArea(msad, &area[i]) == TRUE) + { + return &area[i]; + } + } + return NULL; +} + +KLINE Bool PMSADDireIsHave(PMSADDire* dire) +{ + IF_NULL_DEAD(dire); + if(0 < dire->Entry) + { + return TRUE; + } + return FALSE; +} + +private void MLockInit(MLock* init); +private void PHYMSPaceAreaInit(PHYMSPaceArea* init); +private void PMSADInit(PMSAD* init); +private void PABHListInit(PABHList* init); +private void MSPlitMerInit(MSPlitMer* init); +private void MAreaInit(MArea* init); +private void MNodeInit(MNode* init); +private void GMemManageInit(GMemManage* init); +public Bool KrlMmUPAddGMMAllocMaxFreeNR(UInt allocnr, UInt maxnr, UInt freenr); +public Bool KrlMmUPAddMNodeAreaAllocMaxFreeNR(MNode* node, MArea* area, UInt allocnr, UInt maxnr, UInt freenr); +public Bool KrlMmUPSubGMMAllocMaxFreeNR(UInt allocnr, UInt maxnr, UInt freenr); +public Bool KrlMmUPSubMNodeAreaAllocMaxFreeNR(MNode* node, MArea* area, UInt allocnr, UInt maxnr, UInt freenr); +public void KrlMmLocked(MLock* lock); +public void KrlMmUnLock(MLock* lock); +private Bool NewOnePHYMSPaceArea(E820Map* e820, PHYMSPaceArea* area); +private void PHYMSPaceAreaSwap(PHYMSPaceArea *s, PHYMSPaceArea *d); +private void PHYMSPaceAreaSort(PHYMSPaceArea* area, U64 nr); +private Bool SetPMSADInMNodeMAreaInfo(MNode* node, PMSAD* msad); +private PMSAD* NewOnePMSAD(MNode* node, PHYMSPaceArea* area, PMSADDire* dire, U64 paddr); +private UInt PMSADInitOnPHYMSPaceArea(MNode* node, PMSADDire* dire, PHYMSPaceArea* area, U64 start, U64 end); +private PMSAD* PMSADDireIsNeedAllocMemory(U64 start, U64 end); +private Bool PMSADInitOnMNode(MNode* node); +private Bool ScanOccupancyPMSADOnAddr(Addr start, Addr end); +public Bool KrlMmScanOccupancyPMSAD(); +public Bool KrlMmPMSADInit(); +public Bool KrlMmPHYMSPaceAreaInit(); +public Bool PMSADAddInPABHList(PABHList* pabhl, PMSAD* msad, UInt order); +private SInt RetOrderInPMSADsNR(PMSAD* start, PMSAD* end); +private PMSAD* NextOrderPMSADsAddInPABHList(MNode* node, MArea* area, PMSAD* start, PMSAD* end, UInt* summsad); +private UInt ScanOrderPMSADsAddInPABHList(MNode* node, MArea* area, PMSAD* start, PMSAD* end); +private UInt ScanContinuousAddrPMSADsLen(PMSAD* start, PMSAD* end); +private UInt ScanContinuousAddrPMSADs(MNode* node, MArea* area, PMSAD* start, PMSAD* end); +private UInt ScanContinuousFreePMSADsLen(PMSAD* start, PMSAD* end); +private UInt ScanContinuousFreePMSADs(MNode* node, MArea* area, PMSAD* start, PMSAD* end); +private UInt ScanSameAreaTypePMSADsLen(PMSAD* start, PMSAD* end, UInt areatype); +private UInt ScanSameAreaTypePMSADs(MNode* node, MArea* area, PMSAD* start, PMSAD* end); +private UInt PMSADBlockInitOnPMSADDire(MNode* node, MArea* area, PMSADDire* dire); +private Bool OneMAreaInitOnMNode(MNode* node, MArea* area); +private Bool MAreaInitOnMNode(MNode* node); +public Bool KrlMmClearPMSADUseStatus(PMSAD* msad); +public PMSAD* KrlMmGetPMSADOnVaddr(Addr vaddr); +public MNode* KrlMmGetMNode(UInt nodeid); +public MArea* KrlMmGetMArea(MNode* node, UInt areaid); +public Bool KrlMmMAreaInit(); +private Bool DefaultMNodeInit(); +public Bool KrlMmMNodeInit(); +public Bool KrlMmManageInit(); +#endif diff --git a/Include/KernelInc/MemoryInc/KrlMmPool.h b/Include/KernelInc/MemoryInc/KrlMmPool.h new file mode 100644 index 0000000..c3d9f06 --- /dev/null +++ b/Include/KernelInc/MemoryInc/KrlMmPool.h @@ -0,0 +1,117 @@ +/********************************************************** + 内存池头文件KrlMmPool.h +*********************************************************** + 彭东 +**********************************************************/ + +#ifndef _KRLMMPOOLHEAD +#define _KRLMMPOOLHEAD +#define MSCLST_MAX (5) +#define KMPOOL_MAX (64) +#define PMLH_MAX (32) +#define PER_POE_INCSIZE (32) +#define KUC_NEWFLG (1) +#define KUC_DELFLG (2) +#define KUC_DSYFLG (3) + +typedef struct POOLPARM +{ + UInt AllocPMSADs; + UInt POESize; +}PoolParam; + +typedef struct PMLHEAD +{ + UInt PmsadNR; + UInt AllocPMSADNR; + UInt EndMaxPMSADNR; + List Lists; +}PMLHead; + + +typedef struct POENTITIES +{ + List Lists; + UInt Status; + void* Start; +}POEntities; + +typedef struct KMEMPOOL +{ + List Lists; + MLock Lock; + UInt Status; + UInt Flags; + UInt Size; + UInt ObjNR; + UInt FreeObjNR; + UInt AllocPMSADNR; + Addr VAddrStart; + Addr VAddrEnd; + List ObjLists; + List PMSADsLists; + void* Priv; + void* Ext; +}KMemPool; + +typedef struct KPMSADSPOOL +{ + List Lists; + MLock Lock; + UInt Status; + UInt Flags; + UInt PmsadsNR; + PMLHead* PMLHeadCache; + PMLHead PMLHeadArr[PMLH_MAX]; +}KPMSADsPool; + +typedef struct GMEMPOOLMANAGE +{ + List Lists; + MLock Lock; + UInt Status; + UInt Flags; + UInt KMemPoolNR; + KPMSADsPool PMSADsPool; + KMemPool* KMemPoolCache; + KMemPool* KMemPoolArr[KMPOOL_MAX]; +}GMemPoolManage; + +KLINE GMemPoolManage* KrlMmGetGMemPoolAddr() +{ + return &GMemPoolData; +} + +private void PMLHeadInit(PMLHead* init, UInt msadnr, UInt endmsadnr); +private void KPMSADsPoolInit(KPMSADsPool* init); +private void POEntitiesInit(POEntities* init); +private void KMemPoolInit(KMemPool* init); +private void GMemPoolManageInit(GMemPoolManage* init); +private KMemPool* ForSizeRetKMemPoolOnGMemPoolManage(GMemPoolManage* gmpm, Size size); +private PMSAD* ForAddrDelAndRetPMSADOnKPMSADsPool(KPMSADsPool* pool, void* addr); +private KMemPool* ForAddrRetKMemPoolOnGMemPoolManage(GMemPoolManage* gmpm, void* addr); +private PMLHead* ForMsadNrRetPMLHeadOnGMemPoolManage(GMemPoolManage* gmpm, UInt msadnr); +private POEntities* PickPOEntitiesOnKMemPool(KMemPool* pool); +private Bool PutsPOEntitiesOnKMemPool(KMemPool* pool, POEntities* entities); +private UInt POEntitiesArrInitOnMemSPace(KMemPool* pool, Addr start, Addr end); +private Bool ExtendKMemPoolCapacity(GMemPoolManage* gmpm, KMemPool* pool); +private void* NewPOEntitiesOnKMemPool(GMemPoolManage* gmpm, KMemPool* pool, Size size); +private void* NewPMSADsOnKPMSADsPool(GMemPoolManage* gmpm, KPMSADsPool* pool, PMLHead* head, UInt msadnr); +private void* KrlMmNewPMSADsRealizeCore(GMemPoolManage* gmpm, Size size); +private void* KrlMmNewPOEntitiesRealizeCore(GMemPoolManage* gmpm, Size size); +private void* KrlMmNewPMSADsRealize(Size size); +private void* KrlMmNewPOEntitiesRealize(Size size); +private Bool DelPOEntitiesOnKMemPool(GMemPoolManage* gmpm, KMemPool* pool, void* addr); +private Bool DelPMSADsOnKPMSADsPool(KPMSADsPool* pool, PMLHead* head, PMSAD* msad); +private Bool KrlMmDelPMSADsRealizeCore(GMemPoolManage* gmpm, PMSAD* msad, void* addr); +private Bool KrlMmDelPOEntitiesRealizeCore(GMemPoolManage* gmpm, void* addr); +private Bool KrlMmDelPOEntitiesRealize(void* addr); +private UInt CreateNewKMemPoolInit(KMemPool* pool, PMSAD* msad, UInt msadnr, Addr start, Addr end, Size size); +private KMemPool* KrlMmCreateKMemPoolRealize(GMemPoolManage* gmpm, UInt msadnr, Size size); +public KMemPool* KrlMmCreateKMemPool(UInt msadnr, Size size); +public Bool KrlMmDelPOEntities(void* addr); +public Bool KrlMmDel(void* addr); +public void* KrlMmNewPOEntities(Size size); +public void* KrlMmNew(Size size); +public Bool KrlMmPoolInit(); +#endif \ No newline at end of file diff --git a/Include/KernelInc/MemoryInc/KrlMmReclaim.h b/Include/KernelInc/MemoryInc/KrlMmReclaim.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/MemoryInc/KrlMmVmem.h b/Include/KernelInc/MemoryInc/KrlMmVmem.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/MemoryInc/MEMTestUnitInc/MemTestUnit.h b/Include/KernelInc/MemoryInc/MEMTestUnitInc/MemTestUnit.h new file mode 100644 index 0000000..adec5c1 --- /dev/null +++ b/Include/KernelInc/MemoryInc/MEMTestUnitInc/MemTestUnit.h @@ -0,0 +1,24 @@ +/********************************************************** + 内存测试单元头文件MemTestUnit.h +*********************************************************** + 彭东 +**********************************************************/ +#ifndef _MEMTESTUNITHEAD +#define _MEMTESTUNITHEAD + +public Bool MemGMemManageTest(); +public Bool MemPHYMSPaceAreaTest(); +public Bool MemMNodeTest(); +public Bool MemPMSADOnPMSADDireTest(MNode* node, PMSADDire* dire, U64 start, U64 end); +public Bool MemPMSADOnMNodeTest(MNode* node); +public Bool MemPMSADTest(); +private UInt PMSADBlockIsContinuousAddr(PMSAD* start, PMSAD* end); +public Bool MemMSPlitMerOnPerPMSADBlockTest(MNode* node, MArea* area, PABHList* pabhl, PMSAD* start); +public Bool MemMSPlitMerOnPerPABHListTest(MNode* node, MArea* area, MSPlitMer* splitmer, PABHList* pabhl); +public Bool MemMSPlitMerTest(MNode* node, MArea* area, MSPlitMer* splitmer); +public Bool MemMAreaOnPerMAreaTest(MNode* node, MArea* area); +public Bool MemMAreaOnMNodeTest(MNode* node); +public Bool MemMAreaTest(); +public Bool MemTestUnit(); + +#endif \ No newline at end of file diff --git a/Include/KernelInc/ObjectInc/KrlObjAsyncIPC.h b/Include/KernelInc/ObjectInc/KrlObjAsyncIPC.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/ObjectInc/KrlObjExecutor.h b/Include/KernelInc/ObjectInc/KrlObjExecutor.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/ObjectInc/KrlObjInterface.h b/Include/KernelInc/ObjectInc/KrlObjInterface.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/ObjectInc/KrlObjManage.h b/Include/KernelInc/ObjectInc/KrlObjManage.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/ObjectInc/KrlObjMem.h b/Include/KernelInc/ObjectInc/KrlObjMem.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/ObjectInc/KrlObjSecurity.h b/Include/KernelInc/ObjectInc/KrlObjSecurity.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/ObjectInc/KrlObjSyncIPC.h b/Include/KernelInc/ObjectInc/KrlObjSyncIPC.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/ObjectInc/KrlObjThread.h b/Include/KernelInc/ObjectInc/KrlObjThread.h new file mode 100644 index 0000000..e69de29 diff --git a/Include/KernelInc/ObjectInc/KrlObjUniversal.h b/Include/KernelInc/ObjectInc/KrlObjUniversal.h new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Executor/KrlExecutor.c b/Kernel/Executor/KrlExecutor.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Executor/KrlExecutorCom.c b/Kernel/Executor/KrlExecutorCom.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Executor/KrlExecutorInterface.c b/Kernel/Executor/KrlExecutorInterface.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Executor/KrlExecutorManage.c b/Kernel/Executor/KrlExecutorManage.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Executor/KrlExecutorRes.c b/Kernel/Executor/KrlExecutorRes.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Executor/KrlExecutorSync.c b/Kernel/Executor/KrlExecutorSync.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Executor/KrlThread.c b/Kernel/Executor/KrlThread.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Executor/KrlTransfer.c b/Kernel/Executor/KrlTransfer.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/KrlInit.c b/Kernel/KrlInit.c new file mode 100644 index 0000000..018f769 --- /dev/null +++ b/Kernel/KrlInit.c @@ -0,0 +1,12 @@ +/**************************************************************** + Kernel层初始化头文件KrlInit.h +***************************************************************** + 彭东 +****************************************************************/ +#include "BaseType.h" +#include "KrlInit.h" + +public void KrlCoreInit() +{ + return; +} \ No newline at end of file diff --git a/Kernel/KrlLog.c b/Kernel/KrlLog.c new file mode 100644 index 0000000..97bf527 --- /dev/null +++ b/Kernel/KrlLog.c @@ -0,0 +1,130 @@ +/**************************************************************** + Kernel层日志文件KrlLog.c +***************************************************************** + 彭东 +****************************************************************/ +#include "BaseType.h" +#include "HalCPU.h" +#include "HalSync.h" +#include "HalFirmware.h" +#include "KrlLog.h" + +private Char* FmtNumber(Char* str, UInt n, SInt base) +{ + register Char* p; + Char strbuf[36]; + p = &strbuf[36]; + *--p = 0; + if (n == 0) + { + *--p = '0'; + } + else + { + do + { + *--p = "0123456789abcdef"[n % base]; + } while (n /= base); + } + while (*p != 0) + { + *str++ = *p++; + } + return str; +} + +private Char* FmtStrCopy(Char* buf, Char* str) +{ + while(*str) + { + *buf = *str; + buf++; + str++; + } + return buf; +} + +private void FmtCore(Char* buf, const Char* fmt, VAList args) +{ + Char* p = buf; + while(*fmt) + { + if(*fmt != '%') + { + *p++ = *fmt++; + continue; + } + fmt++; + switch(*fmt) + { + case 'x': + p = FmtNumber(p, VA_ARG(args, UInt), 16); + fmt++; + break; + case 'd': + p = FmtNumber(p, VA_ARG(args, UInt), 10); + fmt++; + break; + case 's': + p = FmtStrCopy(p, (Char*)VA_ARG(args, UInt)); + fmt++; + break; + default: + break; + } + } + *p = 0; + return; +} + +public void KrlPrint(const Char* fmt, ...) +{ + CPUFlg cpuflg; + Char buf[512]; + VAList ap; + HalCliFlags(&cpuflg); + VA_START(ap, fmt); + FmtCore(buf, fmt, ap); + HalDefStringWrite(buf); + VA_END(ap); + HalStiFlags(&cpuflg); + return; +} + +public void KrlLog(UInt level, const Char* fmt, ...) +{ + CPUFlg cpuflg; + Char buf[512]; + VAList ap; + if(0 != level) + { + return; + } + HalCliFlags(&cpuflg); + VA_START(ap, fmt); + FmtCore(buf, fmt, ap); + HalDefStringWrite(buf); + VA_END(ap); + HalStiFlags(&cpuflg); + return; +} + +public void KrlErrorCrashDead(const Char* fmt, ...) +{ + CPUFlg cpuflg; + Char buf[512]; + VAList ap; + HalCliFlags(&cpuflg); + VA_START(ap, fmt); + FmtCore(buf, fmt, ap); + HalDefStringWrite(buf); + VA_END(ap); + HalStiFlags(&cpuflg); + HalDead(0); + return; +} + +public Bool KrlLogInit() +{ + return TRUE; +} \ No newline at end of file diff --git a/Kernel/Memory/KrlMmAlloc.c b/Kernel/Memory/KrlMmAlloc.c new file mode 100644 index 0000000..3cf2035 --- /dev/null +++ b/Kernel/Memory/KrlMmAlloc.c @@ -0,0 +1,597 @@ +/********************************************************** + 物理内存分配文件KrlMmAlloc.c +*********************************************************** + 彭东 +**********************************************************/ +#include "BaseType.h" +#include "List.h" +#include "HalCPU.h" +#include "KrlMmManage.h" +#include "KrlMmAlloc.h" + +private SInt ForPmsadNrRetOrder(UInt msadnr) +{ + SInt mbits = HalSearch64RLBits((U64)msadnr); + IF_LTN_RETURN(mbits, 0, -1); + + if(msadnr & (msadnr - 1)) + { + mbits++;//有问题不要使用 + } + return mbits; +} + + +private PABHList* ForPmsadNrRetPABListOnMArea(MNode* node, MArea* area, UInt msadnr) +{ + PABHList* abhlist = NULL; + IF_NULL_RETURN_NULL(node); + IF_NULL_RETURN_NULL(area); + abhlist = area->MSPLMerData.PAddrBlockArr; + for(UInt i = 0; i < MSPLMER_ARR_LMAX; i++) + { + if(abhlist->InOrderPmsadNR >= msadnr) + { + return abhlist; + } + } + return NULL; +} + +private PABHList* ForPmsadNrRetAllocPABListOnMArea(MNode* node, MArea* area, UInt msadnr) +{ + PABHList* abhlist = NULL; + IF_NULL_RETURN_NULL(node); + IF_NULL_RETURN_NULL(area); + abhlist = area->MSPLMerData.PAddrBlockArr; + for(UInt i = 0; i < MSPLMER_ARR_LMAX; i++) + { + if((abhlist->InOrderPmsadNR >= msadnr) && (abhlist->FreePmsadNR >= msadnr) && + (ListIsEmptyCareful(&abhlist->FreeLists) == FALSE)) + { + return abhlist; + } + } + return NULL; +} + +private PMSAD* PickPMSADsOnPABHList(PABHList* abhlist) +{ + PMSAD* msad = NULL; + PMSAD* end = NULL; + + IF_NULL_RETURN_NULL(abhlist); + IF_LTN_RETURN(abhlist->FreePmsadNR, abhlist->InOrderPmsadNR, NULL); + KrlMmLocked(&abhlist->Lock); + + if(ListIsEmptyCareful(&abhlist->FreeLists) == TRUE) + { + KrlMmUnLock(&abhlist->Lock); + return NULL; + } + + msad = ListFirstOne(&abhlist->FreeLists, PMSAD, Lists); + if(1 == abhlist->InOrderPmsadNR) + { + IF_NEQ_DEAD(MF_OLKTY_BAFH, RetPMSADOLType(msad), "PMSAD OLTYPE NOT MF_OLKTY_BAFH"); + ListDel(&msad->Lists); + abhlist->FreePmsadNR -= 1; + abhlist->PmsadNR -= 1; + KrlMmUnLock(&abhlist->Lock); + return msad; + } + + IF_NEQ_DEAD(MF_OLKTY_ODER, RetPMSADOLType(msad), "PMSAD OLTYPE NOT MF_OLKTY_ODER"); + + end = (PMSAD*)RetPMSADBlockLink(msad); + IF_NEQ_DEAD(MF_OLKTY_BAFH, RetPMSADOLType(end), "PMSAD OLTYPE NOT MF_OLKTY_BAFH"); + + ListDel(&msad->Lists); + abhlist->FreePmsadNR -= abhlist->InOrderPmsadNR; + abhlist->PmsadNR -= abhlist->InOrderPmsadNR; + KrlMmUnLock(&abhlist->Lock); + return msad; +} + +private Bool PutsPMSADsOnPABHList(PABHList* abhlist, PMSAD* msad, PMSAD* msadend, UInt order) +{ + PMSAD* end = NULL; + IF_NULL_RETURN_FALSE(abhlist); + IF_NULL_RETURN_FALSE(msad); + IF_NULL_RETURN_FALSE(msadend); + + if(PMSADIsFree(msad) == FALSE) + { + return FALSE; + } + if(abhlist->Order != order) + { + return FALSE; + } + + end = &msad[(1 << order) - 1]; + IF_NEQ_RETURN(end, msadend, FALSE); + + KrlMmLocked(&abhlist->Lock); + ListAdd(&msad->Lists, &abhlist->FreeLists); + SetPMSADOLType(msad, MF_OLKTY_ODER); + SetPMSADBlockLink(msad, (void*)msadend); + SetPMSADOLType(msadend, MF_OLKTY_BAFH); + SetPMSADBlockLink(msad, (void*)abhlist); + abhlist->FreePmsadNR += (1 << order); + abhlist->PmsadNR += (1 << order); + KrlMmUnLock(&abhlist->Lock); + return TRUE; +} + +private PMSAD* OperationAfterAllocPMSADs(PABHList* abhlist, PMSAD* start, PMSAD* end) +{ + UInt msadnr = 0; + IF_EQT_DEAD(NULL, abhlist, "PARM:abhlist == NULL\n"); + IF_EQT_DEAD(NULL, start, "PARM: start == NULL\n"); + IF_EQT_DEAD(NULL, end, "PARM:end == NULL\n"); + IF_EQT_DEAD(FALSE, PMSADIsFree(start), "PMSAD:start is Not Free\n"); + IF_EQT_DEAD(FALSE, PMSADIsFree(end), "PMSAD:end is Not Free\n"); + + msadnr = (end - start) + 1; + IF_NEQ_DEAD(msadnr, abhlist->InOrderPmsadNR, "abhlist->InOrderPmsadNR != msadnr\n"); + + if(start == end) + { + IF_NEQ_DEAD(1, abhlist->InOrderPmsadNR, "abhlist->InOrderPmsadNR != 1\n"); + GetPMSAD(start); + SetPMSADAlloc(start); + SetPMSADOLType(start, MF_OLKTY_ODER); + SetPMSADBlockLink(start, (void*)end); + return start; + } + GetPMSAD(start); + SetPMSADAlloc(start); + + GetPMSAD(end); + SetPMSADAlloc(end); + + SetPMSADOLType(start, MF_OLKTY_ODER); + SetPMSADBlockLink(start, (void*)end); + + return start; +} + +private PMSAD* AllocPMSADsOnPABHList(MNode* node, MArea* area, PABHList* abhlist, PABHList* allocbhlist, UInt msadnr) +{ + PABHList* start = NULL; + PABHList* end = NULL; + PABHList* tmp = NULL; + PMSAD* msad = NULL; + Bool rets = FALSE; + + IF_NULL_RETURN_NULL(node); + IF_NULL_RETURN_NULL(area); + IF_NULL_RETURN_NULL(abhlist); + IF_NULL_RETURN_NULL(allocbhlist); + + IF_LTN_RETURN(msadnr, abhlist->InOrderPmsadNR, NULL); + IF_GTN_RETURN(msadnr, allocbhlist->InOrderPmsadNR, NULL); + + IF_GTN_RETURN(abhlist, allocbhlist, NULL); + start = abhlist; + end = allocbhlist; + + if(start == end) + { + msad = PickPMSADsOnPABHList(allocbhlist); + IF_NULL_RETURN_NULL(msad); + SetPMSADAlloc(msad); + GetPMSAD(msad); + return msad; + } + + msad = PickPMSADsOnPABHList(allocbhlist); + IF_NULL_RETURN_NULL(msad); + + tmp = end - 1; + while(tmp >= start) + { + rets = PutsPMSADsOnPABHList(tmp, &msad[tmp->InOrderPmsadNR], &msad[tmp->InOrderPmsadNR + tmp->InOrderPmsadNR - 1], tmp->Order); + IF_NEQ_DEAD(FALSE, rets, "PMSADAddInPABHList rets FALSE\n"); + tmp--; + } + OperationAfterAllocPMSADs(abhlist, msad, &msad[abhlist->InOrderPmsadNR]); + return msad; +} + +private PMSAD* KrlMmAllocPMSADsRealizeCore(GMemManage* gmm, MNode* node, MArea* area, UInt msadnr, U64 flags) +{ + PABHList* abhlist = NULL; + PABHList* allocbhlist = NULL; + PMSAD* msad = NULL; + IF_NULL_RETURN_NULL(gmm); + IF_NULL_RETURN_NULL(node); + IF_NULL_RETURN_NULL(area); + IF_ZERO_RETURN_NULL(msadnr); + + IF_LTN_RETURN(gmm->FreePMSAD, msadnr, NULL); + IF_LTN_RETURN(area->FreePMSAD, msadnr, NULL); + + abhlist = ForPmsadNrRetPABListOnMArea(node, area, msadnr); + IF_NULL_RETURN_NULL(abhlist); + + allocbhlist = ForPmsadNrRetAllocPABListOnMArea(node, area, msadnr); + IF_NULL_RETURN_NULL(allocbhlist); + + msad = AllocPMSADsOnPABHList(node, area, abhlist, allocbhlist, msadnr); + IF_NULL_RETURN_NULL(msad); + return msad; +} + +private PMSAD* KrlMmAllocPMSADsRealize(UInt nodeid, UInt areaid, UInt msadnr, U64 flags) +{ + GMemManage* gmm = NULL; + MNode* node = NULL; + MArea* area = NULL; + PMSAD* msad = NULL; + UInt msadnr = 0; + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_RETURN_NULL(gmm); + + node = KrlMmGetMNode(nodeid); + IF_NULL_RETURN_NULL(node); + + area = KrlMmGetMArea(node, areaid); + IF_NULL_RETURN_NULL(area); + + KrlMmLocked(&node->Lock); + KrlMmLocked(&area->Lock); + msad = KrlMmAllocPMSADsRealizeCore(gmm, node, area, msadnr, flags); + KrlMmUnLock(&area->Lock); + KrlMmUnLock(&node->Lock); + msadnr = (UInt)KrlMmGetPMSADsLen(msad); + KrlMmUPAddMNodeAreaAllocMaxFreeNR(node, area, msadnr, 0, 0); + KrlMmUPSubMNodeAreaAllocMaxFreeNR(node, area, 0, 0, msadnr); + KrlMmUPAddGMMAllocMaxFreeNR(msadnr, 0, 0); + KrlMmUPSubGMMAllocMaxFreeNR(0, 0, msadnr); + return msad; +} + +public U64 KrlMmGetPMSADsLen(PMSAD* msad) +{ + PMSAD* end = NULL; + IF_NULL_RETURN_ZERO(msad); + IF_NEQ_RETURN(TRUE, PMSADIsFree(msad), 0); + IF_NULL_RETURN_ZERO(RetPMSADBlockLink(msad)); + + end = (PMSAD*)RetPMSADBlockLink(msad); + IF_LTN_RETURN(end, msad, 0); + + return ((U64)(end - msad) + 1); +} + +public U64 KrlMmGetPMSADsSize(PMSAD* msad) +{ + U64 msadlen = 0; + IF_NULL_RETURN_ZERO(msad); + IF_NEQ_RETURN(TRUE, PMSADIsFree(msad), 0); + msadlen = KrlMmGetPMSADLen(msad); + return (msadlen << MSAD_PADR_SLBITS); +} + +public PMSAD* KrlMmGetPMSADsEnd(PMSAD* msad) +{ + PMSAD* end = NULL; + IF_NULL_RETURN_NULL(msad); + IF_NEQ_RETURN(TRUE, PMSADIsFree(msad), NULL); + IF_NEQ_RETURN(MF_OLKTY_ODER, RetPMSADOLType(msad), NULL); + IF_NULL_RETURN_NULL(RetPMSADBlockLink(msad)); + + end = (PMSAD*)RetPMSADBlockLink(msad); + IF_LTN_RETURN(end, msad, NULL); + return end; +} + +public Addr KrlMmGetPMSADsRangeVStart(PMSAD* msad) +{ + IF_NULL_DEAD(msad); + IF_NEQ_DEAD(TRUE, PMSADIsFree(msad), "PMSAD Is Not Free\n"); + return PMSADRetVAddr(msad); +} + +public Addr KrlMmGetPMSADsRangeVEnd(PMSAD* msad) +{ + PMSAD* end = NULL; + IF_NULL_DEAD(msad); + IF_NEQ_DEAD(TRUE, PMSADIsFree(msad), "PMSAD Is Not Free\n"); + end = KrlMmGetPMSADsEnd(msad); + IF_NULL_DEAD(end); + return (Addr)((PMSADRetVAddr(end) + MSAD_SIZE) - 1); +} + +public PMSAD* KrlMmAllocPMSADs(UInt nodeid, UInt areaid, UInt msadnr, U64 flags) +{ + return KrlMmAllocPMSADsRealize(nodeid, areaid, msadnr, flags); +} + + +public PMSAD* KrlMmAllocKernPMSADs(UInt msadnr) +{ + return KrlMmAllocPMSADs(DEFAULT_NODE_ID, KERN_AREA_ID, msadnr, KMAF_DEFAULT); +} + +public PMSAD* KrlMmAllocUserPMSADs(UInt msadnr) +{ + IF_NEQONE_RETRUN_NULL(msadnr); + return KrlMmAllocPMSADs(DEFAULT_NODE_ID, USER_AREA_ID, msadnr, KMAF_DEFAULT); +} + +private UInt OperationBeforeFreePMSADs(PABHList* abhlist, PMSAD* start, PMSAD* end) +{ + UInt msadnr = 0; + IF_EQT_DEAD(NULL, abhlist, "PARM:abhlist == NULL\n"); + IF_EQT_DEAD(NULL, start, "PARM: start == NULL\n"); + IF_EQT_DEAD(NULL, end, "PARM:end == NULL\n"); + IF_EQT_DEAD(TRUE, PMSADIsFree(start), "PMSAD:start is Not Alloc\n"); + IF_EQT_DEAD(TRUE, PMSADIsFree(end), "PMSAD:end is Not Alloc\n"); + + msadnr = (end - start) + 1; + IF_NEQ_DEAD(msadnr, abhlist->InOrderPmsadNR, "abhlist->InOrderPmsadNR != msadnr\n"); + + if(start == end) + { + IF_NEQ_DEAD(1, abhlist->InOrderPmsadNR, "abhlist->InOrderPmsadNR != 1\n"); + PutPMSAD(start); + if(RetPMSADRefCount(start) > 0) + { + return 1; + } + + KrlMmClearPMSADUseStatus(start); + SetPMSADOLType(start, MF_OLKTY_BAFH); + SetPMSADBlockLink(start, (void*)abhlist); + return 2; + } + + PutPMSAD(start); + PutPMSAD(end); + if(RetPMSADRefCount(start) > 0) + { + return 1; + } + + KrlMmClearPMSADUseStatus(start); + KrlMmClearPMSADUseStatus(end); + + SetPMSADOLType(start, MF_OLKTY_ODER); + SetPMSADBlockLink(start, (void*)end); + SetPMSADOLType(end, MF_OLKTY_BAFH); + SetPMSADBlockLink(end, (void*)abhlist); + return 2; +} + +private Bool CheckOnePMSADBlock(PABHList* abhlist, PMSAD* mblockstart, PMSAD* mblockend) +{ + IF_NULL_RETURN_FALSE(abhlist); + IF_NULL_RETURN_FALSE(mblockstart); + IF_NULL_RETURN_FALSE(mblockend); + IF_LTN_RETURN(mblockend, mblockstart, FALSE); + IF_NEQ_RETURN(abhlist->InOrderPmsadNR, ((mblockend - mblockstart) + 1), FALSE); + IF_NEQ_RETURN(TRUE, PMSADIsFree(mblockstart), FALSE); + IF_NEQ_RETURN(TRUE, PMSADIsFree(mblockend), FALSE); + return TRUE; +} + +private Bool ClearPMSADTowBlockFlags(PABHList* abhlist, PMSAD* _1mblocks, PMSAD* _1mblocke, PMSAD* _2mblocks, PMSAD* _2mblocke) +{ + if(_1mblocks == _2mblocks || _1mblocke == _2mblocke) + { + return FALSE; + } + SetPMSADOLType(_1mblocke, MF_OLKTY_INIT); + SetPMSADBlockLink(_1mblocke, NULL); + SetPMSADOLType(_2mblocks, MF_OLKTY_INIT); + SetPMSADBlockLink(_2mblocks, NULL); + + SetPMSADOLType(_1mblocks, MF_OLKTY_ODER); + SetPMSADBlockLink(_1mblocks, (void*)_2mblocke); + SetPMSADOLType(_2mblocke, MF_OLKTY_BAFH); + SetPMSADBlockLink(_2mblocke, (void*)abhlist); + return TRUE; +} + +private UInt PMSADTowBlockIsOk(PABHList* abhlist, PMSAD* _1mblocks, PMSAD* _1mblocke, PMSAD* _2mblocks, PMSAD* _2mblocke) +{ + IF_NEQ_RETURN(TRUE, CheckOnePMSADBlock(abhlist, _1mblocks, _1mblocke), 1); + IF_NEQ_RETURN(TRUE, CheckOnePMSADBlock(abhlist, _2mblocks, _2mblocke), 1); + IF_EQT_RETURN(TRUE, PMSADIsAdjacent(_1mblocke, _2mblocks), 2); + IF_EQT_RETURN(TRUE, PMSADIsAdjacent(_2mblocke, _1mblocks), 4); + return 0; +} + +private UInt FindContinuousPMSADsBlock(PABHList* abhlist, PMSAD** msadstart, PMSAD** msadend) +{ + PMSAD* start = NULL; + PMSAD* end = NULL; + UInt msadnr = 0; + List* tmplst = NULL; + PMSAD* tmpmsa = NULL; + PMSAD* blkms = NULL; + PMSAD* blkme = NULL; + UInt rets = 0; + + start = *msadstart; + end = *msadend; + msadnr = (UInt)KrlMmGetPMSADsLen(start); + + KrlMmLocked(&abhlist->Lock); + if(1 > abhlist->FreePmsadNR) + { + KrlMmUnLock(&abhlist->Lock); + return 1; + } + + IF_EQT_DEAD(abhlist->InOrderPmsadNR, msadnr, "PMSAD len NEQ area order NR\n"); + + ListForEach(tmplst, &abhlist->FreeLists) + { + tmpmsa = ListEntry(tmplst, PMSAD, Lists); + rets = PMSADTowBlockIsOk(abhlist, start, end, tmpmsa, &tmpmsa[abhlist->InOrderPmsadNR - 1]); + if (2 == rets || 4 == rets) + { + blkms = tmpmsa; + blkme = &tmpmsa[abhlist->InOrderPmsadNR - 1]; + ListDel(&tmpmsa->Lists); + abhlist->FreePmsadNR -= abhlist->InOrderPmsadNR; + abhlist->PmsadNR -= abhlist->InOrderPmsadNR; + KrlMmUnLock(&abhlist->Lock); + goto step1; + } + } + +step1: + + KrlMmUnLock(&abhlist->Lock); + if(0 == rets || 1 == rets) + { + return 1; + } + + if(2 == rets) + { + if(ClearPMSADTowBlockFlags(abhlist + 1, start, end, blkms, blkme) == TRUE) + { + *msadstart = start; + *msadend = blkme; + return 2; + } + return 0; + } + + if(4 == rets) + { + if(ClearPMSADTowBlockFlags(abhlist + 1, blkms, blkme, start, end) == TRUE) + { + *msadstart = blkms; + *msadend = end; + return 2; + } + return 0; + } + return 0; +} + +private Bool FreePMSADsOnPABHList(MNode* node, MArea* area, PABHList* abhlist, PABHList* freebhlist, PMSAD* msad, UInt msadnr) +{ + PABHList* start = NULL; + PABHList* end = NULL; + PABHList* tmp = NULL; + PMSAD* mblockstart = NULL; + PMSAD* mblockend = NULL; + Bool rets = FALSE; + UInt oks = 0; + + IF_NULL_RETURN_FALSE(node); + IF_NULL_RETURN_FALSE(area); + IF_NULL_RETURN_FALSE(abhlist); + IF_NULL_RETURN_FALSE(freebhlist); + + IF_GTN_RETURN(abhlist, freebhlist, FALSE); + start = abhlist; + end = freebhlist; + + mblockstart = msad; + mblockend = &msad[msadnr - 1]; + for(tmp = start; tmp < end; tmp++) + { + oks = FindContinuousPMSADsBlock(tmp, &mblockstart, &mblockend); + if(1 == oks) + { + break; + } + IF_EQT_DEAD(0, oks, "oks is zero\n"); + } + IF_NEQ_DEAD(tmp->InOrderPmsadNR, KrlMmGetPMSADsLen(mblockstart), "tmp->InOrderPmsadNR != mblockstart len\n"); + return PutsPMSADsOnPABHList(tmp, mblockstart, mblockend, tmp->Order); +} + +private Bool KrlMmFreePMSADsRealizeCore(GMemManage* gmm, MNode* node, MArea* area, PMSAD* msad, U64 flags) +{ + Bool rets = FALSE; + PABHList* abhlist = NULL; + PABHList* freebhlist = NULL; + UInt msadnr = 0; + UInt opt = 0; + IF_NULL_RETURN_FALSE(gmm); + IF_NULL_RETURN_FALSE(node); + IF_NULL_RETURN_FALSE(area); + IF_NULL_RETURN_FALSE(msad); + + msadnr = (UInt)KrlMmGetPMSADsLen(msad); + freebhlist = &area->MSPLMerData.PAddrBlockArr[MSPLMER_ARR_LMAX - 1]; + abhlist = ForPmsadNrRetPABListOnMArea(node, area, msadnr); + IF_NULL_RETURN_FALSE(abhlist); + opt = OperationBeforeFreePMSADs(abhlist, msad, KrlMmGetPMSADsEnd(msad)); + if(2 == opt) + { + rets = FreePMSADsOnPABHList(node, area,abhlist, freebhlist, msad, msadnr); + if(TRUE == rets) + { + return rets; + } + return FALSE; + } + if(1 == opt) + { + return TRUE; + } + if(0 == opt) + { + return FALSE; + } + return FALSE; +} + +private Bool KrlMmFreePMSADsRealize(PMSAD* msad, U64 flags) +{ + Bool rets = FALSE; + UInt msadnr = 0; + GMemManage* gmm = NULL; + MNode* node = NULL; + MArea* area = NULL; + IF_NULL_RETURN_FALSE(msad); + + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_RETURN_FALSE(gmm); + + node = PMSADRetItsMNode(msad); + IF_NULL_RETURN_FALSE(node); + + area = PMSADRetItsMArea(msad); + IF_NULL_RETURN_FALSE(area); + + msadnr = (UInt)KrlMmGetPMSADsLen(msad); + + KrlMmLocked(&node->Lock); + KrlMmLocked(&area->Lock); + rets = KrlMmFreePMSADsRealizeCore(gmm, node, area, msad, flags); + KrlMmUnLock(&area->Lock); + KrlMmUnLock(&node->Lock); + KrlMmUPAddMNodeAreaAllocMaxFreeNR(node, area, 0, 0, msadnr); + KrlMmUPSubMNodeAreaAllocMaxFreeNR(node, area, msadnr, 0, 0); + KrlMmUPAddGMMAllocMaxFreeNR(0, 0, msadnr); + KrlMmUPSubGMMAllocMaxFreeNR(msadnr, 0, 0); + return rets; +} + +public Bool KrlMmFreePMSADs(PMSAD* msad, U64 flags) +{ + return KrlMmFreePMSADsRealize(msad, flags); +} + +public Bool KrlMmFreeKernPMSADs(PMSAD* msad) +{ + return KrlMmFreePMSADs(msad, KMAF_DEFAULT); +} + +public Bool KrlMmFreeUserPMSADs(PMSAD* msad) +{ + IF_NULL_RETURN_FALSE(msad); + return KrlMmFreePMSADs(msad, KMAF_DEFAULT); +} \ No newline at end of file diff --git a/Kernel/Memory/KrlMmCache.c b/Kernel/Memory/KrlMmCache.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Memory/KrlMmInterface.c b/Kernel/Memory/KrlMmInterface.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Memory/KrlMmManage.c b/Kernel/Memory/KrlMmManage.c new file mode 100644 index 0000000..f073ec3 --- /dev/null +++ b/Kernel/Memory/KrlMmManage.c @@ -0,0 +1,919 @@ +/********************************************************** + 物理内存管理文件KrlMmManage.c +*********************************************************** + 彭东 +**********************************************************/ +#include "BaseType.h" +#include "List.h" +#include "HalSync.h" +#include "HalCPU.h" +#include "HalBoot.h" +#include "HalInterface.h" +#include "KrlLog.h" +#include "KrlMmManage.h" + +DefinedMEMData(GMemManage, GMemManageData); + +private void MLockInit(MLock* init) +{ + IF_NULL_RETURN(init); + SPinLockInit(&init->Locks); + return; +} + +private void PHYMSPaceAreaInit(PHYMSPaceArea* init) +{ + IF_NULL_RETURN(init); + INIT_OBJOFPTR_ZERO(init); + return; +} + +private void PMSADInit(PMSAD* init) +{ + IF_NULL_RETURN(init); + INIT_OBJOFPTR_ZERO(init); + ListInit(&init->Lists); + SPinLockInit(&init->Lock); + return; +} + +private void PABHListInit(PABHList* init) +{ + IF_NULL_RETURN(init); + INIT_OBJOFPTR_ZERO(init); + + MLockInit(&init->Lock); + ListInit(&init->FreeLists); + ListInit(&init->AllocLists); + ListInit(&init->OveLists); + return; +} + +private void MSPlitMerInit(MSPlitMer* init) +{ + IF_NULL_RETURN(init); + INIT_OBJOFPTR_ZERO(init); + + MLockInit(&init->Lock); + for(UInt i = 0; i < MSPLMER_ARR_LMAX; i++) + { + PABHListInit(&init->PAddrBlockArr[i]); + } + PABHListInit(&init->OnePAddrBlock); + return; +} + +private void MAreaInit(MArea* init) +{ + IF_NULL_RETURN(init); + INIT_OBJOFPTR_ZERO(init); + ListInit(&init->Lists); + MLockInit(&init->Lock); + ListInit(&init->AllPMSADLists); + MSPlitMerInit(&init->MSPLMerData); + return; +} + +private void MNodeInit(MNode* init) +{ + IF_NULL_RETURN(init); + INIT_OBJOFPTR_ZERO(init); + ListInit(&init->Lists); + MLockInit(&init->Lock); + for(UInt i = 0; i < MEMAREA_MAX; i++) + { + MAreaInit(&init->MAreaArr[i]); + init->MAreaArr[i].AreaId = (U64)i; + } + return; +} + +private void GMemManageInit(GMemManage* init) +{ + IF_NULL_RETURN(init); + INIT_OBJOFPTR_ZERO(init); + MLockInit(&init->Lock); + return; +} + +public Bool KrlMmUPAddGMMAllocMaxFreeNR(UInt allocnr, UInt maxnr, UInt freenr) +{ + GMemManage* gmm = NULL; + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_RETURN_FALSE(gmm); + + KrlMmLocked(&gmm->Lock); + gmm->AllocPMSAD += (U64)allocnr; + gmm->MaxPMSAD += (U64)maxnr; + gmm->FreePMSAD += (U64)freenr; + gmm->MemroySZ = (U64)(gmm->MaxPMSAD << MSAD_PADR_SLBITS); + KrlMmUnLock(&gmm->Lock); + return TRUE; +} + +public Bool KrlMmUPAddMNodeAreaAllocMaxFreeNR(MNode* node, MArea* area, UInt allocnr, UInt maxnr, UInt freenr) +{ + IF_NULL_RETURN_FALSE(node); + IF_NULL_RETURN_FALSE(area); + KrlMmLocked(&area->Lock); + area->AllocPMSAD += allocnr; + area->MaxPMSAD += maxnr; + area->FreePMSAD += freenr; + KrlMmUnLock(&area->Lock); + return TRUE; +} + +public Bool KrlMmUPSubGMMAllocMaxFreeNR(UInt allocnr, UInt maxnr, UInt freenr) +{ + GMemManage* gmm = NULL; + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_RETURN_FALSE(gmm); + + KrlMmLocked(&gmm->Lock); + if((U64)allocnr <= gmm->AllocPMSAD) + { + gmm->AllocPMSAD -= allocnr; + } + if((U64)maxnr <= gmm->MaxPMSAD) + { + gmm->MaxPMSAD -= (U64)maxnr; + } + if((U64)freenr <= gmm->FreePMSAD) + { + gmm->FreePMSAD -= (U64)freenr; + } + gmm->MemroySZ = (U64)(gmm->MaxPMSAD << MSAD_PADR_SLBITS); + KrlMmUnLock(&gmm->Lock); + return TRUE; +} + +public Bool KrlMmUPSubMNodeAreaAllocMaxFreeNR(MNode* node, MArea* area, UInt allocnr, UInt maxnr, UInt freenr) +{ + IF_NULL_RETURN_FALSE(node); + IF_NULL_RETURN_FALSE(area); + KrlMmLocked(&area->Lock); + if(allocnr <= area->AllocPMSAD) + { + area->AllocPMSAD -= allocnr; + } + if(maxnr <= area->MaxPMSAD) + { + area->MaxPMSAD -= maxnr; + } + if(freenr <= area->FreePMSAD) + { + area->FreePMSAD -= freenr; + } + KrlMmUnLock(&area->Lock); + return TRUE; +} + +public void KrlMmLocked(MLock* lock) +{ + IF_NULL_DEAD(lock); + HalSPinLock(&lock->Locks); + return; +} + +public void KrlMmUnLock(MLock* lock) +{ + IF_NULL_DEAD(lock); + HalUnSPinLock(&lock->Locks); + return; +} + +private Bool NewOnePHYMSPaceArea(E820Map* e820, PHYMSPaceArea* area) +{ + U32 type = 0, subtype = 0; + IF_NULL_RETURN_FALSE(e820); + IF_NULL_RETURN_FALSE(area); + + PHYMSPaceAreaInit(area); + + switch (e820->Type) + { + case RAM_USABLE: + type = PMSA_T_OSAPUSERRAM; + subtype = RAM_USABLE; + break; + case RAM_RESERV: + type = PMSA_T_RESERVRAM; + subtype = RAM_RESERV; + break; + case RAM_ACPIREC: + type = PMSA_T_HWUSERRAM; + subtype = RAM_ACPIREC; + break; + case RAM_ACPINVS: + type = PMSA_T_HWUSERRAM; + subtype = RAM_ACPINVS; + break; + case RAM_AREACON: + type = PMSA_T_BUGRAM; + subtype = RAM_AREACON; + break; + default: + break; + } + if (0 == type) + { + return FALSE; + } + + area->Type = type; + area->SubType = subtype; + area->Flags = PMSA_F_X86_64; + area->Start = e820->Addr; + area->Size = e820->Size; + area->End = e820->Addr + e820->Size - 1; + return TRUE; +} + +private void PHYMSPaceAreaSwap(PHYMSPaceArea *s, PHYMSPaceArea *d) +{ + PHYMSPaceArea tmp; + PHYMSPaceAreaInit(&tmp); + HalMemCopy(s, &tmp, sizeof(PHYMSPaceArea)); + HalMemCopy(d, s, sizeof(PHYMSPaceArea)); + HalMemCopy(&tmp, d, sizeof(PHYMSPaceArea)); + return; +} + +private void PHYMSPaceAreaSort(PHYMSPaceArea* area, U64 nr) +{ + U64 i, j, k = nr - 1; + for(j = 0; j < k; j++) + { + for(i = 0; i < k - j; i++) + { + if(area[i].Start > area[i + 1].Start) + { + PHYMSPaceAreaSwap(&area[i], &area[i + 1]); + } + } + } + return; +} + +private Bool SetPMSADInMNodeMAreaInfo(MNode* node, PMSAD* msad) +{ + Addr paddr = 0; + IF_NULL_RETURN_FALSE(node); + IF_NULL_RETURN_FALSE(msad); + + paddr = PMSADRetPAddr(msad); + + for(U64 i = 0; i < MEMAREA_MAX; i++) + { + if((node->MAreaArr[i].LogicStart <= paddr) && ((paddr + MSAD_SIZE) < node->MAreaArr[i].LogicEnd)) + { + switch (node->MAreaArr[i].Type) + { + case MA_TYPE_HWAD: + { + msad->CountFlags.AreaTypeBit = MF_MARTY_HWD; + return TRUE; + } + case MA_TYPE_KRNL: + { + msad->CountFlags.AreaTypeBit = MF_MARTY_KRL; + return TRUE; + } + case MA_TYPE_PROC: + { + msad->CountFlags.AreaTypeBit = MF_MARTY_PRC; + return TRUE; + } + case MA_TYPE_SHAR: + { + msad->CountFlags.AreaTypeBit = MF_MARTY_SHD; + return TRUE; + } + default: + { + return FALSE; + } + } + } + } + return FALSE; +} + +private PMSAD* NewOnePMSAD(MNode* node, PHYMSPaceArea* area, PMSADDire* dire, U64 paddr) +{ + PMSAD* msadstart = NULL; + MArea* marea = NULL; + UInt index = 0; + IF_NULL_RETURN_NULL(node); + IF_NULL_RETURN_NULL(area); + IF_NULL_RETURN_NULL(dire); + + msadstart = dire->DireStart; + IF_NULL_RETURN_NULL(msadstart); + + index = PMSADIndex(paddr); + + PMSADInit(&msadstart[index]); + + SetPMSADPAddr(&msadstart[index], paddr); + SetPMSADPresent(&msadstart[index]); + + SetPMSADInMNodeMAreaInfo(node, &msadstart[index]); + + marea = PMSADRetItsMArea(&msadstart[index]); + IF_NULL_DEAD(marea); + marea->AllPMSADNR++; + marea->MaxPMSAD++; + node->NodeMemSize += MSAD_SIZE; + KrlMmUPAddGMMAllocMaxFreeNR(0, 1, 0); + return &msadstart[index]; +} + +private UInt PMSADInitOnPHYMSPaceArea(MNode* node, PMSADDire* dire, PHYMSPaceArea* area, U64 start, U64 end) +{ + UInt count = 0; + PMSAD* pstart = NULL; + IF_NULL_RETURN_ZERO(node); + IF_NULL_RETURN_ZERO(dire); + IF_NULL_RETURN_ZERO(area); + for(U64 paddr = area->Start; (paddr + (MSAD_SIZE - 1)) < area->End; paddr += MSAD_SIZE) + { + if((start <= paddr) && (paddr < end)) + { + pstart = NewOnePMSAD(node, area, dire, paddr); + if(NULL != pstart) + { + count++; + } + } + } + return count; +} + +private PMSAD* PMSADDireIsNeedAllocMemory(U64 start, U64 end) +{ + PHYMSPaceArea* pmsarea = NULL; + GMemManage* gmm = NULL; + + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_RETURN_NULL(gmm); + + pmsarea = gmm->PAreaStart; + for(U64 i = 0; i < gmm->PAreaNR; i++) + { + if(PMSA_T_OSAPUSERRAM == pmsarea[i].Type) + { + for(U64 paddr = pmsarea[i].Start; (paddr + (MSAD_SIZE - 1)) < pmsarea[i].End; paddr += MSAD_SIZE) + { + if((start <= paddr) && (paddr < end)) + { + return HalExPBootAllocMem((Size)((PMSADDIRE_SIZE >> MSAD_PADR_SLBITS) * sizeof(PMSAD))); + } + } + } + } + return NULL; +} + +private Bool PMSADInitOnMNode(MNode* node) +{ + PHYMSPaceArea* pmsarea = NULL; + GMemManage* gmm = NULL; + PMSADDire* dire = NULL; + PMSAD* msad = NULL; + U64 addrstart = 0; + U64 addrend = 0; + UInt msadnr = 0; + + IF_NULL_RETURN_FALSE(node); + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_DEAD(gmm); + + pmsarea = gmm->PAreaStart; + for(U64 d = 0; d < PMSADDIRE_MAX; d++) + { + dire = &node->PMSADDir.PMSADEArr[d]; + addrstart = d * PMSADDIRE_SIZE; + addrend = addrstart + PMSADDIRE_SIZE; + + msad = PMSADDireIsNeedAllocMemory(addrstart, addrend); + if(NULL == msad) + { + continue; + } + + dire->DireStart = msad; + + for(U64 i = 0; i < gmm->PAreaNR; i++) + { + if(PMSA_T_OSAPUSERRAM == pmsarea[i].Type) + { + msadnr += PMSADInitOnPHYMSPaceArea(node, dire, &pmsarea[i], addrstart, addrend); + } + } + } + return TRUE; +} + +private Bool ScanOccupancyPMSADOnAddr(Addr start, Addr end) +{ + Addr tmpstart = 0; + Addr tmpend = 0; + MNode* node = NULL; + PMSADDire* dire = NULL; + PMSAD* msad = NULL; + + tmpstart = (start & MSAD_MASK); + tmpend = MSAD_ALIGN(end); + + for(Addr paddr = tmpstart; paddr < tmpend; paddr += MSAD_SIZE) + { + msad = PHYAddrRetPMSAD(paddr); + IF_NULL_RETURN_FALSE(msad); + if(PMSADIsFree(msad) == TRUE) + { + SetPMSADOccupancyType(msad, MF_MOCTY_KRNL); + GetPMSAD(msad); + SetPMSADAllocBit(msad); + } + + } + return TRUE; +} + +public Bool KrlMmScanOccupancyPMSAD() +{ + MachStartInfo* msinfo = NULL; + msinfo = HalExPGetMachStartInfoAddr(); + IF_NULL_RETURN_FALSE(msinfo); + + ScanOccupancyPMSADOnAddr(0, 0x1000 - 1); + ScanOccupancyPMSADOnAddr((Addr)(msinfo->KrlInitStack & MSAD_MASK), (Addr)msinfo->KrlInitStack); + ScanOccupancyPMSADOnAddr((Addr)(msinfo->krlCoreFilePAddr), (Addr)(msinfo->krlCoreFilePAddr + msinfo->krlCoreFileSZ)); + // ScanOccupancyPMSADOnAddr((Addr)(msinfo->KrlImgFilePAddr), (Addr)(msinfo->KrlImgFilePAddr + msinfo->KrlImgFileSZ)); + ScanOccupancyPMSADOnAddr((Addr)msinfo->BrkCurrAddr, (Addr)msinfo->BrkCurrAddr); + return TRUE; +} + +public Bool KrlMmPMSADInit() +{ + PHYMSPaceArea* pmsarea = NULL; + GMemManage* gmm = NULL; + MNode* node = NULL; + UInt msadnr = 0; + + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_DEAD(gmm); + + node = gmm->MNodeStart; + for(U64 i = 0; i < gmm->MNodeNR; i++) + { + PMSADInitOnMNode(&node[i]); + } + + return TRUE; +} + +public Bool KrlMmPHYMSPaceAreaInit() +{ + PHYMSPaceArea* area = NULL; + E820Map* e820 = NULL; + GMemManage* gmm = NULL; + MachStartInfo* msinfo = NULL; + U64 areanr= 0; + + msinfo = HalExPGetMachStartInfoAddr(); + IF_NULL_DEAD(msinfo); + + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_DEAD(gmm); + + area = HalExPBootAllocMem((Size)(msinfo->E820NR * sizeof(PHYMSPaceArea))); + IF_NULL_RETURN_FALSE(area); + for ( ;e820 != NULL; areanr++) + { + e820 = HalExPBootGetNextE820(); + NewOnePHYMSPaceArea(e820, &area[areanr]); + } + PHYMSPaceAreaSort(area, areanr); + msinfo->PMSPaceAreaPAddr = HalVAddrToPAddr((Addr)area); + msinfo->PMSPaceAreaNR = areanr; + msinfo->PMSPaceAreaCurr = 0; + msinfo->PMSPaceAreaSZ = areanr * (U64)(sizeof(PHYMSPaceArea)); + gmm->PAreaStart = area; + gmm->PAreaNR = areanr; + return TRUE; +} + +public Bool PMSADAddInPABHList(PABHList* pabhl, PMSAD* msad, UInt order) +{ + PMSAD* msadend = NULL; + IF_NULL_RETURN_FALSE(pabhl); + IF_NULL_RETURN_FALSE(msad); + + if(PMSADIsFree(msad) == FALSE) + { + return FALSE; + } + if(pabhl->Order != order) + { + return FALSE; + } + + KrlMmLocked(&pabhl->Lock); + + msadend = &msad[(1 << order) - 1]; + ListAdd(&msad->Lists, &pabhl->FreeLists); + SetPMSADOLType(msad, MF_OLKTY_ODER); + SetPMSADBlockLink(msad, (void*)msadend); + SetPMSADOLType(msadend, MF_OLKTY_BAFH); + SetPMSADBlockLink(msad, (void*)pabhl); + pabhl->FreePmsadNR += (1 << order); + pabhl->PmsadNR += (1 << order); + KrlMmUnLock(&pabhl->Lock); + return TRUE; +} + +private SInt RetOrderInPMSADsNR(PMSAD* start, PMSAD* end) +{ + UInt msadnr = 0; + SInt order = -1; + if(NULL == start || NULL == end) + { + return -1; + } + if(start > end) + { + return -1; + } + + msadnr = (end - start) + 1; + + for(UInt i = 0; i < MSPLMER_ARR_LMAX; i++) + { + if((1 << i) <= msadnr) + { + order++; + } + } + return order; +} + +private PMSAD* NextOrderPMSADsAddInPABHList(MNode* node, MArea* area, PMSAD* start, PMSAD* end, UInt* summsad) +{ + SInt msadnr = 0; + SInt order = -1; + PABHList* pabhlist = NULL; + PMSAD* nextmsad = NULL; + + pabhlist = area->MSPLMerData.PAddrBlockArr; + msadnr = (end - start) + 1; + + order = RetOrderInPMSADsNR(start, end); + if(0 > order) + { + KrlErrorCrashDead("RetOrderInPMSADsNR is Fail\n"); + return NULL; + } + + if(PMSADAddInPABHList(&pabhlist[order], start, (UInt)order) == FALSE) + { + KrlErrorCrashDead("PMSADAddInPABHList is Fail\n"); + return NULL; + } + *summsad = 1 << order; + nextmsad = &start[(msadnr - (1 << order)) + 1]; + + area->FreePMSAD += (UInt)(1 << order); + KrlMmUPAddGMMAllocMaxFreeNR(0, 0, (UInt)(1 << order)); + return nextmsad; +} + +private UInt ScanOrderPMSADsAddInPABHList(MNode* node, MArea* area, PMSAD* start, PMSAD* end) +{ + PMSAD* msad = NULL; + UInt count = 0; + UInt sum = 0; + msad = start; + while(msad <= end) + { + msad = NextOrderPMSADsAddInPABHList(node, area, msad, end, &count); + if(NULL == msad) + { + KrlErrorCrashDead("NextOrderPMSADsAddInPABHList is Fail\n"); + } + sum += count; + } + + return sum; +} + +private UInt ScanContinuousAddrPMSADsLen(PMSAD* start, PMSAD* end) +{ + PMSAD* msad = NULL; + UInt count = 1; + if(start == end) + { + return 1; + } + msad = start + 1; + while(msad <= end) + { + if(PMSADIsAdjacent(msad - 1, msad) == FALSE) + { + return count; + } + count++; + msad++; + } + return count; +} + +private UInt ScanContinuousAddrPMSADs(MNode* node, MArea* area, PMSAD* start, PMSAD* end) +{ + PMSAD* msad = NULL; + UInt count = 0; + UInt sum = 0; + msad = start; + while(msad <= end) + { + if(MA_TYPE_PROC == area->Type) + { + sum += ScanOrderPMSADsAddInPABHList(node, area, msad, msad); + msad++; + } + else + { + count = ScanContinuousAddrPMSADsLen(msad, end); + if(0 < count) + { + sum += ScanOrderPMSADsAddInPABHList(node, area, msad, end); + msad += count; + } + else + { + msad++; + } + } + } + return sum; +} + +private UInt ScanContinuousFreePMSADsLen(PMSAD* start, PMSAD* end) +{ + PMSAD* msad = NULL; + UInt count = 0; + msad = start; + while(msad <= end) + { + if(PMSADIsFree(msad) == FALSE) + { + return count; + } + count++; + msad++; + } + return count; +} + +private UInt ScanContinuousFreePMSADs(MNode* node, MArea* area, PMSAD* start, PMSAD* end) +{ + PMSAD* msad = NULL; + UInt count = 0; + UInt sum = 0; + msad = start; + while(msad <= end) + { + count = ScanContinuousFreePMSADsLen(msad, end); + if(0 < count) + { + sum += ScanContinuousAddrPMSADs(node, area, msad, &msad[count - 1]); + msad += count; + } + else + { + msad++; + } + } + return sum; +} + +private UInt ScanSameAreaTypePMSADsLen(PMSAD* start, PMSAD* end, UInt areatype) +{ + PMSAD* msad = NULL; + UInt count = 0; + msad = start; + while(msad <= end) + { + if(PMSADIsEQAreaType(msad, areatype) == FALSE) + { + return count; + } + count++; + msad++; + } + return count; +} + +private UInt ScanSameAreaTypePMSADs(MNode* node, MArea* area, PMSAD* start, PMSAD* end) +{ + PMSAD* msad = NULL; + UInt count = 0; + UInt sum = 0; + UInt areatype = 0; + + areatype = area->Type; + msad = start; + + while(msad <= end) + { + count = ScanSameAreaTypePMSADsLen(msad, end, areatype); + if(0 < count) + { + sum += ScanContinuousFreePMSADs(node, area, msad, &msad[count - 1]); + msad += count; + } + else + { + msad++; + } + } + + return sum; +} + +private UInt PMSADBlockInitOnPMSADDire(MNode* node, MArea* area, PMSADDire* dire) +{ + PMSAD* start = NULL; + PMSAD* end = NULL; + + IF_NULL_RETURN_ZERO(node); + IF_NULL_RETURN_ZERO(area); + IF_NULL_RETURN_ZERO(dire); + IF_NULL_RETURN_ZERO(dire->DireStart); + + start = dire->DireStart; + end = &start[(PMSADDIRE_PMSAD_NR - 1)]; + return ScanSameAreaTypePMSADs(node, area, start, end); +} + +private Bool OneMAreaInitOnMNode(MNode* node, MArea* area) +{ + PMSADDire* dire = NULL; + IF_NULL_RETURN_FALSE(node); + IF_NULL_RETURN_FALSE(area); + + dire = node->PMSADDir.PMSADEArr; + for(UInt i = 0; i < PMSADDIRE_MAX; i++) + { + PMSADBlockInitOnPMSADDire(node, area, &dire[i]); + } + return TRUE; +} + +private Bool MAreaInitOnMNode(MNode* node) +{ + MArea* area = NULL; + IF_NULL_RETURN_FALSE(node); + area = node->MAreaArr; + for(UInt i = 0; i < MEMAREA_MAX; i++) + { + OneMAreaInitOnMNode(node, &area[i]); + } + return TRUE; +} + +public Bool KrlMmClearPMSADUseStatus(PMSAD* msad) +{ + IF_NULL_RETURN_FALSE(msad); + ClearPMSADAlloc(msad); + ClearPMSADShare(msad); + ClearPMSADSwap(msad); + ClearPMSADLock(msad); + ClearPMSADKMPool(msad); + return TRUE; +} + +public PMSAD* KrlMmGetPMSADOnVaddr(Addr vaddr) +{ + Addr paddr = NULL; + if((vaddr & (MSAD_SIZE - 1)) != 0) + { + return NULL; + } + paddr = HalVAddrToPAddr(vaddr); + IF_NULL_RETURN_NULL(paddr); + return PHYAddrRetPMSAD((U64)paddr); +} + +public MNode* KrlMmGetMNode(UInt nodeid) +{ + GMemManage* gmm = NULL; + MNode* node = NULL; + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_RETURN_NULL(gmm); + + node = gmm->MNodeStart; + IF_NULL_RETURN_NULL(node); + + for(UInt i = 0; i < gmm->MNodeNR; i++) + { + if(node[i].NodeID == nodeid) + { + return &node[i]; + } + } + return NULL; +} + +public MArea* KrlMmGetMArea(MNode* node, UInt areaid) +{ + IF_NULL_RETURN_NULL(node); + + for(UInt i = 0; i < MEMAREA_MAX; i++) + { + if(node->MAreaArr[i].AreaId == (U64)areaid) + { + return &node->MAreaArr[i]; + } + } + return NULL; +} + +public Bool KrlMmMAreaInit() +{ + MNode* node = NULL; + MachStartInfo* msinfo = NULL; + GMemManage* gmm = NULL; + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_DEAD(gmm); + + node = gmm->MNodeStart; + IF_NULL_RETURN_FALSE(node); + + for(UInt i = 0; i < gmm->MNodeNR; i++) + { + MAreaInitOnMNode(&node[i]); + } + return TRUE; +} + +private Bool DefaultMNodeInit() +{ + MNode* node = NULL; + MachStartInfo* msinfo = NULL; + GMemManage* gmm = NULL; + + msinfo = HalExPGetMachStartInfoAddr(); + IF_NULL_DEAD(msinfo); + + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_DEAD(gmm); + + node = (MNode*)HalExPBootAllocMem((Size)(sizeof(MNode))); + IF_NULL_DEAD(node); + + MNodeInit(node); + node->MAreaArr[MA_TYPE_HWAD].Type = MA_TYPE_HWAD; + node->MAreaArr[MA_TYPE_HWAD].LogicStart = MA_HWAD_LSTART; + node->MAreaArr[MA_TYPE_HWAD].LogicEnd = MA_HWAD_LEND; + node->MAreaArr[MA_TYPE_HWAD].LogicSZ = MA_HWAD_LSZ; + + node->MAreaArr[MA_TYPE_KRNL].Type = MA_TYPE_KRNL; + node->MAreaArr[MA_TYPE_KRNL].LogicStart = MA_KRNL_LSTART; + node->MAreaArr[MA_TYPE_KRNL].LogicEnd = MA_KRNL_LEND; + node->MAreaArr[MA_TYPE_KRNL].LogicSZ = MA_KRNL_LSZ; + + node->MAreaArr[MA_TYPE_PROC].Type = MA_TYPE_PROC; + node->MAreaArr[MA_TYPE_PROC].LogicStart = MA_PROC_LSTART; + node->MAreaArr[MA_TYPE_PROC].LogicEnd = MA_PROC_LEND; + node->MAreaArr[MA_TYPE_PROC].LogicSZ = MA_PROC_LSZ; + + node->MAreaArr[MA_TYPE_SHAR].Type = MA_TYPE_SHAR; + + node->PMSAreaPtr = gmm->PAreaStart; + node->PMSAreaNR = gmm->PAreaNR; + + gmm->MNodeStart = node; + gmm->MNodeNR = 1; + + return TRUE; +} + +public Bool KrlMmMNodeInit() +{ + DefaultMNodeInit(); + return TRUE; +} + + +public Bool KrlMmManageInit() +{ + GMemManageInit(&GMemManageData); + KrlMmPHYMSPaceAreaInit(); + KrlMmMNodeInit(); + KrlMmPMSADInit(); + KrlMmScanOccupancyPMSAD(); + KrlMmMAreaInit(); + return TRUE; +} \ No newline at end of file diff --git a/Kernel/Memory/KrlMmPool.c b/Kernel/Memory/KrlMmPool.c new file mode 100644 index 0000000..a9310c3 --- /dev/null +++ b/Kernel/Memory/KrlMmPool.c @@ -0,0 +1,582 @@ +/********************************************************** + 内存池文件KrlMmPool.c +*********************************************************** + 彭东 +**********************************************************/ +#include "BaseType.h" +#include "List.h" +#include "KrlMmManage.h" +#include "KrlMmAlloc.h" +#include "KrlMmPool.h" + +DefinedMEMData(GMemPoolManage, GMemPoolData); +MEMDATA_SECTION PoolParam PoolParamArr[KMPOOL_MAX] = { + {2, 32}, {2, 64}, {2, 96}, {2, 128}, + {2, 160}, {2, 192}, {2, 224}, {2, 256}, + {2, 288}, {2, 320}, {2, 352}, {2, 384}, + {4, 416}, {4, 448}, {4, 480}, {4, 512}, + {4, 544}, {4, 576}, {4, 608}, {4, 640}, + {4, 672}, {4, 704}, {4, 736}, {4, 768}, + {4, 800}, {4, 832}, {4, 864}, {4, 896}, + {8, 928}, {8, 960}, {8, 992}, {8, 1024}, + {8, 1056}, {8, 1088}, {8, 1120}, {8, 1152}, + {8, 1184}, {8, 1216}, {8, 1248}, {8, 1280}, + {8, 1312}, {8, 1344}, {8, 1376}, {8, 1408}, + {8, 1440}, {8, 1472}, {8, 1504}, {8, 1536}, + {8, 1568}, {8, 1600}, {8, 1632}, {8, 1664}, + {8, 1696}, {8, 1728}, {8, 1760}, {8, 1796}, + {16, 1824}, {16, 1856}, {16, 1888}, {16, 1920}, + {16, 1952}, {16, 1984}, {16, 2016}, {16, 2048}, +}; + +private void PMLHeadInit(PMLHead* init, UInt msadnr, UInt endmsadnr) +{ + IF_NULL_RETURN(init); + INIT_OBJOFPTR_ZERO(init); + init->AllocPMSADNR = msadnr; + init->EndMaxPMSADNR = endmsadnr; + ListInit(&init->Lists); + return; +} + +private void KPMSADsPoolInit(KPMSADsPool* init) +{ + IF_NULL_RETURN(init); + INIT_OBJOFPTR_ZERO(init); + ListInit(&init->Lists); + MLockInit(&init->Lock); + for(UInt i = 0; i < PMLH_MAX; i++) + { + PMLHeadInit(&init->PMLHeadArr[i], (1 << i), ((1 << (i + 1)) - 1)); + } + return; +} + +private void POEntitiesInit(POEntities* init) +{ + IF_NULL_RETURN_NULL(init); + INIT_OBJOFPTR_ZERO(init); + ListInit(&init->Lists); + return; +} + +private void KMemPoolInit(KMemPool* init) +{ + IF_NULL_RETURN(init); + INIT_OBJOFPTR_ZERO(init); + ListInit(&init->Lists); + ListInit(&init->ObjLists); + ListInit(&init->PMSADsLists); + MLockInit(&init->Lock); + return; +} + +private void GMemPoolManageInit(GMemPoolManage* init) +{ + IF_NULL_RETURN(init); + INIT_OBJOFPTR_ZERO(init); + ListInit(&init->Lists); + MLockInit(&init->Lock); + KPMSADsPoolInit(&init->PMSADsPool); + return; +} + +private KMemPool* ForSizeRetKMemPoolOnGMemPoolManage(GMemPoolManage* gmpm, Size size) +{ + IF_NULL_RETURN_NULL(gmpm); + if(NULL != gmpm->KMemPoolCache) + { + if((gmpm->KMemPoolCache->Size > size) && (gmpm->KMemPoolCache->Size < (size + PER_POE_INCSIZE))) + { + return gmpm->KMemPoolCache; + } + } + for(UInt i = 0; i < KMPOOL_MAX; i++) + { + if(NULL != gmpm->KMemPoolArr[i]) + { + if((gmpm->KMemPoolArr[i]->Size > size) && (gmpm->KMemPoolCache->Size < (size + PER_POE_INCSIZE))) + { + gmpm->KMemPoolCache = &gmpm->KMemPoolArr[i]; + return &gmpm->KMemPoolArr[i]; + } + } + } + return NULL; +} + +private PMSAD* ForAddrDelAndRetPMSADOnKPMSADsPool(KPMSADsPool* pool, void* addr) +{ + PMLHead* head = NULL; + List* lists = NULL; + PMSAD* msad = NULL; + + IF_NULL_RETURN_NULL(pool); + IF_NULL_RETURN_NULL(addr); + for(UInt i = 0; i < PMLH_MAX; i++) + { + head = &pool->PMLHeadArr[i]; + ListForEach(lists, &head->Lists) + { + msad = ListEntry(lists, PMSAD, Lists); + if(addr == (void*)PMSADRetVAddr(msad)) + { + ListDel(&msad->Lists); + head->PmsadNR--; + return msad; + } + } + } + return NULL; +} + +private KMemPool* ForAddrRetKMemPoolOnGMemPoolManage(GMemPoolManage* gmpm, void* addr) +{ + List* lists = NULL; + PMSAD* msad = NULL; + KMemPool* pool = NULL; + Addr rangestart = NULL; + Addr rangeend = NULL; + IF_NULL_RETURN_NULL(gmpm); + if(NULL != gmpm->KMemPoolCache) + { + pool = gmpm->KMemPoolCache; + if((pool->VAddrStart <= (Addr)addr) && ((Addr)addr < pool->VAddrEnd)) + { + ListForEach(lists, &pool->PMSADsLists) + { + msad = ListEntry(lists, PMSAD, Lists); + rangestart = KrlMmGetPMSADsRangeVStart(msad); + rangeend = KrlMmGetPMSADsRangeVEnd(msad); + if((rangestart <= (Addr)addr) && ((Addr)addr < rangeend)) + { + return pool; + } + } + } + + } + for(UInt i = 0; i < KMPOOL_MAX; i++) + { + if(NULL != gmpm->KMemPoolArr[i]) + { + pool = gmpm->KMemPoolArr[i]; + if ((pool->VAddrStart <= (Addr)addr) && ((Addr)addr < pool->VAddrEnd)) + { + ListForEach(lists, &pool->PMSADsLists) + { + msad = ListEntry(lists, PMSAD, Lists); + rangestart = KrlMmGetPMSADsRangeVStart(msad); + rangeend = KrlMmGetPMSADsRangeVEnd(msad); + if((rangestart <= (Addr)addr) && ((Addr)addr < rangeend)) + { + return pool; + } + } + } + } + } + return NULL; +} + +private PMLHead* ForMsadNrRetPMLHeadOnGMemPoolManage(GMemPoolManage* gmpm, UInt msadnr) +{ + PMLHead* head = NULL; + KPMSADsPool* pool = NULL; + IF_NULL_RETURN_NULL(gmpm); + pool = &gmpm->PMSADsPool; + for(UInt i = 0; i < PMLH_MAX; i++) + { + head = &pool->PMLHeadArr[i]; + if((msadnr <= head->AllocPMSADNR)) + { + return head; + } + } + return NULL; +} + +private POEntities* PickPOEntitiesOnKMemPool(KMemPool* pool) +{ + POEntities* entities = NULL; + IF_NULL_RETURN_NULL(pool); + IF_LTNONE_RETRUN_NULL(pool->FreeObjNR); + IF_LTNONE_RETRUN_NULL(pool->ObjNR); + IF_EQT_RETURN(TRUE, ListIsEmptyCareful(&pool->ObjLists), NULL); + entities = ListFirstOne(&pool->ObjLists, POEntities, Lists); + ListDel(&entities->Lists); + pool->FreeObjNR--; + return entities; +} + +private Bool PutsPOEntitiesOnKMemPool(KMemPool* pool, POEntities* entities) +{ + IF_NULL_RETURN_FALSE(pool); + IF_NULL_RETURN_FALSE(entities); + POEntitiesInit(entities); + ListAdd(&entities->Lists, &pool->ObjLists); + pool->FreeObjNR++; + return TRUE; +} + +private UInt POEntitiesArrInitOnMemSPace(KMemPool* pool, Addr start, Addr end) +{ + POEntities* entstart = NULL; + POEntities* entend = NULL; + UInt i = 0; + + entstart = (POEntities*)start; + entend = (POEntities*)end; + for(; entstart < entend; i++) + { + POEntitiesInit(entstart); + ListAdd(&entstart->Lists, &pool->ObjLists); + pool->ObjNR++; + pool->FreeObjNR++; + entstart = (POEntities*)(((UInt)entstart) + ((UInt)pool->Size)); + } + IF_EQT_RETURN(0, i, 0); + if(start < pool->VAddrStart) + { + pool->VAddrStart = start; + } + if(end > pool->VAddrEnd) + { + pool->VAddrEnd = end; + } + return i; +} + +private Bool ExtendKMemPoolCapacity(GMemPoolManage* gmpm, KMemPool* pool) +{ + PMSAD* msad = NULL; + Addr start = NULL; + Addr end = NULL; + Bool rets = FALSE; + UInt nr = 0; + IF_NULL_RETURN_FALSE(gmpm); + IF_NULL_RETURN_FALSE(pool); + msad = KrlMmAllocKernPMSADs(pool->AllocPMSADNR); + IF_NULL_RETURN_FALSE(msad); + + start = PMSADRetVAddr(msad); + end = start + (Addr)(KrlMmGetPMSADsSize(msad) - 1); + SetPMSADKMPool(msad); + + nr = POEntitiesArrInitOnMemSPace(pool, start, end); + if(1 > nr) + { + rets = KrlMmFreeKernPMSADs(msad); + IF_EQT_DEAD(FALSE, rets, "KrlMmFreeKernPMSADs is Fail\n"); + return FALSE; + } + return TRUE; +} + +private void* NewPOEntitiesOnKMemPool(GMemPoolManage* gmpm, KMemPool* pool, Size size) +{ + POEntities* entities = NULL; + Bool rets = FALSE; + IF_NULL_RETURN_NULL(gmpm); + IF_NULL_RETURN_NULL(pool); + IF_LTN_RETURN(pool->Size, size, NULL); + IF_GTN_RETURN(pool->Size, (size + PER_POE_INCSIZE), NULL); + entities = PickPOEntitiesOnKMemPool(pool); + if(NULL != entities) + { + INIT_OBJOFPTR_ZERO(entities); + return (void*)entities; + } + rets = ExtendKMemPoolCapacity(gmpm, pool); + IF_NEQ_RETURN(TRUE, rets, NULL); + return (void*)PickPOEntitiesOnKMemPool(pool); +} + +private void* NewPMSADsOnKPMSADsPool(GMemPoolManage* gmpm, KPMSADsPool* pool, PMLHead* head, UInt msadnr) +{ + PMSAD* msad = NULL; + IF_NULL_RETURN_NULL(gmpm); + IF_NULL_RETURN_NULL(pool); + IF_NULL_RETURN_NULL(head); + IF_ZERO_RETURN_NULL(msadnr); + msad = KrlMmAllocKernPMSADs(msadnr); + IF_NULL_RETURN_NULL(msad); + ListAdd(&msad->Lists, &head->Lists); + head->PmsadNR++; + pool->PmsadsNR++; + return (void*)PMSADRetVAddr(msad); +} + +private void* KrlMmNewPMSADsRealizeCore(GMemPoolManage* gmpm, Size size) +{ + void* addr = NULL; + KPMSADsPool* pool = NULL; + PMLHead* head = NULL; + UInt msadnr = 0; + IF_NULL_RETURN_NULL(gmpm); + msadnr = (MSAD_ALIGN(size) >> MSAD_PADR_SLBITS); + pool = &gmpm->PMSADsPool; + head = ForMsadNrRetPMLHeadOnGMemPoolManage(gmpm, msadnr); + IF_NULL_RETURN_NULL(head); + + KrlMmLocked(&pool->Lock); + addr = NewPMSADsOnKPMSADsPool(gmpm, pool, head, msadnr); + KrlMmUnLock(&pool->Lock); + return addr; +} + +private void* KrlMmNewPOEntitiesRealizeCore(GMemPoolManage* gmpm, Size size) +{ + void* addr = NULL; + KMemPool* pool = NULL; + IF_NULL_RETURN_NULL(gmpm); + + pool = ForSizeRetKMemPoolOnGMemPoolManage(gmpm, size); + IF_NULL_RETURN_NULL(pool); + + KrlMmLocked(&pool->Lock); + addr = NewPOEntitiesOnKMemPool(gmpm, pool, size); + KrlMmUnLock(&pool->Lock); + return addr; +} + +private void* KrlMmNewPMSADsRealize(Size size) +{ + void* addr = NULL; + GMemPoolManage* gmpm = NULL; + + gmpm = KrlMmGetGMemPoolAddr(); + IF_NULL_RETURN_NULL(gmpm); + + KrlMmLocked(&gmpm->Lock); + addr = KrlMmNewPMSADsRealizeCore(gmpm, size); + KrlMmUnLock(&gmpm->Lock); + return addr; +} + +private void* KrlMmNewPOEntitiesRealize(Size size) +{ + void* addr = NULL; + GMemPoolManage* gmpm = NULL; + + gmpm = KrlMmGetGMemPoolAddr(); + IF_NULL_RETURN_NULL(gmpm); + + KrlMmLocked(&gmpm->Lock); + addr = KrlMmNewPOEntitiesRealizeCore(gmpm, size); + KrlMmUnLock(&gmpm->Lock); + return addr; +} + +private Bool DelPOEntitiesOnKMemPool(GMemPoolManage* gmpm, KMemPool* pool, void* addr) +{ + Bool rets = FALSE; + IF_NULL_RETURN_FALSE(gmpm); + IF_NULL_RETURN_FALSE(pool); + IF_NULL_RETURN_FALSE(addr); + + rets = PutsPOEntitiesOnKMemPool(pool, (POEntities*)addr); + return rets; +} + +private Bool DelPMSADsOnKPMSADsPool(KPMSADsPool* pool, PMLHead* head, PMSAD* msad) +{ + Bool rets = FALSE; + List* lists = NULL; + PMSAD* tmpmsad = NULL; + + IF_NULL_RETURN_FALSE(pool); + IF_NULL_RETURN_FALSE(head); + IF_NULL_RETURN_FALSE(msad); + KrlMmLocked(&pool->Lock); + ListForEach(lists, &head->Lists) + { + tmpmsad = ListEntry(lists, PMSAD, Lists); + if(tmpmsad == msad) + { + ListDel(&msad->Lists); + head->PmsadNR--; + rets = KrlMmFreeKernPMSADs(msad); + IF_NEQ_DEAD(TRUE, rets, "KrlMmFreeKernPMSADs Called Fail\n"); + if(pool->PmsadsNR > 0) + { + pool->PmsadsNR--; + } + KrlMmUnLock(&pool->Lock); + return rets; + } + } + KrlMmUnLock(&pool->Lock); + return FALSE; +} + +private Bool KrlMmDelPMSADsRealizeCore(GMemPoolManage* gmpm, PMSAD* msad, void* addr) +{ + Bool rets = FALSE; + UInt msadnr = 0; + PMLHead* head = NULL; + IF_NULL_RETURN_FALSE(gmpm); + IF_NULL_RETURN_FALSE(msad); + + msadnr = (UInt)KrlMmGetPMSADsLen(msad); + IF_ZERO_RETURN_FALSE(msadnr); + IF_NEQ_RETURN(FALSE, PMSADIsKMPool(msad), FALSE); + IF_NEQ_DEAD(addr, (void*)PMSADRetVAddr(msad), "addr is not EQ PMSAD Addr\n"); + head = ForMsadNrRetPMLHeadOnGMemPoolManage(gmpm, msadnr); + IF_NULL_RETURN_FALSE(head); + return DelPMSADsOnKPMSADsPool(&gmpm->PMSADsPool, head, msad); +} + +private Bool KrlMmDelPOEntitiesRealizeCore(GMemPoolManage* gmpm, void* addr) +{ + Bool rets = FALSE; + KMemPool* pool = NULL; + IF_NULL_RETURN_FALSE(gmpm); + + pool = ForAddrRetKMemPoolOnGMemPoolManage(gmpm, addr); + IF_NULL_RETURN_FALSE(pool); + + KrlMmLocked(&pool->Lock); + rets = DelPOEntitiesOnKMemPool(gmpm, pool, addr); + KrlMmUnLock(&pool->Lock); + return rets; +} + +private Bool KrlMmDelPOEntitiesRealize(void* addr) +{ + Bool rets = FALSE; + GMemPoolManage* gmpm = NULL; + PMSAD* msad = NULL; + + gmpm = KrlMmGetGMemPoolAddr(); + IF_NULL_RETURN_FALSE(gmpm); + + KrlMmLocked(&gmpm->Lock); + + msad = KrlMmGetPMSADOnVaddr((Addr)addr); + if(msad != NULL) + { + if(PMSADIsKMPool(msad) != TRUE) + { + rets = KrlMmDelPMSADsRealizeCore(gmpm, msad, addr); + KrlMmUnLock(&gmpm->Lock); + return rets; + } + else + { + rets = KrlMmDelPOEntitiesRealizeCore(gmpm, addr); + KrlMmUnLock(&gmpm->Lock); + return rets; + } + } + + rets = KrlMmDelPOEntitiesRealizeCore(gmpm, addr); + KrlMmUnLock(&gmpm->Lock); + return rets; +} + +private UInt CreateNewKMemPoolInit(KMemPool* pool, PMSAD* msad, UInt msadnr, Addr start, Addr end, Size size) +{ + POEntities* entstart = NULL; + POEntities* entend = NULL; + KMemPool* tmp = 0; + UInt i = 0; + tmp = pool + 1; + entstart = (POEntities*)tmp; + entend = (POEntities*)end; + + for(; entstart < entend; i++) + { + POEntitiesInit(entstart); + ListAdd(&entstart->Lists, &pool->ObjLists); + pool->ObjNR++; + pool->FreeObjNR++; + entstart = (POEntities*)(((UInt)entstart) + ((UInt)pool->Size)); + } + + IF_EQT_RETURN(0, i, 0); + + pool->Size = size; + pool->AllocPMSADNR = msadnr; + pool->VAddrStart = start; + pool->VAddrEnd = end; + SetPMSADKMPool(msad); + ListAdd(&msad->Lists, &pool->PMSADsLists); + return i; +} + +private KMemPool* KrlMmCreateKMemPoolRealize(GMemPoolManage* gmpm, UInt msadnr, Size size) +{ + KMemPool* pool = NULL; + PMSAD* msad = NULL; + Bool rets = FALSE; + IF_NULL_RETURN_NULL(gmpm); + msad = KrlMmAllocKernPMSADs(msadnr); + IF_NULL_RETURN_NULL(msad); + pool = (KMemPool*)PMSADRetVAddr(msad); + IF_NULL_RETURN_NULL(pool); + KMemPoolInit(pool); + if(1 > CreateNewKMemPoolInit(pool, msad, msadnr, (Addr)pool, ((Addr)pool + (Addr)KrlMmGetPMSADsSize(msad) - 1), size)) + { + rets = KrlMmFreeKernPMSADs(msad); + IF_EQT_DEAD(FALSE, rets, "KrlMmFreeKernPMSADs is Fail\n"); + return NULL; + } + return pool; +} + +public KMemPool* KrlMmCreateKMemPool(UInt msadnr, Size size) +{ + GMemPoolManage* gmpm; + IF_LTNONE_RETRUN_NULL(msadnr); + IF_LTNONE_RETRUN_NULL(size); + IF_GTN_RETURN(size, 2048, NULL); + gmpm = KrlMmGetGMemPoolAddr(); + IF_NULL_RETURN_NULL(gmpm); + return KrlMmCreateKMemPoolRealize(gmpm, msadnr, size); +} + +public Bool KrlMmDelPOEntities(void* addr) +{ + IF_NULL_RETURN_FALSE(addr); + return KrlMmDelPOEntitiesRealize(addr); +} + +public Bool KrlMmDel(void* addr) +{ + return KrlMmDelPOEntities(addr); +} + +public void* KrlMmNewPOEntities(Size size) +{ + IF_LTNONE_RETRUN_NULL(size); + if(size > 2048); + { + return KrlMmNewPMSADsRealize(size); + } + return KrlMmNewPOEntitiesRealize(size); +} + +public void* KrlMmNew(Size size) +{ + return KrlMmNewPOEntities(size); +} + +public Bool KrlMmPoolInit() +{ + GMemPoolManage* gmpm = NULL; + KMemPool* pool = NULL; + gmpm = KrlMmGetGMemPoolAddr(); + IF_NULL_RETURN_FALSE(gmpm); + GMemPoolManageInit(gmpm); + for(UInt i = 0; i < KMPOOL_MAX; i++) + { + pool = KrlMmCreateKMemPool(PoolParamArr[i].AllocPMSADs, PoolParamArr[i].POESize); + if(NULL != pool) + { + gmpm->KMemPoolArr[i] = pool; + gmpm->KMemPoolNR++; + } + } + return TRUE; +} \ No newline at end of file diff --git a/Kernel/Memory/KrlMmReclaim.c b/Kernel/Memory/KrlMmReclaim.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Memory/KrlMmVmem.c b/Kernel/Memory/KrlMmVmem.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Memory/MEMTestUnit/MemTestUnit.c b/Kernel/Memory/MEMTestUnit/MemTestUnit.c new file mode 100644 index 0000000..2981089 --- /dev/null +++ b/Kernel/Memory/MEMTestUnit/MemTestUnit.c @@ -0,0 +1,288 @@ +/********************************************************** + 内存测试单元文件MemTestUnit.c +*********************************************************** + 彭东 +**********************************************************/ +#include "BaseType.h" +#include "List.h" +#include "HalSync.h" +#include "HalCPU.h" +#include "HalBoot.h" +#include "HalInterface.h" +#include "KrlLog.h" +#include "KrlMmManage.h" +#include "MemTestUnit.h" + + +public Bool MemGMemManageTest() +{ + GMemManage* gmm = NULL; + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_DEAD(gmm); + IF_GTN_DEAD(1, gmm->FreePMSAD, "GMemManage:FreePMSAD < 1\n"); + IF_GTN_DEAD(1, gmm->MaxPMSAD, "GMemManage:MaxPMSAD < 1\n"); + IF_NEQ_DEAD(gmm->MemroySZ, (gmm->MaxPMSAD << MSAD_PADR_SLBITS), "GMemManage:MemorySZ data error\n"); + IF_GTN_DEAD(1, gmm->PAreaNR,"GMemManage:PAreaNR < 1\n"); + IF_EQT_DEAD(NULL, gmm->PAreaStart, "GMemManage:PAreaStart = NULL\n"); + IF_GTN_DEAD(1, gmm->MNodeNR,"GMemManage:MNodeNR < 1\n"); + IF_EQT_DEAD(NULL, gmm->MNodeStart, "GMemManage:MNodeStart = NULL\n"); + return TRUE; +} + +public Bool MemPHYMSPaceAreaTest() +{ + MachStartInfo* msinfo = NULL; + GMemManage* gmm = NULL; + PHYMSPaceArea* parea = NULL; + E820Map* e820 = NULL; + UInt status = 0; + msinfo = HalExPGetMachStartInfoAddr(); + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_DEAD(msinfo); + IF_NULL_DEAD(gmm); + + e820 = (E820Map*)HalPAddrToVAddr((Addr)msinfo->E820PAddr); + IF_EQT_DEAD(NULL, e820, "MachStartInfo:E820PAddr = NULL\n"); + IF_GTN_DEAD(1, msinfo->E820NR, "MachStartInfo:E820NR < 1\n"); + + parea = gmm->PAreaStart; + IF_GTN_DEAD(1, gmm->PAreaNR,"GMemManage:PAreaNR < 1\n"); + IF_EQT_DEAD(NULL, parea, "GMemManage:PAreaStart = NULL\n"); + for(U64 i = 0; i < gmm->PAreaNR; i++) + { + status = 0; + for(U64 e = 0; e < msinfo->E820NR; e++) + { + if((parea[i].SubType == e820[e].Type) && (parea[i].Start == e820[e].Addr) && + (parea[i].End == (e820[e].Size + e820[e].Addr - 1)) && + (parea[i].Size == e820[e].Size)) + { + status++; + } + } + IF_NEQ_DEAD(1, status, "No have E820Map EQ\n"); + IF_NEQ_DEAD(PMSA_F_X86_64, parea[i].Flags, "PHYMSPaceArea:Flags != PMSA_F_X86_64\n"); + } + + return TRUE; +} + +public Bool MemMNodeTest() +{ + GMemManage* gmm = NULL; + MNode* node = NULL; + + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_DEAD(gmm); + + node = gmm->MNodeStart; + IF_EQT_DEAD(NULL, node, "GMemManage:MNodeStart = NULL\n"); + IF_GTN_DEAD(1, gmm->MNodeNR, "GMemManage:MNodeNR < 1\n"); + + for(U64 i = 0; i < gmm->MNodeNR; i++) + { + IF_EQT_DEAD(0, node[i].NodeMemAddrEnd, "MNode: NodeMemAddrEnd = 0"); + } + return TRUE; +} + +public Bool MemPMSADOnPMSADDireTest(MNode* node, PMSADDire* dire, U64 start, U64 end) +{ + PMSAD* msad = NULL; + MNode* cnode = NULL; + U64 paddr = 0; + IF_EQT_DEAD(NULL, node, "PRAM node = NULL\n"); + IF_EQT_DEAD(NULL, dire, "PRAM dire = NULL\n"); + msad = dire->DireStart; + IF_NULL_RETURN_FALSE(msad); + for(UInt i = 0; i < PMSADDIRE_PMSAD_NR; i++) + { + + if(PMSADIsPresent(&msad[i]) == TRUE) + { + paddr = PMSADRetPAddr(&msad[i]); + cnode = PMSADRetItsMNode(&msad[i]); + IF_NEQ_DEAD(cnode, node, "PMSAD doesn't node\n"); + IF_GTN_DEAD(paddr, end, "PMSAD addr Greater than PMSADDire end\n"); + IF_LTN_DEAD(paddr, start, "PMSAD addr Less than PMSADDire start\n"); + } + } + return TRUE; +} + + +public Bool MemPMSADOnMNodeTest(MNode* node) +{ + U64 addrstart = 0; + U64 addrend = 0; + PMSADDire* dire = NULL; + IF_EQT_DEAD(NULL, node, "PRAM node = NULL\n"); + dire = node->PMSADDir.PMSADEArr; + for(UInt i = 0; i < PMSADDIRE_MAX; i++) + { + addrstart = i * PMSADDIRE_SIZE; + addrend = addrstart + PMSADDIRE_SIZE; + MemPMSADOnPMSADDireTest(node, &dire[i], addrstart, addrend); + } + return TRUE; +} + +public Bool MemPMSADTest() +{ + GMemManage* gmm = NULL; + MNode* node = NULL; + + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_DEAD(gmm); + + node = gmm->MNodeStart; + IF_EQT_DEAD(NULL, node, "GMemManage:MNodeStart = NULL\n"); + IF_GTN_DEAD(1, gmm->MNodeNR, "GMemManage:MNodeNR < 1\n"); + for(U64 i = 0; i < gmm->MNodeNR; i++) + { + MemPMSADOnMNodeTest(&node[i]); + } + return TRUE; +} + + +private UInt PMSADBlockIsContinuousAddr(PMSAD* start, PMSAD* end) +{ + PMSAD* msad = NULL; + UInt count = 1; + if(start == end) + { + return 1; + } + msad = start + 1; + while(msad <= end) + { + if(PMSADIsAdjacent(msad - 1, msad) == FALSE) + { + return count; + } + count++; + msad++; + } + return count; +} + +public Bool MemMSPlitMerOnPerPMSADBlockTest(MNode* node, MArea* area, PABHList* pabhl, PMSAD* start) +{ + PMSAD* end = NULL; + PMSAD* msad = NULL; + Addr paddr = 0; + UInt ordernr = 0; + UInt msadnr = 0; + IF_EQT_DEAD(NULL, node, "PRAM node = NULL\n"); + IF_EQT_DEAD(NULL, area, "PRAM area = NULL\n"); + IF_EQT_DEAD(NULL, pabhl, "PRAM pabhl = NULL\n"); + IF_EQT_DEAD(NULL, start, "PRAM splitmer = NULL\n"); + IF_NEQ_DEAD(MF_OLKTY_ODER, start->CountFlags.OLTypeBit, "PMSAD:CountFlags.OLTypeBit != MF_OLKTY_ODER\n"); + + end = (PMSAD*)start->BlockLink; + msad = start; + ordernr = (end - start) + 1; + + msadnr = PMSADBlockIsContinuousAddr(start, end); + IF_NEQ_DEAD(msadnr, pabhl->InOrderPmsadNR, "PMSADBlock is not continuous\n"); + + while(msad <= end) + { + paddr = PMSADRetPAddr(msad); + IF_GTN_DEAD(paddr, area->LogicEnd, "PMSAD PAddr doesn't area\n"); + IF_LTN_DEAD(paddr, area->LogicStart, "PMSAD PAddr doesn't area\n"); + IF_NEQ_DEAD(TRUE, PMSADIsPresent(msad), "PMSAD Not Present\n"); + IF_NEQ_DEAD(TRUE, PMSADIsFree(msad), "PMSAD Not Free\n"); + IF_NEQ_DEAD(node, PMSADRetItsMNode(msad), "PMSAD doesn't node\n"); + IF_NEQ_DEAD(area, PMSADRetItsMArea(msad), "PMSAD doesn't area\n"); + IF_NEQ_DEAD(ordernr, pabhl->InOrderPmsadNR, "PMSAD number NEQ\n"); + } + return TRUE; +} + +public Bool MemMSPlitMerOnPerPABHListTest(MNode* node, MArea* area, MSPlitMer* splitmer, PABHList* pabhl) +{ + Bool rets = FALSE; + List* pos = NULL; + PMSAD* msad = NULL; + IF_EQT_DEAD(NULL, node, "PRAM node = NULL\n"); + IF_EQT_DEAD(NULL, area, "PRAM area = NULL\n"); + IF_EQT_DEAD(NULL, splitmer, "PRAM splitmer = NULL\n"); + IF_EQT_DEAD(NULL, pabhl, "PRAM pabhl = NULL\n"); + if(0 < pabhl->PmsadNR) + { + rets = ListIsEmptyCareful(&pabhl->FreeLists); + IF_EQT_DEAD(TRUE, rets, "PABHList:FreeLists == Empty\n"); + ListForEach(pos, &pabhl->FreeLists) + { + msad = ListEntry(pos, PMSAD, Lists); + MemMSPlitMerOnPerPMSADBlockTest(node, area, pabhl, msad); + } + } +} + +public Bool MemMSPlitMerTest(MNode* node, MArea* area, MSPlitMer* splitmer) +{ + PABHList* pabhl = NULL; + IF_EQT_DEAD(NULL, node, "PRAM node = NULL\n"); + IF_EQT_DEAD(NULL, area, "PRAM area = NULL\n"); + IF_EQT_DEAD(NULL, splitmer, "PRAM splitmer = NULL\n"); + pabhl = splitmer->PAddrBlockArr; + for(UInt i = 0; i < MSPLMER_ARR_LMAX; i++) + { + MemMSPlitMerOnPerPABHListTest(node, area, splitmer, &pabhl[i]); + } + return TRUE; +} + +public Bool MemMAreaOnPerMAreaTest(MNode* node, MArea* area) +{ + IF_EQT_DEAD(NULL, node, "PRAM node = NULL\n"); + IF_EQT_DEAD(NULL, area, "PRAM area = NULL\n"); + if(0 < area->MaxPMSAD) + { + MemMSPlitMerTest(node, area, &area->MSPLMerData); + } + return; +} + +public Bool MemMAreaOnMNodeTest(MNode* node) +{ + MArea* area = NULL; + IF_EQT_DEAD(NULL, node, "PRAM node = NULL\n"); + area = &node->MAreaArr; + for(UInt i = 0; i < MEMAREA_MAX; i++) + { + MemMAreaOnPerMAreaTest(node, &area[i]); + } + return TRUE; +} + +public Bool MemMAreaTest() +{ + GMemManage* gmm = NULL; + MNode* node = NULL; + + gmm = KrlMmGetGMemManageAddr(); + IF_NULL_DEAD(gmm); + + node = gmm->MNodeStart; + IF_EQT_DEAD(NULL, node, "GMemManage:MNodeStart = NULL\n"); + IF_GTN_DEAD(1, gmm->MNodeNR, "GMemManage:MNodeNR < 1\n"); + for(U64 i = 0; i < gmm->MNodeNR; i++) + { + MemMAreaOnMNodeTest(&node[i]); + } + return TRUE; +} + +public Bool MemTestUnit() +{ + MemGMemManageTest(); + MemPHYMSPaceAreaTest(); + MemMNodeTest(); + MemPMSADTest(); + MemMAreaTest(); + return TRUE; +} \ No newline at end of file diff --git a/Kernel/Object/KrlObjAsyncIPC.c b/Kernel/Object/KrlObjAsyncIPC.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Object/KrlObjExecutor.c b/Kernel/Object/KrlObjExecutor.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Object/KrlObjInterface.c b/Kernel/Object/KrlObjInterface.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Object/KrlObjManage.c b/Kernel/Object/KrlObjManage.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Object/KrlObjMem.c b/Kernel/Object/KrlObjMem.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Object/KrlObjSecurity.c b/Kernel/Object/KrlObjSecurity.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Object/KrlObjSyncIPC.c b/Kernel/Object/KrlObjSyncIPC.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Object/KrlObjThread.c b/Kernel/Object/KrlObjThread.c new file mode 100644 index 0000000..e69de29 diff --git a/Kernel/Object/KrlObjUniversal.c b/Kernel/Object/KrlObjUniversal.c new file mode 100644 index 0000000..e69de29