Also did more work on getting the x86_64 port working.
- Related changes to VESA driver and usermode
-BUILD_NUM = 2150
+BUILD_NUM = 2156
#ifndef _ARCH_H_
#define _ARCH_H_
-// - Memory Layout
-#define MM_USER_MIN 0x00200000
-#define USER_STACK_SZ 0x00010000
-#define USER_STACK_TOP 0x00800000
-#define MM_USER_MAX 0xBC000000
-#define MM_PPD_MIN 0xBC000000 // Per-Process Data
-#define MM_PPD_VFS 0xBC000000 //
-#define MM_PPD_CFG 0xBFFFF000 //
-#define MM_PPD_MAX 0xB0000000
+// - Base Defintions
#define KERNEL_BASE 0xC0000000
-#define MM_KHEAP_BASE 0xC0400000 // C+4MiB
-#define MM_KHEAP_MAX 0xCF000000 //
-#define MM_KERNEL_VFS 0xCF000000 //
-#define MM_KUSER_CODE 0xCFFF0000 // 16 Pages
-#define MM_MODULE_MIN 0xD0000000 // Lowest Module Address
-#define MM_MODULE_MAX 0xF0000000 // 512 MiB
-
#define BITS 32
// - Processor/Machine Specific Features
#ifndef _MM_VIRT_H
#define _MM_VIRT_H
+
+// - Memory Layout
+#define MM_USER_MIN 0x00200000
+#define USER_STACK_SZ 0x00010000
+#define USER_STACK_TOP 0x00800000
+#define USER_LIB_MAX 0xBC000000
+#define MM_USER_MAX 0xBC000000 // Top load address for user libraries
+#define MM_PPD_MIN 0xBC000000 // Per-Process Data
+#define MM_PPD_VFS 0xBC000000 //
+#define MM_PPD_CFG 0xBFFFF000 //
+#define MM_PPD_MAX 0xC0000000 //
+
+#define MM_KHEAP_BASE 0xC0400000 // C+4MiB
+#define MM_KHEAP_MAX 0xCF000000 //
+#define MM_KERNEL_VFS 0xCF000000 //
+#define MM_KUSER_CODE 0xCFFF0000 // 16 Pages
+#define MM_MODULE_MIN 0xD0000000 // Lowest Module Address
+#define MM_MODULE_MAX 0xF0000000 // 512 MiB
+
// === FUNCTIONS ===
extern void MM_FinishVirtualInit();
-extern void MM_SetCR3(Uint32 CR3);
+extern void MM_SetCR3(Uint CR3);
extern tPAddr MM_Allocate(tVAddr VAddr);
extern void MM_Deallocate(tVAddr VAddr);
extern int MM_Map(tVAddr VAddr, tPAddr PAddr);
#define DEBUG 0
#define SANITY 1
#include <acess.h>
+#include <mm_virt.h>
#include <mm_phys.h>
#include <proc.h>
}
/**
- * \fn void MM_SetCR3(tPAddr CR3)
+ * \fn void MM_SetCR3(Uint CR3)
* \brief Sets the current process space
*/
-void MM_SetCR3(tPAddr CR3)
+void MM_SetCR3(Uint CR3)
{
__asm__ __volatile__ ("mov %0, %%cr3"::"r"(CR3));
}
#LD = ld
#OBJDUMP = objdump
-CPPFLAGS =
-CFLAGS = $(KERNEL_CFLAGS)
-ASFLAGS = -f elf
+MAX_CPUS := 4
+
+CPPFLAGS := -DMAX_CPUS=$(MAX_CPUS)
+CFLAGS := $(KERNEL_CFLAGS)
+ASFLAGS := -f elf64 -D MAX_CPUS=$(MAX_CPUS)
ifeq ($(ARCH),amd64)
ASFLAGS += -D AMD64=1
endif
-A_OBJ = start32.ao start64.ao
-A_OBJ += main.o lib.o
+A_OBJ = start32.ao start64.ao desctab.ao
+A_OBJ += main.o lib.o proc.o
--- /dev/null
+;
+;
+;
+[BITS 64]
+
+MM_LOCALAPIC equ 0xFFFFFD0000000000
+
+[section .text]
+Desctab_Init:
+ ; Install IRQ Handlers
+
+[section .data]
+gIDT:
+ times 256 dw 0x00080000, 0x00008E00, 0, 0 ; 64-bit Interrupt Gate, CS = 0x8, IST0
+
+%macro DEFERR 1
+Isr%1:
+ push 0
+ push %1
+ jmp ErrorCommon
+%endmacro
+%macro DEFERRNO 1
+Isr%1:
+ push %1
+ jmp ErrorCommon
+%endmacro
+
+%macro DEFIRQ 1
+Irq%1:
+ push 0
+ push %1
+ jmp IrqCommon
+%endmacro
+
+%macro PUSH_EX 1-*
+ %rep %0
+ push %1
+ %rotate 1
+ %endrep
+%endmacro
+%macro POP_EX 1-*
+ %rep %0
+ %rotate -1
+ pop %1
+ %endrep
+%endmacro
+
+%macro PUSH_GPR 0
+ PUSH_EX r15, r14, r13, r12, r11, r10, r9, r8
+ PUSH_EX rsi, rdi, rbp, rsp, rbx, rdx, rcx, rax
+%endmacro
+%macro POP_GPR 0
+ POP_EX rsi, rdi, rbp, rsp, rbx, rdx, rcx, rax
+ POP_EX r15, r14, r13, r12, r11, r10, r9, r8
+%endmacro
+
+[extern Proc_Scheduler]
+SchedulerIRQ:
+ ; TODO: Find Current CPU
+ PUSH_GPR
+ ;PUSH_FPU
+ ;PUSH_XMM
+
+ xor rsi, rsi
+ mov rdi, MM_LOCALAPIC+0x20
+ mov esi, [rdi]
+ call Proc_Scheduler
+
+ ;POP_XMM
+ ;POP_FPU
+ POP_GPR
+ iret
#define IS_LOCKED(lockptr) (!!(*(tSpinlock*)lockptr))
#define LOCK(lockptr) do {int v=1;\
while(v)\
- __asm__ __volatile__("lock xchgl %%eax, (%%edi)":"=a"(v):"a"(1),"D"(lockptr));\
+ __asm__ __volatile__("lock xchgl %%eax, (%%rdi)":"=a"(v):"a"(1),"D"(lockptr));\
}while(0)
-#define RELEASE(lockptr) __asm__ __volatile__("lock andl $0, (%%edi)"::"D"(lockptr));
+#define RELEASE(lockptr) __asm__ __volatile__("lock andl $0, (%%rdi)"::"D"(lockptr));
#define HALT() __asm__ __volatile__ ("hlt")
// Systemcall Registers
+// TODO: Fix this structure
typedef struct sSyscallRegs
{
Uint Arg4, Arg5; // RDI, RSI
--- /dev/null
+/**
+ */
+#ifndef _DESCTAB_H_
+#define _DESCTAB_H_
+
+typedef struct {
+ union
+ {
+ struct
+ {
+ Uint16 LimitLow;
+ Uint16 BaseLow;
+ Uint8 BaseMid;
+ Uint8 Access;
+ struct {
+ unsigned LimitHi: 4;
+ unsigned Flags: 4;
+ } __attribute__ ((packed));
+ Uint8 BaseHi;
+ };
+ Uint32 DWord[2];
+ };
+} __attribute__ ((packed)) tGDT;
+
+typedef struct {
+ Uint16 OffsetLo;
+ Uint16 CS;
+ Uint16 Flags; // 0-2: IST, 3-7: 0, 8-11: Type, 12: 0, 13-14: DPL, 15: Present
+ Uint16 OffsetMid;
+ Uint32 OffsetHi;
+ Uint32 Reserved;
+} __attribute__ ((packed)) tIDT;
+
+typedef struct {
+ Uint32 Rsvd1;
+
+ Uint64 RSP0;
+ Uint64 RSP1;
+ Uint64 RSP2;
+
+ Uint32 Rsvd2[2];
+
+ // Interrupt Stack Table Pointers
+ Uint64 IST1;
+ Uint64 IST2;
+ Uint64 IST3;
+ Uint64 IST4;
+ Uint64 IST5;
+ Uint64 IST6;
+ Uint64 IST7;
+
+ Uint32 Rsvd3[2];
+ Uint16 Rsvd4;
+ Uint16 IOMapBase;
+} __attribute__ ((packed)) tTSS;
+
+#endif
* Userland - Lower Half
* Kernel land - Upper Half
*
- * 0xFFFF8000 00000000 - 0xFFFFFFFF FFFFFFFF 2**47 Kernel Range
- * 8000 00000000 - 8000 7FFFFFFF 2 GiB Identity Map
- * 8000 80000000 - 8001 00000000 2 GiB Kernel Heap
- * 9000 00000000 - 9800 00000000 cbf Module Space
- * 9800 00000000 - 9900 00000000 cbf Per-Process Data
- * 9900 00000000 - 9A00 00000000 cbf Kernel VFS
+ * START ADDRESS END ADDRESS BITS SIZE NAME
+ * 0xFFFF8000 00000000 - 0xFFFFFFFF FFFFFFFF 47 128 TiB Kernel Range
+ * 8000 00000000 - 8000 7FFFFFFF 31 2 GiB Identity Map
+ * 8000 80000000 - 9000 00000000 ~44 16 TiB Kernel Heap
+ * 9000 00000000 - 9800 00000000 43 8 TiB Module Space
+ * 9800 00000000 - 9900 00000000 40 1 TiB Per-Process Data
+ * 9900 00000000 - 9A00 00000000 40 1 TiB Kernel VFS
+ * A000 00000000 - B000 00000000 44 16 TiB Kernel Stacks
+ * D000 00000000 - E000 00000000 44 16 TiB Hardware Mappings
+ * FE00 00000000 - FE80 00000000 39 512 GiB Fractal Mapping
+ * FE80 00000000 - FF00 00000000 39 512 GiB Temp Fractal Mapping
*/
-#define MM_USER_MIN 0x00008FFF##FFFFF000
+#define MM_USER_MIN 0x00000000##00010000
+#define USER_LIB_MAX 0x00008000##00000000
+#define USER_STACK_SZ 0x00000000##00020000 // 64 KiB
+#define USER_STACK_TOP 0x00008FFF##FFFFF000
+#define MM_USER_MAX 0x00008FFF##FFFFF000
//#define KERNEL_BASE 0xFFF8000##00000000
-#define MM_KHEAP_BASE (KERNEL_BASE|(0x0000##80000000))
-#define MM_KHEAP_MAX (KERNEL_BASE|(0x0001##00000000))
-#define MM_MODULE_MIN (KERNEL_BASE|(0x1000##00000000))
-#define MM_MODULE_MAX (KERNEL_BASE|(0x1800##00000000))
-#define MM_PPD_BASE (KERNEL_BASE|(0x1800##00000000))
-#define MM_PPD_VFS (KERNEL_BASE|(0x1880##00000000))
-#define MM_KERNEL_VFS (KERNEL_BASE|(0x1900##00000000))
+#define MM_KHEAP_BASE (KERNEL_BASE|(0x8000##80000000))
+#define MM_KHEAP_MAX (KERNEL_BASE|(0x8001##00000000))
+#define MM_MODULE_MIN (KERNEL_BASE|(0x9000##00000000))
+#define MM_MODULE_MAX (KERNEL_BASE|(0x9800##00000000))
+#define MM_PPD_BASE (KERNEL_BASE|(0x9800##00000000))
+#define MM_PPD_CFG MM_PPD_BASE
+#define MM_PPD_VFS (KERNEL_BASE|(0x9880##00000000))
+#define MM_KERNEL_VFS (KERNEL_BASE|(0x9900##00000000))
+#define MM_KSTACK_BASE (KERNEL_BASE|(0xA000##00000000))
+#define MM_KSTACK_TOP (KERNEL_BASE|(0xC000##00000000))
+
+#define MM_HWMAP_BASE (KERNEL_BASE|(0xD000##00000000))
+#define MM_HWMAP_TOP (KERNEL_BASE|(0xE000##00000000))
+
+#define MM_LOCALAPIC (KERNEL_BASE|(0xFD00##00000000))
+#define MM_FRACTAL_BASE (KERNEL_BASE|(0xFE00##00000000))
+#define MM_TMPFRAC_BASE (KERNEL_BASE|(0xFE80##00000000))
+
+
+// === FUNCTIONS ===
+void MM_FinishVirtualInit(void);
+tVAddr MM_NewKStack(void);
+tVAddr MM_Clone(void);
+tVAddr MM_NewWorkerStack(void);
#endif
#include <arch.h>
+// Register Structure
+// TODO: Rebuild once IDT code is done
+typedef struct {
+ Uint ds, es, fs, gs;
+ Uint r15, r14, r13, r12;
+ Uint r11, r10, r9, r8;
+ Uint rdi, rsi, rbp, krsp;
+ Uint rbx, rdx, rcx, rax;
+ Uint int_num, err_code;
+ Uint eip, cs;
+ Uint eflags, esp, ss;
+} tRegs;
+
+/**
+ * \brief Memory State for thread handler
+ */
typedef struct sMemoryState
{
tPAddr CR3;
} tMemoryState;
+/**
+ * \brief Task state for thread handler
+ */
typedef struct sTaskState
{
Uint RIP, RSP, RBP;
}
// === Memory Manipulation ===
+int memcmp(const void *__dest, const void *__src, size_t __count)
+{
+ if( ((tVAddr)__dest & 7) != ((tVAddr)__src & 7) ) {
+ const Uint8 *src = __src, *dst = __dest;
+ while(__count)
+ {
+ if( *src != *dst )
+ return *dst - *src;
+ src ++; dst ++; __count --;
+ }
+ return 0;
+ }
+ else {
+ const Uint8 *src = __src;
+ const Uint8 *dst = __dest;
+ const Uint64 *src64, *dst64;
+
+ while( (tVAddr)src & 7 && __count ) {
+ if( *src != *dst )
+ return *dst - *src;
+ dst ++; src ++; __count --;
+ }
+
+ src64 = (void*)src;
+ dst64 = (void*)dst;
+
+ while( __count >= 8 )
+ {
+ if( *src64 != *dst64 )
+ {
+ src = (void*)src64;
+ dst = (void*)dst64;
+ if(src[0] != dst[0]) return dst[0]-src[0];
+ if(src[1] != dst[1]) return dst[1]-src[1];
+ if(src[2] != dst[2]) return dst[2]-src[2];
+ if(src[3] != dst[3]) return dst[3]-src[3];
+ if(src[4] != dst[4]) return dst[4]-src[4];
+ if(src[5] != dst[5]) return dst[5]-src[5];
+ if(src[6] != dst[6]) return dst[6]-src[6];
+ if(src[7] != dst[7]) return dst[7]-src[7];
+ return -1; // This should never happen
+ }
+ __count -= 8;
+ src64 ++;
+ dst64 ++;
+ }
+
+ src = (void*)src64;
+ dst = (void*)dst64;
+ while( __count-- )
+ {
+ if(*dst != *src) return *dst - *src;
+ dst ++;
+ src ++;
+ }
+ }
+ return 0;
+}
+
void *memcpy(void *__dest, const void *__src, size_t __count)
{
if( ((tVAddr)__dest & 7) != ((tVAddr)__src & 7) )
void *memset(void *__dest, int __val, size_t __count)
{
if( __val != 0 || ((tVAddr)__dest & 7) != 0 )
- __asm__ __volatile__ ("rep stosb" : : "D"(__dest),"a"(__val),"c"(__count));
+ __asm__ __volatile__ ("rep stosb" : : "D"(__dest),"a"(__val),"c"(__count));
else {
- Uint8 *dst = __dest;
+ Uint8 *dst = __dest;
- __asm__ __volatile__ ("rep stosq" : : "D"(dst),"a"(0),"c"(__count/8));
- dst += __count & ~7;
- __count = __count & 7;
- while( __count-- )
- *dst++ = 0;
+ __asm__ __volatile__ ("rep stosq" : : "D"(dst),"a"(0),"c"(__count/8));
+ dst += __count & ~7;
+ __count = __count & 7;
+ while( __count-- )
+ *dst++ = 0;
}
return __dest;
}
--- /dev/null
+/*
+ * AcessOS Microkernel Version
+ * proc.c
+ */
+#include <acess.h>
+#include <proc.h>
+#include <threads.h>
+#include <desctab.h>
+#include <mm_virt.h>
+#include <errno.h>
+#if USE_MP
+# include <mp.h>
+#endif
+
+// === FLAGS ===
+#define DEBUG_TRACE_SWITCH 0
+
+// === CONSTANTS ===
+#define SWITCH_MAGIC 0x55ECAFFF##FFFACE55 // There is no code in this area
+// Base is 1193182
+#define TIMER_DIVISOR 11931 //~100Hz
+
+// === IMPORTS ===
+extern tGDT gGDT[];
+extern void APStartup(); // 16-bit AP startup code
+extern Uint GetRIP(); // start.asm
+extern Uint64 gaInitPML4[512]; // start.asm
+extern void Kernel_Stack_Top;
+extern tSpinlock glThreadListLock;
+extern int giNumCPUs;
+extern int giNextTID;
+extern int giTotalTickets;
+extern int giNumActiveThreads;
+extern tThread gThreadZero;
+extern tThread *gActiveThreads;
+extern tThread *gSleepingThreads;
+extern tThread *gDeleteThreads;
+extern tThread *Threads_GetNextToRun(int CPU);
+extern void Threads_Dump();
+extern tThread *Threads_CloneTCB(Uint *Err, Uint Flags);
+extern void Proc_AlterUserReturnAddr();
+
+// === PROTOTYPES ===
+void ArchThreads_Init();
+#if USE_MP
+void MP_StartAP(int CPU);
+void MP_SendIPI(Uint8 APICID, int Vector, int DeliveryMode);
+#endif
+void Proc_Start();
+tThread *Proc_GetCurThread();
+void Proc_ChangeStack();
+ int Proc_Clone(Uint *Err, Uint Flags);
+void Proc_StartProcess(Uint16 SS, Uint Stack, Uint Flags, Uint16 CS, Uint IP);
+void Proc_CallFaultHandler(tThread *Thread);
+void Proc_Scheduler();
+
+// === GLOBALS ===
+// --- Multiprocessing ---
+#if USE_MP
+volatile int giNumInitingCPUs = 0;
+tMPInfo *gMPFloatPtr = NULL;
+tAPIC *gpMP_LocalAPIC = NULL;
+Uint8 gaAPIC_to_CPU[256] = {0};
+tCPU gaCPUs[MAX_CPUS];
+#else
+tThread *gCurrentThread = NULL;
+#endif
+tTSS *gTSSs = NULL;
+tTSS gTSS0 = {0};
+// --- Error Recovery ---
+Uint32 gaDoubleFaultStack[1024];
+
+// === CODE ===
+/**
+ * \fn void ArchThreads_Init()
+ * \brief Starts the process scheduler
+ */
+void ArchThreads_Init()
+{
+ Uint pos = 0;
+
+ #if USE_MP
+ tMPTable *mptable;
+
+ // Mark BSP as active
+ gaCPUs[0].State = 2;
+
+ // -- Initialise Multiprocessing
+ // Find MP Floating Table
+ // - EBDA/Last 1Kib (640KiB)
+ for(pos = KERNEL_BASE|0x9F000; pos < (KERNEL_BASE|0xA0000); pos += 16) {
+ if( *(Uint*)(pos) == MPPTR_IDENT ) {
+ Log("Possible %p", pos);
+ if( ByteSum((void*)pos, sizeof(tMPInfo)) != 0 ) continue;
+ gMPFloatPtr = (void*)pos;
+ break;
+ }
+ }
+ // - Last KiB (512KiB base mem)
+ if(!gMPFloatPtr) {
+ for(pos = KERNEL_BASE|0x7F000; pos < (KERNEL_BASE|0x80000); pos += 16) {
+ if( *(Uint*)(pos) == MPPTR_IDENT ) {
+ Log("Possible %p", pos);
+ if( ByteSum((void*)pos, sizeof(tMPInfo)) != 0 ) continue;
+ gMPFloatPtr = (void*)pos;
+ break;
+ }
+ }
+ }
+ // - BIOS ROM
+ if(!gMPFloatPtr) {
+ for(pos = KERNEL_BASE|0xE0000; pos < (KERNEL_BASE|0x100000); pos += 16) {
+ if( *(Uint*)(pos) == MPPTR_IDENT ) {
+ Log("Possible %p", pos);
+ if( ByteSum((void*)pos, sizeof(tMPInfo)) != 0 ) continue;
+ gMPFloatPtr = (void*)pos;
+ break;
+ }
+ }
+ }
+
+ // If the MP Table Exists, parse it
+ if(gMPFloatPtr)
+ {
+ int i;
+ tMPTable_Ent *ents;
+ Log("gMPFloatPtr = %p", gMPFloatPtr);
+ Log("*gMPFloatPtr = {");
+ Log("\t.Sig = 0x%08x", gMPFloatPtr->Sig);
+ Log("\t.MPConfig = 0x%08x", gMPFloatPtr->MPConfig);
+ Log("\t.Length = 0x%02x", gMPFloatPtr->Length);
+ Log("\t.Version = 0x%02x", gMPFloatPtr->Version);
+ Log("\t.Checksum = 0x%02x", gMPFloatPtr->Checksum);
+ Log("\t.Features = [0x%02x,0x%02x,0x%02x,0x%02x,0x%02x]",
+ gMPFloatPtr->Features[0], gMPFloatPtr->Features[1],
+ gMPFloatPtr->Features[2], gMPFloatPtr->Features[3],
+ gMPFloatPtr->Features[4]
+ );
+ Log("}");
+
+ mptable = (void*)( KERNEL_BASE|gMPFloatPtr->MPConfig );
+ Log("mptable = %p", mptable);
+ Log("*mptable = {");
+ Log("\t.Sig = 0x%08x", mptable->Sig);
+ Log("\t.BaseTableLength = 0x%04x", mptable->BaseTableLength);
+ Log("\t.SpecRev = 0x%02x", mptable->SpecRev);
+ Log("\t.Checksum = 0x%02x", mptable->Checksum);
+ Log("\t.OEMID = '%8c'", mptable->OemID);
+ Log("\t.ProductID = '%8c'", mptable->ProductID);
+ Log("\t.OEMTablePtr = %p'", mptable->OEMTablePtr);
+ Log("\t.OEMTableSize = 0x%04x", mptable->OEMTableSize);
+ Log("\t.EntryCount = 0x%04x", mptable->EntryCount);
+ Log("\t.LocalAPICMemMap = 0x%08x", mptable->LocalAPICMemMap);
+ Log("\t.ExtendedTableLen = 0x%04x", mptable->ExtendedTableLen);
+ Log("\t.ExtendedTableChecksum = 0x%02x", mptable->ExtendedTableChecksum);
+ Log("}");
+
+ gpMP_LocalAPIC = (void*)MM_MapHWPage(mptable->LocalAPICMemMap, 1);
+
+ ents = mptable->Entries;
+ giNumCPUs = 0;
+
+ for( i = 0; i < mptable->EntryCount; i ++ )
+ {
+ int entSize = 0;
+ switch( ents->Type )
+ {
+ case 0: // Processor
+ entSize = 20;
+ Log("%i: Processor", i);
+ Log("\t.APICID = %i", ents->Proc.APICID);
+ Log("\t.APICVer = 0x%02x", ents->Proc.APICVer);
+ Log("\t.CPUFlags = 0x%02x", ents->Proc.CPUFlags);
+ Log("\t.CPUSignature = 0x%08x", ents->Proc.CPUSignature);
+ Log("\t.FeatureFlags = 0x%08x", ents->Proc.FeatureFlags);
+
+
+ if( !(ents->Proc.CPUFlags & 1) ) {
+ Log("DISABLED");
+ break;
+ }
+
+ // Check if there is too many processors
+ if(giNumCPUs >= MAX_CPUS) {
+ giNumCPUs ++; // If `giNumCPUs` > MAX_CPUS later, it will be clipped
+ break;
+ }
+
+ // Initialise CPU Info
+ gaAPIC_to_CPU[ents->Proc.APICID] = giNumCPUs;
+ gaCPUs[giNumCPUs].APICID = ents->Proc.APICID;
+ gaCPUs[giNumCPUs].State = 0;
+ giNumCPUs ++;
+
+ // Send IPI
+ if( !(ents->Proc.CPUFlags & 2) )
+ {
+ MP_StartAP( giNumCPUs-1 );
+ }
+
+ break;
+ case 1: // Bus
+ entSize = 8;
+ Log("%i: Bus", i);
+ Log("\t.ID = %i", ents->Bus.ID);
+ Log("\t.TypeString = '%6c'", ents->Bus.TypeString);
+ break;
+ case 2: // I/O APIC
+ entSize = 8;
+ Log("%i: I/O APIC", i);
+ Log("\t.ID = %i", ents->IOAPIC.ID);
+ Log("\t.Version = 0x%02x", ents->IOAPIC.Version);
+ Log("\t.Flags = 0x%02x", ents->IOAPIC.Flags);
+ Log("\t.Addr = 0x%08x", ents->IOAPIC.Addr);
+ break;
+ case 3: // I/O Interrupt Assignment
+ entSize = 8;
+ Log("%i: I/O Interrupt Assignment", i);
+ Log("\t.IntType = %i", ents->IOInt.IntType);
+ Log("\t.Flags = 0x%04x", ents->IOInt.Flags);
+ Log("\t.SourceBusID = 0x%02x", ents->IOInt.SourceBusID);
+ Log("\t.SourceBusIRQ = 0x%02x", ents->IOInt.SourceBusIRQ);
+ Log("\t.DestAPICID = 0x%02x", ents->IOInt.DestAPICID);
+ Log("\t.DestAPICIRQ = 0x%02x", ents->IOInt.DestAPICIRQ);
+ break;
+ case 4: // Local Interrupt Assignment
+ entSize = 8;
+ Log("%i: Local Interrupt Assignment", i);
+ Log("\t.IntType = %i", ents->LocalInt.IntType);
+ Log("\t.Flags = 0x%04x", ents->LocalInt.Flags);
+ Log("\t.SourceBusID = 0x%02x", ents->LocalInt.SourceBusID);
+ Log("\t.SourceBusIRQ = 0x%02x", ents->LocalInt.SourceBusIRQ);
+ Log("\t.DestLocalAPICID = 0x%02x", ents->LocalInt.DestLocalAPICID);
+ Log("\t.DestLocalAPICIRQ = 0x%02x", ents->LocalInt.DestLocalAPICIRQ);
+ break;
+ default:
+ Log("%i: Unknown (%i)", i, ents->Type);
+ break;
+ }
+ ents = (void*)( (Uint)ents + entSize );
+ }
+
+ if( giNumCPUs > MAX_CPUS ) {
+ Warning("Too many CPUs detected (%i), only using %i of them", giNumCPUs, MAX_CPUS);
+ giNumCPUs = MAX_CPUS;
+ }
+
+ while( giNumInitingCPUs )
+ MM_FinishVirtualInit();
+
+ Panic("Uh oh... MP Table Parsing is unimplemented\n");
+ }
+ else {
+ Log("No MP Table was found, assuming uniprocessor\n");
+ giNumCPUs = 1;
+ gTSSs = &gTSS0;
+ }
+ #else
+ giNumCPUs = 1;
+ gTSSs = &gTSS0;
+ MM_FinishVirtualInit();
+ #endif
+
+ #if USE_MP
+ // Initialise Normal TSS(s)
+ for(pos=0;pos<giNumCPUs;pos++)
+ {
+ #else
+ pos = 0;
+ #endif
+ gTSSs[pos].RSP0 = 0; // Set properly by scheduler
+ gGDT[6+pos*2].BaseLow = ((Uint)(&gTSSs[pos])) & 0xFFFF;
+ gGDT[6+pos*2].BaseMid = ((Uint)(&gTSSs[pos])) >> 16;
+ gGDT[6+pos*2].BaseHi = ((Uint)(&gTSSs[pos])) >> 24;
+ gGDT[6+pos*2+1].DWord[0] = ((Uint)(&gTSSs[pos])) >> 32;
+ #if USE_MP
+ }
+ for(pos=0;pos<giNumCPUs;pos++) {
+ #endif
+ __asm__ __volatile__ ("ltr %%ax"::"a"(0x30+pos*8));
+ #if USE_MP
+ }
+ #endif
+
+ #if USE_MP
+ gaCPUs[0].Current = &gThreadZero;
+ #else
+ gCurrentThread = &gThreadZero;
+ #endif
+
+ gThreadZero.MemState.CR3 = (Uint)gaInitPML4 - KERNEL_BASE;
+
+ // Set timer frequency
+ outb(0x43, 0x34); // Set Channel 0, Low/High, Rate Generator
+ outb(0x40, TIMER_DIVISOR&0xFF); // Low Byte of Divisor
+ outb(0x40, (TIMER_DIVISOR>>8)&0xFF); // High Byte
+
+ // Create Per-Process Data Block
+ MM_Allocate(MM_PPD_CFG);
+
+ // Change Stacks
+ Proc_ChangeStack();
+}
+
+#if USE_MP
+void MP_StartAP(int CPU)
+{
+ Log("Starting AP %i (APIC %i)", CPU, gaCPUs[CPU].APICID);
+ // Set location of AP startup code and mark for a warm restart
+ *(Uint16*)(KERNEL_BASE|0x467) = (Uint)&APStartup - (KERNEL_BASE|0xFFFF0);
+ *(Uint16*)(KERNEL_BASE|0x469) = 0xFFFF;
+ outb(0x70, 0x0F); outb(0x71, 0x0A); // Warm Reset
+ MP_SendIPI(gaCPUs[CPU].APICID, 0, 5);
+ giNumInitingCPUs ++;
+}
+
+void MP_SendIPI(Uint8 APICID, int Vector, int DeliveryMode)
+{
+ Uint32 addr = (Uint)gpMP_LocalAPIC + 0x300;
+ Uint32 val;
+
+ // High
+ val = (Uint)APICID << 24;
+ Log("*%p = 0x%08x", addr+0x10, val);
+ *(Uint32*)(addr+0x10) = val;
+ // Low (and send)
+ val = ((DeliveryMode & 7) << 8) | (Vector & 0xFF);
+ Log("*%p = 0x%08x", addr, val);
+ *(Uint32*)addr = val;
+}
+#endif
+
+/**
+ * \fn void Proc_Start()
+ * \brief Start process scheduler
+ */
+void Proc_Start()
+{
+ // Start Interrupts (and hence scheduler)
+ __asm__ __volatile__("sti");
+}
+
+/**
+ * \fn tThread *Proc_GetCurThread()
+ * \brief Gets the current thread
+ */
+tThread *Proc_GetCurThread()
+{
+ #if USE_MP
+ return gaCPUs[ gaAPIC_to_CPU[gpMP_LocalAPIC->ID.Val&0xFF] ].Current;
+ #else
+ return gCurrentThread;
+ #endif
+}
+
+/**
+ * \fn void Proc_ChangeStack()
+ * \brief Swaps the current stack for a new one (in the proper stack reigon)
+ */
+void Proc_ChangeStack()
+{
+ Uint rsp, rbp;
+ Uint tmp_rbp, old_rsp;
+ Uint curBase, newBase;
+
+ __asm__ __volatile__ ("mov %%rsp, %0":"=r"(rsp));
+ __asm__ __volatile__ ("mov %%rbp, %0":"=r"(rbp));
+
+ old_rsp = rsp;
+
+ // Create new KStack
+ newBase = MM_NewKStack();
+ // Check for errors
+ if(newBase == 0) {
+ Panic("What the?? Unable to allocate space for initial kernel stack");
+ return;
+ }
+
+ curBase = (Uint)&Kernel_Stack_Top;
+
+ LOG("curBase = 0x%x, newBase = 0x%x", curBase, newBase);
+
+ // Get ESP as a used size
+ rsp = curBase - rsp;
+ LOG("memcpy( %p, %p, 0x%x )", (void*)(newBase - rsp), (void*)(curBase - rsp), rsp );
+ // Copy used stack
+ memcpy( (void*)(newBase - rsp), (void*)(curBase - rsp), rsp );
+ // Get ESP as an offset in the new stack
+ rsp = newBase - rsp;
+ // Adjust EBP
+ rbp = newBase - (curBase - rbp);
+
+ // Repair EBPs & Stack Addresses
+ // Catches arguments also, but may trash stack-address-like values
+ for(tmp_rbp = rsp; tmp_rbp < newBase; tmp_rbp += 4)
+ {
+ if(old_rsp < *(Uint*)tmp_rbp && *(Uint*)tmp_rbp < curBase)
+ *(Uint*)tmp_rbp += newBase - curBase;
+ }
+
+ Proc_GetCurThread()->KernelStack = newBase;
+
+ __asm__ __volatile__ ("mov %0, %%rsp"::"r"(rsp));
+ __asm__ __volatile__ ("mov %0, %%rbp"::"r"(rbp));
+}
+
+/**
+ * \fn int Proc_Clone(Uint *Err, Uint Flags)
+ * \brief Clone the current process
+ */
+int Proc_Clone(Uint *Err, Uint Flags)
+{
+ tThread *newThread;
+ tThread *cur = Proc_GetCurThread();
+ Uint rip, rsp, rbp;
+
+ __asm__ __volatile__ ("mov %%rsp, %0": "=r"(rsp));
+ __asm__ __volatile__ ("mov %%rbp, %0": "=r"(rbp));
+
+ newThread = Threads_CloneTCB(Err, Flags);
+ if(!newThread) return -1;
+
+ // Initialise Memory Space (New Addr space or kernel stack)
+ if(Flags & CLONE_VM) {
+ newThread->MemState.CR3 = MM_Clone();
+ newThread->KernelStack = cur->KernelStack;
+ } else {
+ Uint tmp_rbp, old_rsp = rsp;
+
+ // Set CR3
+ newThread->MemState.CR3 = cur->MemState.CR3;
+
+ // Create new KStack
+ newThread->KernelStack = MM_NewKStack();
+ // Check for errors
+ if(newThread->KernelStack == 0) {
+ free(newThread);
+ return -1;
+ }
+
+ // Get ESP as a used size
+ rsp = cur->KernelStack - rsp;
+ // Copy used stack
+ memcpy(
+ (void*)(newThread->KernelStack - rsp),
+ (void*)(cur->KernelStack - rsp),
+ rsp
+ );
+ // Get ESP as an offset in the new stack
+ rsp = newThread->KernelStack - rsp;
+ // Adjust EBP
+ rbp = newThread->KernelStack - (cur->KernelStack - rbp);
+
+ // Repair EBPs & Stack Addresses
+ // Catches arguments also, but may trash stack-address-like values
+ for(tmp_rbp = rsp; tmp_rbp < newThread->KernelStack; tmp_rbp += 4)
+ {
+ if(old_rsp < *(Uint*)tmp_rbp && *(Uint*)tmp_rbp < cur->KernelStack)
+ *(Uint*)tmp_rbp += newThread->KernelStack - cur->KernelStack;
+ }
+ }
+
+ // Save core machine state
+ newThread->SavedState.RSP = rsp;
+ newThread->SavedState.RBP = rbp;
+ rip = GetRIP();
+ if(rip == SWITCH_MAGIC) {
+ outb(0x20, 0x20); // ACK Timer and return as child
+ return 0;
+ }
+
+ // Set EIP as parent
+ newThread->SavedState.RIP = rip;
+
+ // Lock list and add to active
+ Threads_AddActive(newThread);
+
+ return newThread->TID;
+}
+
+/**
+ * \fn int Proc_SpawnWorker()
+ * \brief Spawns a new worker thread
+ */
+int Proc_SpawnWorker()
+{
+ tThread *new, *cur;
+ Uint rip, rsp, rbp;
+
+ cur = Proc_GetCurThread();
+
+ // Create new thread
+ new = malloc( sizeof(tThread) );
+ if(!new) {
+ Warning("Proc_SpawnWorker - Out of heap space!\n");
+ return -1;
+ }
+ memcpy(new, &gThreadZero, sizeof(tThread));
+ // Set Thread ID
+ new->TID = giNextTID++;
+ // Create a new worker stack (in PID0's address space)
+ // The stack is relocated by this code
+ new->KernelStack = MM_NewWorkerStack();
+
+ // Get ESP and EBP based in the new stack
+ __asm__ __volatile__ ("mov %%rsp, %0": "=r"(rsp));
+ __asm__ __volatile__ ("mov %%rbp, %0": "=r"(rbp));
+ rsp = new->KernelStack - (cur->KernelStack - rsp);
+ rbp = new->KernelStack - (cur->KernelStack - rbp);
+
+ // Save core machine state
+ new->SavedState.RSP = rsp;
+ new->SavedState.RBP = rbp;
+ rip = GetRIP();
+ if(rip == SWITCH_MAGIC) {
+ outb(0x20, 0x20); // ACK Timer and return as child
+ return 0;
+ }
+
+ // Set EIP as parent
+ new->SavedState.RIP = rip;
+ // Mark as active
+ new->Status = THREAD_STAT_ACTIVE;
+ Threads_AddActive( new );
+
+ return new->TID;
+}
+
+/**
+ * \fn Uint Proc_MakeUserStack()
+ * \brief Creates a new user stack
+ */
+Uint Proc_MakeUserStack()
+{
+ int i;
+ Uint base = USER_STACK_TOP - USER_STACK_SZ;
+
+ // Check Prospective Space
+ for( i = USER_STACK_SZ >> 12; i--; )
+ if( MM_GetPhysAddr( base + (i<<12) ) != 0 )
+ break;
+
+ if(i != -1) return 0;
+
+ // Allocate Stack - Allocate incrementally to clean up MM_Dump output
+ for( i = 0; i < USER_STACK_SZ/4069; i++ )
+ MM_Allocate( base + (i<<12) );
+
+ return base + USER_STACK_SZ;
+}
+
+
+/**
+ * \fn void Proc_StartUser(Uint Entrypoint, Uint *Bases, int ArgC, char **ArgV, char **EnvP, int DataSize)
+ * \brief Starts a user task
+ */
+void Proc_StartUser(Uint Entrypoint, Uint *Bases, int ArgC, char **ArgV, char **EnvP, int DataSize)
+{
+ Uint *stack = (void*)Proc_MakeUserStack();
+ int i;
+ Uint delta;
+ Uint16 ss, cs;
+
+ LOG("stack = 0x%x", stack);
+
+ // Copy Arguments
+ stack = (void*)( (Uint)stack - DataSize );
+ memcpy( stack, ArgV, DataSize );
+
+ // Adjust Arguments and environment
+ delta = (Uint)stack - (Uint)ArgV;
+ ArgV = (char**)stack;
+ for( i = 0; ArgV[i]; i++ ) ArgV[i] += delta;
+ i ++;
+ EnvP = &ArgV[i];
+ for( i = 0; EnvP[i]; i++ ) EnvP[i] += delta;
+
+ // User Mode Segments
+ ss = 0x23; cs = 0x1B;
+
+ // Arguments
+ *--stack = (Uint)EnvP;
+ *--stack = (Uint)ArgV;
+ *--stack = (Uint)ArgC;
+ while(*Bases)
+ *--stack = *Bases++;
+ *--stack = 0; // Return Address
+
+ Proc_StartProcess(ss, (Uint)stack, 0x202, cs, Entrypoint);
+}
+
+void Proc_StartProcess(Uint16 SS, Uint Stack, Uint Flags, Uint16 CS, Uint IP)
+{
+ Uint *stack = (void*)Stack;
+ *--stack = SS; //Stack Segment
+ *--stack = Stack; //Stack Pointer
+ *--stack = Flags; //EFLAGS (Resvd (0x2) and IF (0x20))
+ *--stack = CS; //Code Segment
+ *--stack = IP; //EIP
+ //PUSHAD
+ *--stack = 0xAAAAAAAA; // eax
+ *--stack = 0xCCCCCCCC; // ecx
+ *--stack = 0xDDDDDDDD; // edx
+ *--stack = 0xBBBBBBBB; // ebx
+ *--stack = 0xD1D1D1D1; // edi
+ *--stack = 0x54545454; // rsp - NOT POPED
+ *--stack = 0x51515151; // esi
+ *--stack = 0xB4B4B4B4; // rbp
+ //Individual PUSHs
+ *--stack = SS; // ds
+
+ __asm__ __volatile__ (
+ "mov %%rax,%%rsp;\n\t" // Set stack pointer
+ "iret;\n\t" : : "a" (stack));
+ for(;;);
+}
+
+/**
+ * \fn int Proc_Demote(Uint *Err, int Dest, tRegs *Regs)
+ * \brief Demotes a process to a lower permission level
+ * \param Err Pointer to user's errno
+ * \param Dest New Permission Level
+ * \param Regs Pointer to user's register structure
+ */
+int Proc_Demote(Uint *Err, int Dest, tRegs *Regs)
+{
+ int cpl = Regs->cs & 3;
+ // Sanity Check
+ if(Dest > 3 || Dest < 0) {
+ *Err = -EINVAL;
+ return -1;
+ }
+
+ // Permission Check
+ if(cpl > Dest) {
+ *Err = -EACCES;
+ return -1;
+ }
+
+ // Change the Segment Registers
+ Regs->cs = (((Dest+1)<<4) | Dest) - 8;
+ Regs->ss = ((Dest+1)<<4) | Dest;
+ // Check if the GP Segs are GDT, then change them
+ if(!(Regs->ds & 4)) Regs->ds = ((Dest+1)<<4) | Dest;
+ if(!(Regs->es & 4)) Regs->es = ((Dest+1)<<4) | Dest;
+ if(!(Regs->fs & 4)) Regs->fs = ((Dest+1)<<4) | Dest;
+ if(!(Regs->gs & 4)) Regs->gs = ((Dest+1)<<4) | Dest;
+
+ return 0;
+}
+
+/**
+ * \brief Calls a signal handler in user mode
+ * \note Used for signals
+ */
+void Proc_CallFaultHandler(tThread *Thread)
+{
+ // Rewinds the stack and calls the user function
+ // Never returns
+ __asm__ __volatile__ ("mov %0, %%rbp;\n\tcall Proc_AlterUserReturnAddr" :: "r"(Thread->FaultHandler));
+ for(;;);
+}
+
+/**
+ * \fn void Proc_Scheduler(int CPU)
+ * \brief Swap current thread and clears dead threads
+ */
+void Proc_Scheduler(int CPU)
+{
+ Uint rsp, rbp, rip;
+ tThread *thread;
+
+ // If the spinlock is set, let it complete
+ if(IS_LOCKED(&glThreadListLock)) return;
+
+ // Clear Delete Queue
+ while(gDeleteThreads)
+ {
+ thread = gDeleteThreads->Next;
+ if(gDeleteThreads->IsLocked) { // Only free if structure is unused
+ gDeleteThreads->Status = THREAD_STAT_NULL;
+ free( gDeleteThreads );
+ }
+ gDeleteThreads = thread;
+ }
+
+ // Check if there is any tasks running
+ if(giNumActiveThreads == 0) {
+ Log("No Active threads, sleeping");
+ __asm__ __volatile__ ("hlt");
+ return;
+ }
+
+ // Get current thread
+ #if USE_MP
+ thread = gaCPUs[CPU].Current;
+ #else
+ thread = gCurrentThread;
+ #endif
+
+ // Reduce remaining quantum and continue timeslice if non-zero
+ if(thread->Remaining--) return;
+ // Reset quantum for next call
+ thread->Remaining = thread->Quantum;
+
+ // Get machine state
+ __asm__ __volatile__ ("mov %%rsp, %0":"=r"(rsp));
+ __asm__ __volatile__ ("mov %%rbp, %0":"=r"(rbp));
+ rip = GetRIP();
+ if(rip == SWITCH_MAGIC) return; // Check if a switch happened
+
+ // Save machine state
+ thread->SavedState.RSP = rsp;
+ thread->SavedState.RBP = rbp;
+ thread->SavedState.RIP = rip;
+
+ // Get next thread
+ thread = Threads_GetNextToRun(CPU);
+
+ // Error Check
+ if(thread == NULL) {
+ Warning("Hmm... Threads_GetNextToRun returned NULL, I don't think this should happen.\n");
+ return;
+ }
+
+ #if DEBUG_TRACE_SWITCH
+ Log("Switching to task %i, CR3 = 0x%x, RIP = %p",
+ thread->TID,
+ thread->MemState.CR3,
+ thread->SavedState.RIP
+ );
+ #endif
+
+ // Set current thread
+ #if USE_MP
+ gaCPUs[CPU].Current = thread;
+ #else
+ gCurrentThread = thread;
+ #endif
+
+ // Update Kernel Stack pointer
+ gTSSs[CPU].RSP0 = thread->KernelStack-4;
+
+ // Set address space
+ #if USE_PAE
+ # error "Todo: Implement PAE Address space switching"
+ #else
+ __asm__ __volatile__ ("mov %0, %%cr3"::"a"(thread->MemState.CR3));
+ #endif
+
+ #if 0
+ if(thread->SavedState.RSP > 0xC0000000
+ && thread->SavedState.RSP < thread->KernelStack-0x2000) {
+ Log_Warning("Proc", "Possible bad ESP %p (PID %i)", thread->SavedState.ESP);
+ }
+ #endif
+
+ // Switch threads
+ __asm__ __volatile__ (
+ "mov %1, %%rsp\n\t" // Restore RSP
+ "mov %2, %%rbp\n\t" // and RBP
+ "jmp *%3" : : // And return to where we saved state (Proc_Clone or Proc_Scheduler)
+ "a"(SWITCH_MAGIC), "b"(thread->SavedState.RSP),
+ "d"(thread->SavedState.RBP), "c"(thread->SavedState.RIP)
+ );
+ for(;;); // Shouldn't reach here
+}
+
+// === EXPORTS ===
+EXPORT(Proc_SpawnWorker);
[section .data]
gGDT:
dd 0,0
- dd 0x00000000, 0x00209800 ; 64-bit Code
- dd 0x00000000, 0x00009000 ; 64-bit Data
+ dd 0x00000000, 0x00209800 ; 0x08: 64-bit Code
+ dd 0x00000000, 0x00009000 ; 0x10: 64-bit Data
+ dd 0x00000000, 0x00209800 ; 0x18: 64-bit User Code
+ dd 0x00000000, 0x00209000 ; 0x20: 64-bit User Data
+ dd 0x00000000, 0x00209800 ; 0x38: 32-bit User Code
+ dd 0x00000000, 0x00209000 ; 0x30: 32-bit User Data
+ times MAX_CPUS dd 0, 0, 0, 0 ; 0x38+16*n: TSS 0
gGDTPtr:
dw $-gGDT-1
dd gGDT
dd 0
[section .padata]
-gInitialPML4: ; 256 TiB
+gInitialPML4: ; Covers 256 TiB (Full 48-bit Virtual Address Space
dd gInitialPDP + 3, 0 ; Identity Map Low 4Mb
times 256-1 dq 0
- dd gInitialPDP + 3, 0 ; Identity Map Low 4Mb to kernel base
+ dd gInitialPDP + 3, 0 ; Map Low 4Mb to kernel base
times 256-1 dq 0
-gInitialPDP: ; 512 GiB
+gInitialPDP: ; Covers 512 GiB
dd gInitialPD + 3, 0
times 511 dq 0
-gInitialPD: ; 1 GiB
+gInitialPD: ; Covers 1 GiB
dd gInitialPT1 + 3, 0
dd gInitialPT2 + 3, 0
-gInitialPT1: ; 2 MiB
+gInitialPT1: ; Covers 2 MiB
%assign i 1
%rep 512
dq i*4096+3
+;
+; Acess2 x86_64 Port
+;
+[bits 64]
+
+start64:
+ jmp $
#define BIN_LOWEST MM_USER_MIN // 1MiB
#define BIN_GRANUALITY 0x10000 // 64KiB
//! \todo Move 0xBC000000 to mm_virt.h
-#define BIN_HIGHEST (0xBC000000-BIN_GRANUALITY) // Just below the kernel
+#define BIN_HIGHEST (USER_LIB_MAX-BIN_GRANUALITY) // Just below the kernel
#define KLIB_LOWEST MM_MODULE_MIN
#define KLIB_GRANUALITY 0x10000 // 32KiB
#define KLIB_HIGHEST (MM_MODULE_MAX-KLIB_GRANUALITY)
else {\r
// Normal copy is OK\r
while( H -- ) {\r
- memcpyd((Uint32*)gpVesa_Framebuffer + dst, (Uint32*)gpVesa_Framebuffer + src, W);\r
+ memcpy((Uint32*)gpVesa_Framebuffer + dst, (Uint32*)gpVesa_Framebuffer + src, W);\r
dst += scrnwidth;\r
src += scrnwidth;\r
}\r
$(BIN): %.kmd.$(ARCH): $(OBJ)
@echo --- $(LD) -o $@
# $(LD) -T $(ACESSDIR)/Modules/link.ld --allow-shlib-undefined -shared -nostdlib -o $@ $(OBJ)
- $(LD) --allow-shlib-undefined -shared -nostdlib -o $@ $(OBJ)
+ @$(LD) --allow-shlib-undefined -shared -nostdlib -o $@ $(OBJ)
@$(OBJDUMP) -d $(BIN) > $(BIN).dsm
else
$(BIN): %.xo.$(ARCH): $(OBJ)
all: $(BIN)
clean:
- @$(RM) $(OBJ) $(BIN) $(BIN).dsm Map.txt
+ @$(RM) $(OBJ) $(DEPFILES) $(BIN) $(BIN).dsm Map.txt
install: $(BIN)
$(xCP) $(BIN) $(DISTROOT)/$(DIR)/
// ---- Plain <hr/> style spacer ----
WM_CreateElement(area, ELETYPE_SPACER, 0);
- // Windows Go Here
+ // Open Windows Go Here
// --- Bottom Segment ---
area = WM_CreateElement(gpInterface_Sidebar, ELETYPE_BOX, ELEFLAG_VERTICAL|ELEFLAG_ALIGN_END);
-/*\r
- AcessOS 1 - Dynamic Loader\r
- By thePowersGang\r
-*/\r
-#include "common.h"\r
-\r
-#define DEBUG 0\r
-\r
-#if DEBUG\r
-# define DEBUGS(v...) SysDebug(v)\r
-#else\r
-# define DEBUGS(v...) \r
-#endif\r
-\r
-// === PROTOTYPES ===\r
+/*
+ AcessOS 1 - Dynamic Loader
+ By thePowersGang
+*/
+#include "common.h"
+
+#define DEBUG 0
+
+#if DEBUG
+# define DEBUGS(v...) SysDebug(v)
+#else
+# define DEBUGS(v...)
+#endif
+
+// === PROTOTYPES ===
Uint IsFileLoaded(char *file);
- int GetSymbolFromBase(Uint base, char *name, Uint *ret);\r
-\r
-// === CONSTANTS ===\r
-const struct {\r
- Uint Value;\r
- char *Name;\r
-} caLocalExports[] = {\r
- {gLoadedLibraries, "gLoadedLibraries"}\r
-};\r
-\r
-// === GLOABLS ===\r
-tLoadedLib gLoadedLibraries[MAX_LOADED_LIBRARIES];\r
-char gsLoadedStrings[MAX_STRINGS_BYTES];\r
-char *gsNextAvailString = gsLoadedStrings;\r
-//tLoadLib *gpLoadedLibraries = NULL;\r
-\r
-// === CODE ===\r
-char *FindLibrary(char *DestBuf, char *SoName, char *ExtraSearchDir)\r
-{ \r
- // -- #1: Executable Specified\r
- if(ExtraSearchDir)\r
- {\r
- strcpy(DestBuf, ExtraSearchDir);\r
- strcat(DestBuf, "/");\r
- strcat(DestBuf, SoName);\r
- if(file_exists(DestBuf)) return DestBuf;\r
- }\r
- \r
- // -- #2: System\r
- strcpy(DestBuf, SYSTEM_LIB_DIR);\r
- strcat(DestBuf, SoName);\r
- if(file_exists(DestBuf)) return DestBuf;\r
- \r
- // -- #3: Current Directory\r
- if(file_exists(SoName)) return SoName;\r
- \r
- return NULL;\r
-}\r
-\r
-/**\r
- */\r
-Uint LoadLibrary(char *SoName, char *SearchDir, char **envp)\r
-{\r
- char sTmpName[1024];\r
- char *filename;\r
- Uint iArg;\r
- void (*fEntry)(int, int, char *[], char**);\r
- \r
- DEBUGS("LoadLibrary: (filename='%s', envp=0x%x)\n", filename, envp);\r
- \r
- // Create Temp Name\r
- filename = FindLibrary(sTmpName, SoName, SearchDir);\r
- if(filename == NULL) {\r
- DEBUGS("LoadLibrary: RETURN 0\n");\r
- return 0;\r
- }\r
- DEBUGS(" LoadLibrary: filename='%s'\n", filename);\r
- \r
- if( (iArg = IsFileLoaded(filename)) )\r
- return iArg;\r
- \r
- // Load Library\r
- iArg = SysLoadBin(filename, (Uint*)&fEntry);\r
- if(iArg == 0) {\r
- DEBUGS("LoadLibrary: RETURN 0\n");\r
- return 0;\r
- }\r
- \r
- DEBUGS(" LoadLibrary: iArg=0x%x, iEntry=0x%x\n", iArg, fEntry);\r
- \r
- // Load Symbols\r
- fEntry = (void*)DoRelocate( iArg, envp, filename );\r
- \r
- // Call Entrypoint\r
- DEBUGS(" LoadLibrary: '%s' Entry 0x%x\n", SoName, fEntry);\r
- fEntry(iArg, 0, NULL, envp);\r
- \r
- DEBUGS("LoadLibrary: RETURN 1\n");\r
- return iArg;\r
+ int GetSymbolFromBase(Uint base, char *name, Uint *ret);
+
+// === CONSTANTS ===
+const struct {
+ Uint Value;
+ char *Name;
+} caLocalExports[] = {
+ {(Uint)gLoadedLibraries, "gLoadedLibraries"}
+};
+
+// === GLOABLS ===
+tLoadedLib gLoadedLibraries[MAX_LOADED_LIBRARIES];
+char gsLoadedStrings[MAX_STRINGS_BYTES];
+char *gsNextAvailString = gsLoadedStrings;
+//tLoadLib *gpLoadedLibraries = NULL;
+
+// === CODE ===
+char *FindLibrary(char *DestBuf, char *SoName, char *ExtraSearchDir)
+{
+ // -- #1: Executable Specified
+ if(ExtraSearchDir)
+ {
+ strcpy(DestBuf, ExtraSearchDir);
+ strcat(DestBuf, "/");
+ strcat(DestBuf, SoName);
+ if(file_exists(DestBuf)) return DestBuf;
+ }
+
+ // -- #2: System
+ strcpy(DestBuf, SYSTEM_LIB_DIR);
+ strcat(DestBuf, SoName);
+ if(file_exists(DestBuf)) return DestBuf;
+
+ // -- #3: Current Directory
+ if(file_exists(SoName)) return SoName;
+
+ return NULL;
}
-\r
-/**\r
- * \fn Uint IsFileLoaded(char *file)\r
- * \brief Determine if a file is already loaded\r
- */\r
-Uint IsFileLoaded(char *file)\r
-{\r
- int i;\r
- DEBUGS("IsFileLoaded: (file='%s')", file);\r
- for( i = 0; i < MAX_LOADED_LIBRARIES; i++ )\r
- {\r
- if(gLoadedLibraries[i].Base == 0) break; // Last entry has Base set to NULL\r
- DEBUGS(" strcmp('%s', '%s')", gLoadedLibraries[i].Name, file);\r
- if(strcmp(gLoadedLibraries[i].Name, file) == 0) {\r
- DEBUGS("IsFileLoaded: Found %i (0x%x)", i, gLoadedLibraries[i].Base);\r
- return gLoadedLibraries[i].Base;\r
- }\r
- }\r
- DEBUGS("IsFileLoaded: Not Found");\r
- return 0;\r
-}\r
-\r
-/**\r
- * \fn void AddLoaded(char *File, Uint base)\r
- * \brief Add a file to the loaded list\r
+
+/**
+ */
+Uint LoadLibrary(char *SoName, char *SearchDir, char **envp)
+{
+ char sTmpName[1024];
+ char *filename;
+ Uint iArg;
+ void (*fEntry)(int, int, char *[], char**);
+
+ DEBUGS("LoadLibrary: (filename='%s', envp=0x%x)\n", filename, envp);
+
+ // Create Temp Name
+ filename = FindLibrary(sTmpName, SoName, SearchDir);
+ if(filename == NULL) {
+ DEBUGS("LoadLibrary: RETURN 0\n");
+ return 0;
+ }
+ DEBUGS(" LoadLibrary: filename='%s'\n", filename);
+
+ if( (iArg = IsFileLoaded(filename)) )
+ return iArg;
+
+ // Load Library
+ iArg = SysLoadBin(filename, (Uint*)&fEntry);
+ if(iArg == 0) {
+ DEBUGS("LoadLibrary: RETURN 0\n");
+ return 0;
+ }
+
+ DEBUGS(" LoadLibrary: iArg=0x%x, iEntry=0x%x\n", iArg, fEntry);
+
+ // Load Symbols
+ fEntry = (void*)DoRelocate( iArg, envp, filename );
+
+ // Call Entrypoint
+ DEBUGS(" LoadLibrary: '%s' Entry 0x%x\n", SoName, fEntry);
+ fEntry(iArg, 0, NULL, envp);
+
+ DEBUGS("LoadLibrary: RETURN 1\n");
+ return iArg;
+}
+
+/**
+ * \fn Uint IsFileLoaded(char *file)
+ * \brief Determine if a file is already loaded
+ */
+Uint IsFileLoaded(char *file)
+{
+ int i;
+ DEBUGS("IsFileLoaded: (file='%s')", file);
+ for( i = 0; i < MAX_LOADED_LIBRARIES; i++ )
+ {
+ if(gLoadedLibraries[i].Base == 0) break; // Last entry has Base set to NULL
+ DEBUGS(" strcmp('%s', '%s')", gLoadedLibraries[i].Name, file);
+ if(strcmp(gLoadedLibraries[i].Name, file) == 0) {
+ DEBUGS("IsFileLoaded: Found %i (0x%x)", i, gLoadedLibraries[i].Base);
+ return gLoadedLibraries[i].Base;
+ }
+ }
+ DEBUGS("IsFileLoaded: Not Found");
+ return 0;
+}
+
+/**
+ * \fn void AddLoaded(char *File, Uint base)
+ * \brief Add a file to the loaded list
*/
void AddLoaded(char *File, Uint base)
-{\r
- int i, length;\r
- char *name = gsNextAvailString;\r
- \r
- DEBUGS("AddLoaded: (File='%s', base=0x%x)", File, base);\r
- \r
- // Find a free slot\r
- for( i = 0; i < MAX_LOADED_LIBRARIES; i ++ )\r
- {\r
- if(gLoadedLibraries[i].Base == 0) break;\r
- }\r
- if(i == MAX_LOADED_LIBRARIES) {\r
- SysDebug("ERROR - ld-acess.so has run out of load slots!");\r
- return;\r
- }\r
- \r
- // Check space in string buffer\r
- length = strlen(File);\r
- if(&name[length+1] >= &gsLoadedStrings[MAX_STRINGS_BYTES]) {\r
- SysDebug("ERROR - ld-acess.so has run out of string buffer memory!");\r
- return;\r
- }\r
- \r
- // Set information\r
- gLoadedLibraries[i].Base = base;\r
- strcpy(name, File);\r
- gLoadedLibraries[i].Name = name;\r
- gsNextAvailString = &name[length+1];\r
- DEBUGS("'%s' (0x%x) loaded as %i\n", name, base, i);\r
+{
+ int i, length;
+ char *name = gsNextAvailString;
+
+ DEBUGS("AddLoaded: (File='%s', base=0x%x)", File, base);
+
+ // Find a free slot
+ for( i = 0; i < MAX_LOADED_LIBRARIES; i ++ )
+ {
+ if(gLoadedLibraries[i].Base == 0) break;
+ }
+ if(i == MAX_LOADED_LIBRARIES) {
+ SysDebug("ERROR - ld-acess.so has run out of load slots!");
+ return;
+ }
+
+ // Check space in string buffer
+ length = strlen(File);
+ if(&name[length+1] >= &gsLoadedStrings[MAX_STRINGS_BYTES]) {
+ SysDebug("ERROR - ld-acess.so has run out of string buffer memory!");
+ return;
+ }
+
+ // Set information
+ gLoadedLibraries[i].Base = base;
+ strcpy(name, File);
+ gLoadedLibraries[i].Name = name;
+ gsNextAvailString = &name[length+1];
+ DEBUGS("'%s' (0x%x) loaded as %i\n", name, base, i);
return;
-}\r
-\r
-/**\r
- * \fn void Unload(Uint Base)\r
- */\r
-void Unload(Uint Base)\r
-{ \r
- int i, j;\r
- int id;\r
- char *str;\r
- for( id = 0; id < MAX_LOADED_LIBRARIES; id++ )\r
- {\r
- if(gLoadedLibraries[id].Base == Base) break;\r
- }\r
- if(id == MAX_LOADED_LIBRARIES) return;\r
- \r
- // Unload Binary\r
- SysUnloadBin( Base );\r
- // Save String Pointer\r
- str = gLoadedLibraries[id].Name;\r
- \r
- // Compact Loaded List\r
- j = id;\r
- for( i = j + 1; i < MAX_LOADED_LIBRARIES; i++, j++ )\r
- {\r
- if(gLoadedLibraries[i].Base == 0) break;\r
- // Compact String\r
- strcpy(str, gLoadedLibraries[i].Name);\r
- str += strlen(str)+1;\r
- // Compact Entry\r
- gLoadedLibraries[j].Base = gLoadedLibraries[i].Base;\r
- gLoadedLibraries[j].Name = str;\r
- }\r
- \r
- // NULL Last Entry\r
- gLoadedLibraries[j].Base = 0;\r
- gLoadedLibraries[j].Name = NULL;\r
- // Save next string\r
- gsNextAvailString = str;\r
-}\r
-\r
+}
+
+/**
+ * \fn void Unload(Uint Base)
+ */
+void Unload(Uint Base)
+{
+ int i, j;
+ int id;
+ char *str;
+ for( id = 0; id < MAX_LOADED_LIBRARIES; id++ )
+ {
+ if(gLoadedLibraries[id].Base == Base) break;
+ }
+ if(id == MAX_LOADED_LIBRARIES) return;
+
+ // Unload Binary
+ SysUnloadBin( Base );
+ // Save String Pointer
+ str = gLoadedLibraries[id].Name;
+
+ // Compact Loaded List
+ j = id;
+ for( i = j + 1; i < MAX_LOADED_LIBRARIES; i++, j++ )
+ {
+ if(gLoadedLibraries[i].Base == 0) break;
+ // Compact String
+ strcpy(str, gLoadedLibraries[i].Name);
+ str += strlen(str)+1;
+ // Compact Entry
+ gLoadedLibraries[j].Base = gLoadedLibraries[i].Base;
+ gLoadedLibraries[j].Name = str;
+ }
+
+ // NULL Last Entry
+ gLoadedLibraries[j].Base = 0;
+ gLoadedLibraries[j].Name = NULL;
+ // Save next string
+ gsNextAvailString = str;
+}
+
/**
\fn Uint GetSymbol(char *name)
\brief Gets a symbol value from a loaded library
*/
Uint GetSymbol(char *name)
-{\r
+{
int i;
- Uint ret;\r
- for(i=0;i<sizeof(caLocalExports)/sizeof(caLocalExports[0]);i++)\r
- {\r
- if( strcmp(caLocalExports[i].Name, name) == 0 )\r
- return caLocalExports[i].Value;\r
- }\r
- \r
- for(i=0;i<sizeof(gLoadedLibraries)/sizeof(gLoadedLibraries[0]);i++)\r
- {\r
- if(gLoadedLibraries[i].Base == 0) break;\r
+ Uint ret;
+ for(i=0;i<sizeof(caLocalExports)/sizeof(caLocalExports[0]);i++)
+ {
+ if( strcmp(caLocalExports[i].Name, name) == 0 )
+ return caLocalExports[i].Value;
+ }
+
+ for(i=0;i<sizeof(gLoadedLibraries)/sizeof(gLoadedLibraries[0]);i++)
+ {
+ if(gLoadedLibraries[i].Base == 0) break;
- //SysDebug(" GetSymbol: Trying 0x%x, '%s'\n",\r
+ //SysDebug(" GetSymbol: Trying 0x%x, '%s'\n",
// gLoadedLibraries[i].Base, gLoadedLibraries[i].Name);
- if(GetSymbolFromBase(gLoadedLibraries[i].Base, name, &ret)) return ret;\r
- }\r
- SysDebug("GetSymbol: === Symbol '%s' not found ===\n", name);\r
+ if(GetSymbolFromBase(gLoadedLibraries[i].Base, name, &ret)) return ret;
+ }
+ SysDebug("GetSymbol: === Symbol '%s' not found ===\n", name);
return 0;
}
SYSCALL2 kill, SYS_KILL
SYSCALL0 yield, SYS_YIELD
SYSCALL0 sleep, SYS_SLEEP
-SYSCALL1 wait, SYS_WAIT
SYSCALL2 waittid, SYS_WAITTID
SYSCALL0 gettid, SYS_GETTID
+++ /dev/null
-/*
- * AcessOS LibC
- * string.h
- */
-#ifndef __STRING_H
-#define __STRING_H
-
-#include <stddef.h>
-
-// Strings
-extern int strlen(const char *string);
-extern int strcmp(const char *str1, const char *str2);
-extern int strncmp(const char *str1, const char *str2, size_t len);
-extern char *strcpy(char *dst, const char *src);
-extern char *strncpy(char *dst, const char *src, size_t num);
-extern char *strcat(char *dst, const char *src);
-extern char *strdup(const char *src);
-extern char *strchr(char *str, int character);
-extern char *strrchr(char *str, int character);
-extern char *strstr(char *str1, const char *str2);
-
-// Memory
-extern void *memset(void *dest, int val, size_t count);
-extern void *memcpy(void *dest, const void *src, size_t count);
-extern void *memmove(void *dest, const void *src, size_t count);
-extern int memcmp(const void *mem1, const void *mem2, size_t count);
-extern void *memchr(void *ptr, int value, size_t num);
-
-#endif
git.ucc.asn.au / tpg / acess2.git / commitdiff
UCC git Repository :: git.ucc.asn.au