q3k
/
Cucumber
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

C++!

alentours-dev
q3k 2012-10-01 15:03:10 +02:00
parent cd811bda04
commit 99912f2083
17 changed files with 879 additions and 389 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
Kernel/Makefile
View File

@ -24,9 +24,15 @@ CFLAGS:=-m64 -mcmodel=large -Wall -Werror -nostdlib -nostartfiles -nodefaultlibs
CFLAGS+=-I ./include -Wno-packed-bitfield-compat -O2 -fno-optimize-sibling-calls -mcmodel=kernel
CFLAGS+= -mno-red-zone -ffreestanding -I ./include/Lua -I ./src/Lua
CXFLAGS:= -Wall -Werror -nostdlib -fno-builtin -nostartfiles -I ./include
CXFLAGS+= -nodefaultlibs -fno-exceptions -fno-rtti -fno-stack-protector
CXFLAGS+= -Wno-packed-bitfield-compat -O3 -mcmodel=kernel
#CXFLAGS:= -Wall -Werror -nostdlib -fno-builtin -nostartfiles -I ./include
#CXFLAGS+= -nodefaultlibs -fno-exceptions -fno-rtti -fno-stack-protector
#CXFLAGS+= -Wno-packed-bitfield-compat -O3 -mcmodel=kernel
CXFLAGS:=-m64 -mcmodel=large -Wall -Werror -nostdlib -nostartfiles -nodefaultlibs -g
CXFLAGS+=-I ./include -Wno-packed-bitfield-compat -O2 -fno-optimize-sibling-calls -mcmodel=kernel
CXFLAGS+= -mno-red-zone -ffreestanding -I ./include/Lua -I ./src/Lua -fno-exceptions -fno-rtti
CXFLAGS+= -fno-stack-protector
LFLAGS:=-nostdlib -nostartfiles -nodefaultlibs
.PHONY: all clean kernel.bin emulate hdd.img
@ -60,12 +66,12 @@ TIER0OBJ := $(patsubst %.asm,%.nao,$(TIER0OBJ))
TIER0 := $(foreach i, $(TIER0OBJ), obj/$(i))
Tier0: $(TIER0)
#TIER1SRC := $(shell find src/Tier1 -mindepth 1 -maxdepth 3 -name "*.cpp")
#TIER1SRC += $(shell find src/Tier1 -mindepth 1 -maxdepth 3 -name "*.asm")
#TIER1OBJ := $(patsubst %.cpp,%.xo,$(TIER1SRC))
#TIER1OBJ := $(patsubst %.asm,%.nao,$(TIER1OBJ))
#TIER1 := $(foreach i, $(TIER1OBJ), obj/$(i))
#Tier1: $(TIER1)
TIER1SRC := $(shell find src/Tier1 -mindepth 1 -maxdepth 3 -name "*.cpp")
TIER1SRC += $(shell find src/Tier1 -mindepth 1 -maxdepth 3 -name "*.asm")
TIER1OBJ := $(patsubst %.cpp,%.xo,$(TIER1SRC))
TIER1OBJ := $(patsubst %.asm,%.nao,$(TIER1OBJ))
TIER1 := $(foreach i, $(TIER1OBJ), obj/$(i))
Tier1: $(TIER1)
src/Lua/liblua.a:
@echo "[i] Building Lua..."
@ -74,7 +80,7 @@ src/Lua/liblua.a:
LUA := src/Lua/liblua.a
Lua: $(LUA)
kernel.bin: version-gen Tier0 Lua
kernel.bin: version-gen Tier0 Tier1 Lua
@echo "[i] Linking kernel.bin..."
@$(LD) -T src/kernel.ld -o kernel.bin $(TIER0) $(TIER1) -Lsrc/Lua -llua

22
Kernel/include/Tier0/atomic_operations.h
View File

@ -4,27 +4,27 @@
#include "types.h"
typedef struct {
u32 Value;
u64 Value;
} T_ATOMIC;
#define atomic_init(n) { (n) }
#define atomic_read(v) ((v)->Value)
#define atomic_set(v, n) (((v)->Value) = n)
static inline void atomic_add(T_ATOMIC *Atom, u32 Value)
static inline void atomic_add(T_ATOMIC *Atom, u64 Value)
{
__asm__ volatile("lock addl %1, %0" : "+m"(Atom->Value) : "ir"(Value));
__asm__ volatile("lock addq %1, %0" : "+m"(Atom->Value) : "ir"(Value));
}
static inline void atomic_sub(T_ATOMIC *Atom, u32 Value)
static inline void atomic_sub(T_ATOMIC *Atom, u64 Value)
{
__asm__ volatile("lock subl %1, %0" : "+m"(Atom->Value) : "ir"(Value));
__asm__ volatile("lock subq %1, %0" : "+m"(Atom->Value) : "ir"(Value));
}
static inline u8 atomic_sub_and_test(T_ATOMIC *Atom, u32 Value)
static inline u8 atomic_sub_and_test(T_ATOMIC *Atom, u64 Value)
{
u8 C;
__asm__ volatile("lock subl %2, %0\n"
__asm__ volatile("lock subq %2, %0\n"
"sete %1\n"
: "+m"(Atom->Value), "=qm"(C)
: "ir" (Value) : "memory");
@ -33,18 +33,18 @@ static inline u8 atomic_sub_and_test(T_ATOMIC *Atom, u32 Value)
static inline void atomic_inc(T_ATOMIC *Atom)
{
__asm__ volatile("lock incl %0" : "+m"(Atom->Value));
__asm__ volatile("lock incq %0" : "+m"(Atom->Value));
}
static inline void atomic_dec(T_ATOMIC *Atom)
{
__asm__ volatile("lock decl %0" : "+m"(Atom->Value));
__asm__ volatile("lock decq %0" : "+m"(Atom->Value));
}
static inline u8 atomic_dec_and_test(T_ATOMIC *Atom)
{
u8 C;
__asm__ volatile("lock decl %0\n"
__asm__ volatile("lock decq %0\n"
"sete %1" : "+m"(Atom->Value), "=qm"(C) :: "memory");
return C;
}
@ -52,7 +52,7 @@ static inline u8 atomic_dec_and_test(T_ATOMIC *Atom)
static inline u8 atomic_inc_and_test(T_ATOMIC *Atom)
{
u8 C;
__asm__ volatile("lock incl %0\n"
__asm__ volatile("lock incq %0\n"
"sete %1" : "+m"(Atom->Value), "=qm"(C) :: "memory");
return C;
}

4
Kernel/include/Tier1/CKernel.h
View File

@ -3,7 +3,7 @@
#include "types.h"
#include "Tier1/CLogger.h"
#include "Tier1/CTask.h"
//#include "Tier1/CTask.h"
#define CKERNEL_MAGIC 0x8BA67FE9
@ -19,7 +19,7 @@ namespace cb {
u32 m_dwMagic;
CLogger *m_Logger;
CTask *CreateKernelTask(void);
// CTask *CreateKernelTask(void);
};
};

114
Kernel/include/Tier1/CTask.h
View File

@ -3,63 +3,11 @@
#include "types.h"
#include "Tier1/CKernel.h"
#include "Tier1/CPageDirectory.h"
//#include "Tier1/CPageDirectory.h"
#include "Tier1/CSemaphore.h"
#include "Tier0/semaphore.h"
// Task memory map...
// _______________________
// 0x00000000 | | This is left unused because of possible
// | thar be dragons | segfaults due to dereferencing of null
// |_______________________| pointers and other crap like that
// 0x10000000 | |
// | process code | The process image lies here, unless
// |_______________________| we're in the kernel, then it's unused
// 0x20000000 | |
// | process heap |
// |_______________________|
// 0x30000000 | |
// | process heap | The process heap is here. Managed via
// |_______________________| the tier0 heap mechanism
// 0x40000000 | |
// | process heap |
// |_______________________|
// 0x50000000 | |
// | process heap |
// |_______________________|
// 0x60000000 | |
// | process data |
// |_______________________| .data, .rodata and the like
// 0x70000000 | |
// | process data |
// |_______________________|
// 0x80000000 | |
// | |
// |_______________________|
// 0x90000000 | |
// | |
// |_______________________|
// 0xA0000000 | | Process stack. Starts at 4kb, then
// | process stack | grows if needed
// |_______________________|
// 0xB0000000 | |
// | |
// |_______________________|
// 0xC0000000 | |
// | kernel code |
// |_______________________| We need this in every process.
// 0xD0000000 | |
// | kernel heap |
// |_______________________|
// 0xE0000000 | |
// | IPC |
// |_______________________| For IPC (message passing)
// 0xF0000000 | |
// | IPC |
// |_______________________|
// 0xFFFFFFFF
#define TASK_MAP_CODE_START 0x10000000
/*#define TASK_MAP_CODE_START 0x10000000
#define TASK_MAP_CODE_SIZE 0x10000000
#define TASK_MAP_HEAP_START 0x20000000
@ -69,10 +17,10 @@
#define TASK_MAP_STACK_SIZE 0x10000000
#define TASK_MAP_KERNEL_START 0xC0000000
#define TASK_MAP_KERNEL_SIZE 0x20000000
#define TASK_MAP_KERNEL_SIZE 0x20000000*/
extern "C" {
u32 ctask_geteip(void);
u64 ctask_getrip(void);
}
namespace cb {
@ -102,27 +50,27 @@ namespace cb {
friend class CScheduler;
protected:
void *m_Owner; //TODO: Replace me with a real type
CPageDirectory *m_Directory;
//CPageDirectory *m_Directory;
ETaskPriority m_Priority;
ETaskRing m_Ring;
bool m_User;
volatile u32 m_PID;
volatile u64 m_PID;
volatile u32 m_ESP, m_EIP, m_EBP;
volatile u64 m_ESP, m_EIP, m_EBP;
volatile ETaskStatus m_Status;
volatile u32 m_StatusData;
volatile u64 m_StatusData;
u32 m_HeapStart;
u32 m_HeapSize;
u64 m_HeapStart;
u64 m_HeapSize;
u32 m_StackStart;
u32 m_StackSize;
u64 m_StackStart;
u64 m_StackSize;
u32 m_ImageStart;
u32 m_ImageSize;
u64 m_ImageStart;
u64 m_ImageSize;
u32 m_KernelStart;
u32 m_KernelSize;
u64 m_KernelStart;
u64 m_KernelSize;
bool m_CreatedStack;
@ -135,29 +83,29 @@ namespace cb {
CTask(bool User = 0, bool Empty = false);
~CTask(void);
CPageDirectory *GetPageDirectory(void);
//CPageDirectory *GetPageDirectory(void);
// Equivalent of the POSIX fork() call.
CTask *Fork(void);
inline u32 GetPID(void) { return m_PID; }
inline u32 GetESP(void) { return m_ESP; }
inline u32 GetEIP(void) { return m_EIP; }
inline u32 GetEBP(void) { return m_EBP; }
inline u64 GetPID(void) { return m_PID; }
inline u64 GetESP(void) { return m_ESP; }
inline u64 GetEIP(void) { return m_EIP; }
inline u64 GetEBP(void) { return m_EBP; }
inline u32 GetPageDirectoryPhysicalAddress(void)
/*inline u64 GetPageDirectoryPhysicalAddress(void)
{
return m_Directory->m_Directory->PhysicalAddress;
}
}*/
inline void SetESP(u32 ESP) { m_ESP = ESP; }
inline void SetEIP(u32 EIP) { m_EIP = EIP; }
inline void SetEBP(u32 EBP) { m_EBP = EBP; }
inline void SetESP(u64 ESP) { m_ESP = ESP; }
inline void SetEIP(u64 EIP) { m_EIP = EIP; }
inline void SetEBP(u64 EBP) { m_EBP = EBP; }
inline void SetPageDirectory(CPageDirectory *Directory)
/*inline void SetPageDirectory(CPageDirectory *Directory)
{
m_Directory = Directory;
}
}*/
void Dump(void);
@ -170,17 +118,17 @@ namespace cb {
void Enable(void);
// Like sleep(). Usually microseconds.
void Sleep(u32 Ticks);
void Sleep(u64 Ticks);
// Used for waking up via a CTimer
static bool WakeUp(u32 Extra);
static bool WakeUp(u64 Extra);
inline ETaskStatus GetStatus(void)
{
return m_Status;
}
inline u32 GetStatusData(void)
inline u64 GetStatusData(void)
{
return m_StatusData;
}

8
Kernel/kernel.sublime-project Normal file
View File

@ -0,0 +1,8 @@
{
"folders":
[
{
"path": "/home/q3k/Cucumber/Kernel"
}
]
}

565
Kernel/kernel.sublime-workspace Normal file
View File

@ -0,0 +1,565 @@
{
"auto_complete":
{
"selected_items":
[
[
"fno",
"fno-stack-protector"
]
]
},
"buffers":
[
{
"file": "src/Tier1/CLogger.cpp",
"settings":
{
"buffer_size": 927,
"line_ending": "Unix"
}
},
{
"file": "src/Tier1/CKernel.cpp",
"settings":
{
"buffer_size": 2679,
"line_ending": "Unix"
}
},
{
"file": "include/Tier1/CKernel.h",
"settings":
{
"buffer_size": 477,
"line_ending": "Unix"
}
},
{
"file": "src/Tier0/cpp.c",
"settings":
{
"buffer_size": 776,
"line_ending": "Unix"
}
},
{
"file": "include/Tier0/cpp.h",
"settings":
{
"buffer_size": 242,
"line_ending": "Unix"
}
},
{
"file": "src/Tier1/new.cpp",
"settings":
{
"buffer_size": 329,
"line_ending": "Unix"
}
},
{
"file": "Makefile",
"settings":
{
"buffer_size": 4219,
"line_ending": "Unix"
}
},
{
"file": "src/Tier1/CTask.asm",
"settings":
{
"buffer_size": 82,
"line_ending": "Unix"
}
},
{
"file": "src/Tier1/CTask.cpp",
"settings":
{
"buffer_size": 4774,
"line_ending": "Unix"
}
},
{
"file": "include/Tier1/CTask.h",
"settings":
{
"buffer_size": 3787,
"line_ending": "Unix"
}
},
{
"file": "include/Tier0/atomic_operations.h",
"settings":
{
"buffer_size": 1400,
"line_ending": "Unix"
}
}
],
"build_system": "",
"command_palette":
{
"height": 0.0,
"selected_items":
[
],
"width": 0.0
},
"console":
{
"height": 0.0
},
"distraction_free":
{
"menu_visible": true,
"show_minimap": false,
"show_open_files": false,
"show_tabs": false,
"side_bar_visible": false,
"status_bar_visible": false
},
"file_history":
[
"/home/q3k/Cucumber/Kernel/include/Tier0/semaphore.h"
],
"find":
{
"height": 0.0
},
"find_in_files":
{
"height": 0.0,
"where_history":
[
]
},
"find_state":
{
"case_sensitive": false,
"find_history":
[
"u32",
"Semaphore",
"SEMAPHORE",
"semaphore",
"Semaphore",
"SEMAPHORE",
"semaphore",
"Semaphore",
"SEMAPHORE",
"semaphore",
"Semaphore",
"SEMAPHORE",
"semaphore",
"SEMAPHORE",
"include",
"Semaphore",
"SEMAPHORE",
"semaphore",
"Semaphore",
"SEMAPHORE",
"semaphore",
"Semaphore",
"SEMAPHORE",
"semaphore",
"Semaphore",
"SEMAPHORE",
"semaphore",
"PHO",
"pho",
"PHO",
"pho",
"PHO",
"pho",
"#",
"nic.h\"\n #include \"Tier0/he"
],
"highlight": true,
"in_selection": false,
"preserve_case": false,
"regex": false,
"replace_history":
[
],
"reverse": false,
"show_context": true,
"use_buffer2": true,
"whole_word": false,
"wrap": true
},
"groups":
[
{
"selected": 6,
"sheets":
[
{
"buffer": 0,
"file": "src/Tier1/CLogger.cpp",
"settings":
{
"buffer_size": 927,
"regions":
{
},
"selection":
[
[
298,
298
]
],
"settings":
{
"syntax": "Packages/C++/C++.tmLanguage",
"tab_size": 4,
"translate_tabs_to_spaces": true
},
"translation.x": 0.0,
"translation.y": 0.0,
"zoom_level": 1.0
},
"type": "text"
},
{
"buffer": 1,
"file": "src/Tier1/CKernel.cpp",
"settings":
{
"buffer_size": 2679,
"regions":
{
},
"selection":
[
[
196,
196
]
],
"settings":
{
"syntax": "Packages/C++/C++.tmLanguage",
"tab_size": 4,
"translate_tabs_to_spaces": true
},
"translation.x": 0.0,
"translation.y": 0.0,
"zoom_level": 1.0
},
"type": "text"
},
{
"buffer": 2,
"file": "include/Tier1/CKernel.h",
"settings":
{
"buffer_size": 477,
"regions":
{
},
"selection":
[
[
0,
0
]
],
"settings":
{
"syntax": "Packages/C++/C++.tmLanguage",
"tab_size": 4,
"translate_tabs_to_spaces": true
},
"translation.x": 0.0,
"translation.y": 0.0,
"zoom_level": 1.0
},
"type": "text"
},
{
"buffer": 3,
"file": "src/Tier0/cpp.c",
"settings":
{
"buffer_size": 776,
"regions":
{
},
"selection":
[
[
0,
0
]
],
"settings":
{
"syntax": "Packages/C++/C.tmLanguage",
"tab_size": 4,
"translate_tabs_to_spaces": true
},
"translation.x": 0.0,
"translation.y": 0.0,
"zoom_level": 1.0
},
"type": "text"
},
{
"buffer": 4,
"file": "include/Tier0/cpp.h",
"settings":
{
"buffer_size": 242,
"regions":
{
},
"selection":
[
[
36,
36
]
],
"settings":
{
"syntax": "Packages/C++/C++.tmLanguage"
},
"translation.x": 0.0,
"translation.y": 0.0,
"zoom_level": 1.0
},
"type": "text"
},
{
"buffer": 5,
"file": "src/Tier1/new.cpp",
"settings":
{
"buffer_size": 329,
"regions":
{
},
"selection":
[
[
0,
0
]
],
"settings":
{
"syntax": "Packages/C++/C++.tmLanguage"
},
"translation.x": 0.0,
"translation.y": 0.0,
"zoom_level": 1.0
},
"type": "text"
},
{
"buffer": 6,
"file": "Makefile",
"settings":
{
"buffer_size": 4219,
"regions":
{
},
"selection":
[
[
1308,
1308
]
],
"settings":
{
"syntax": "Packages/Makefile/Makefile.tmLanguage"
},
"translation.x": 0.0,
"translation.y": 90.0,
"zoom_level": 1.0
},
"type": "text"
},
{
"buffer": 7,
"file": "src/Tier1/CTask.asm",
"settings":
{
"buffer_size": 82,
"regions":
{
},
"selection":
[
[
79,
79
]
],
"settings":
{
"syntax": "Packages/Text/Plain text.tmLanguage"
},
"translation.x": 0.0,
"translation.y": 0.0,
"zoom_level": 1.0
},
"type": "text"
},
{
"buffer": 8,
"file": "src/Tier1/CTask.cpp",
"settings":
{
"buffer_size": 4774,
"regions":
{
},
"selection":
[
[
404,
404
]
],
"settings":
{
"syntax": "Packages/C++/C++.tmLanguage",
"tab_size": 4,
"translate_tabs_to_spaces": true
},
"translation.x": 0.0,
"translation.y": 0.0,
"zoom_level": 1.0
},
"type": "text"
},
{
"buffer": 9,
"file": "include/Tier1/CTask.h",
"settings":
{
"buffer_size": 3787,
"regions":
{
},
"selection":
[
[
2983,
2983
]
],
"settings":
{
"syntax": "Packages/C++/C++.tmLanguage",
"tab_size": 4,
"translate_tabs_to_spaces": true
},
"translation.x": 0.0,
"translation.y": 1125.0,
"zoom_level": 1.0
},
"type": "text"
},
{
"buffer": 10,
"file": "include/Tier0/atomic_operations.h",
"settings":
{
"buffer_size": 1400,
"regions":
{
},
"selection":
[
[
1294,
1294
]
],
"settings":
{
"syntax": "Packages/C++/C++.tmLanguage",
"tab_size": 4,
"translate_tabs_to_spaces": true
},
"translation.x": 0.0,
"translation.y": 0.0,
"zoom_level": 1.0
},
"type": "text"
}
]
}
],
"incremental_find":
{
"height": 0.0
},
"input":
{
"height": 31.0
},
"layout":
{
"cells":
[
[
0,
0,
1,
1
]
],
"cols":
[
0.0,
1.0
],
"rows":
[
0.0,
1.0
]
},
"menu_visible": true,
"output.exec":
{
"height": 100.0
},
"replace":
{
"height": 0.0
},
"save_all_on_build": true,
"select_file":
{
"height": 0.0,
"selected_items":
[
],
"width": 0.0
},
"select_project":
{
"height": 0.0,
"selected_items":
[
],
"width": 0.0
},
"show_minimap": true,
"show_open_files": true,
"show_tabs": true,
"side_bar_visible": true,
"side_bar_width": 276.0,
"status_bar_visible": true
}

8
Kernel/src/Tier0_32/cpp.c → Kernel/src/Tier0/cpp.c
View File

@ -3,15 +3,15 @@
#include "Tier0/cpp.h"
#include "Tier0/kstdio.h"
extern u64 g_start_ctors;
extern u64 g_end_ctors;
extern u64 _start_ctors;
extern u64 _end_ctors;
void CKernelStart(void);
void cpp_call_ctors(void)
{
u32 Number = ((void *)&g_end_ctors - (void *)&g_start_ctors) / 4;
u32 Number = ((void *)&_end_ctors - (void *)&_start_ctors) / 8;
kprintf("[i] Calling %i constructors before jumping to Tier1..\n", Number);
for(u64 *C = (u64*)&g_start_ctors; C < (u64*)&g_end_ctors; ++C)
for(u64 *C = (u64*)&_start_ctors; C < (u64*)&_end_ctors; ++C)
{
((void (*) (void)) (*C)) ();
}

73
Kernel/src/Tier0/kmain.c
View File

@ -15,37 +15,16 @@
//#include "Tier0/kbd_layout.h"
#include "Tier0/physmem.h"
#include "Tier0/heap.h"
//#include "Tier0/cpp.h"
#include "Tier0/cpp.h"
#include "Tier0/exceptions.h"
#include "Tier0/panic.h"
//#include "Tier0/prng.h"
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
#include "lualib.h"
extern u64 _start;
extern u64 _end;
void kmain_newstack(void);
static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
if (nsize == 0)
{
kfree(ptr);
return NULL;
}
if (ptr != 0)
{
void *newptr = kmalloc(nsize);
kmemcpy(newptr, ptr, nsize);
return newptr;
}
return kmalloc(nsize);;
}
// Real kernel entry point, called from loader
void kmain(u32 LoadContextAddress)
{
@ -102,36 +81,6 @@ void kmain(u32 LoadContextAddress)
kmain_newstack_ptr();
}
static int traceback (lua_State *L) {
const char *msg = lua_tostring(L, 1);
if (msg)
{
kprintf("Lua traceback: %s\n", msg);
return 0;
}
return 1;
}
int doluastring(lua_State *State, s8 *Code)
{
kprintf("[i] Running Lua string:\n %s\n", Code);
int Buffer = luaL_loadbuffer(State, Code, kstrlen(Code), "kmain-dostring");
if (Buffer != LUA_OK)
{
kprintf("[e] doluastring: Could not load Lua buffer!\n");
return 1;
}
int Base = lua_gettop(State);
lua_pushcfunction(State, traceback);
lua_insert(State, Base);
lua_pcall(State, 0, 0, 1);
lua_remove(State, Base);
return 0;
}
void kmain_newstack(void)
{
@ -158,11 +107,14 @@ void kmain_newstack(void)
"orq $0x600, %rax;"
"movq %rax, %cr4;");
lua_State *State = lua_newstate(l_alloc, NULL);
luaL_checkversion(State);
luaL_openlibs(State);
doluastring(State, "print(table.concat({'Lua', 'is', 'awesome!'}, ' '))");
for (;;) {}
//lua_State *State = lua_newstate(l_alloc, NULL);
//luaL_checkversion(State);
//luaL_openlibs(State);
cpp_call_ctors();
cpp_start_ckernel();
kprintf("[i] Returned from Tier1, sleeping forever.\n");
LOOPFOREVER;
/*pic_init(0, 0);
ps2_init_simple();
@ -179,10 +131,5 @@ void kmain_newstack(void)
for (u32 Rl = 0; Rl < R; Rl++)
{
krand();
}
cpp_call_ctors();
cpp_start_ckernel();
kprintf("[i] Returned from Tier1, sleeping forever.\n");
LOOPFOREVER;*/
} */
}

18
Kernel/src/Tier1_32/CKernel.cpp → Kernel/src/Tier1/CKernel.cpp
View File

@ -1,11 +1,11 @@
#include "Tier1/CKernel.h"
#include "Tier1/CPageFaultDispatcher.h"
#include "Tier1/CPageDirectory.h"
#include "Tier1/CTask.h"
#include "Tier1/CScheduler.h"
//#include "Tier1/CPageFaultDispatcher.h"
//#include "Tier1/CPageDirectory.h"
//#include "Tier1/CTask.h"
//#include "Tier1/CScheduler.h"
#include "Tier1/Util/CVector.h"
#include "Tier1/Util/CLinearList.h"
#include "Tier1/CTimer.h"
//#include "Tier1/CTimer.h"
using namespace cb;
@ -44,7 +44,7 @@ void CKernel::Start(void)
m_Logger = new CLogger();
CTask *KernelTask = CreateKernelTask();
/*CTask *KernelTask = CreateKernelTask();
kprintf("[i] Kernel task has TID %i.\n", KernelTask->GetPID());
CScheduler::AddTask(KernelTask);
CScheduler::Enable();
@ -73,10 +73,10 @@ void CKernel::Start(void)
}
kprintf("[i] Hello! I'm the child process %i.\n", CTimer::GetTicks());
}
}
}*/
}
extern T_PAGING_DIRECTORY g_kernel_page_directory;
/*extern T_PAGING_DIRECTORY g_kernel_page_directory;
extern CPageDirectory *g_KernelPageDirectory;
CTask *CKernel::CreateKernelTask(void)
{
@ -101,5 +101,5 @@ CTask *CKernel::CreateKernelTask(void)
Task->m_KernelSize = 0x20000000;
return Task;
}
}*/

15
Kernel/src/Tier1/CKnot.h Normal file
View File

@ -0,0 +1,15 @@
#ifndef __CKNOT_H__
#define __CKNOT_H__
// KNOT - Kinda Not an Object Tree, or more accurately, KNOT is Not an
// Object Tree.
namespace cb {
class CKnot {
public:
CKnot(void);
~CKnot(void);
};
};
#endif

0
Kernel/src/Tier1_32/CLogger.cpp → Kernel/src/Tier1/CLogger.cpp
View File

8
Kernel/src/Tier1/CTask.asm Normal file
View File

@ -0,0 +1,8 @@
align 8
section .text
global ctask_getrip
ctask_getrip:
pop rax
jmp rax

191
Kernel/src/Tier1/CTask.cpp Normal file
View File

@ -0,0 +1,191 @@
#include "Tier1/CTask.h"
using namespace cb;
extern "C" {
// #include "Tier0/physical_alloc.h"
#include "Tier0/paging.h"
#include "Tier0/panic.h"
#include "Tier0/kstdio.h"
};
//#include "Tier1/CScheduler.h"
//#include "Tier1/CTimer.h"
///extern CPageDirectory *g_KernelPageDirectory;
u32 CTaskNextPID = 0;
CTask::CTask(bool User, bool Empty)
{
m_User = User;
if (!Empty)
{
// CreateDirectory();
// CreateStack();
// CopyKernelMemory();
m_CreatedStack = true;
}
else
m_CreatedStack = false;
m_Status = ETS_RUNNING;
m_PID = CTaskNextPID++;
m_Priority = ETP_NORMAL;
m_Owner = 0;
m_Ring = (User ? ETR_RING3 : ETR_RING0);
}
CTask::~CTask(void)
{
// if (m_CreatedStack)
// physmem_free_page(m_StackStart / (4 * 1024));
}
// void CTask::CreateStack(void)
// {
// m_StackStart = physmem_allocate_page() * 4 * 1024;
// m_StackSize = TASK_MAP_STACK_SIZE;
// m_Directory->MapTable(TASK_MAP_STACK_START, m_StackStart, 1, 1);
// }
// void CTask::CreateDirectory(void)
// {
// m_Directory = new CPageDirectory();
// }
// void CTask::CopyKernelMemory(void)
// {
// //Copy all the kernel tables...
// m_KernelStart = 0xC0000000;
// m_KernelSize = 0x20000000;
// u32 NumTables = m_KernelSize / (4 * 1024 * 1024);
// for (u32 i = 0; i < NumTables; i++)
// m_Directory->LinkTable(m_KernelStart + i * 4 * 1024 * 1024,
// g_KernelPageDirectory);
// m_Directory->LinkTable(0x00000000, g_KernelPageDirectory);
// m_Directory->LinkTable(0x00400000, g_KernelPageDirectory);
// //m_Directory->LinkTable(0x00800000, g_KernelPageDirectory);
// //m_Directory->LinkTable(0x01000000, g_KernelPageDirectory);
// }
// void CTask::CopyStack(CTask *Source)
// {
// CPageDirectory *SourcePD = Source->GetPageDirectory();
// SourcePD->CopyPage(TASK_MAP_STACK_START, m_Directory, m_User, 1);
// }
// CPageDirectory *CTask::GetPageDirectory(void)
// {
// return m_Directory;
// }
// CTask *CTask::Fork(void)
// {
// __asm__ volatile("cli");
// volatile u32 ESP, EBP;
// CTask *ParentTask = CScheduler::GetCurrentTask();
// CTask *NewTask = new CTask(m_User);
// NewTask->m_Owner = m_Owner;
// NewTask->m_Ring = m_Ring;
// if (m_User)
// {
// //TODO: Write code for userland
// PANIC("Cannot fork usermode program!");
// }
// __asm__ volatile("mov %%esp, %0" : "=r"(ESP));
// __asm__ volatile("mov %%ebp, %0" : "=r"(EBP));
// NewTask->CopyStack(this);
// volatile u32 ForkPoint = ctask_geteip();
// if (CScheduler::GetCurrentTask() == ParentTask)
// {
// NewTask->m_ESP = ESP;
// NewTask->m_EBP = EBP;
// NewTask->m_EIP = ForkPoint;
// kprintf("[i] Forked: TID %i, ESP %x, EBP %x, EIP %x...\n", NewTask->m_PID,
// ESP, EBP, ForkPoint);
// CScheduler::AddTask(NewTask);
// __asm__ volatile("sti");
// return ParentTask;
// }
// else
// {
// __asm__ volatile("sti");
// //for(;;){}
// return NewTask;
// }
// }
// void CTask::Dump(void)
// {
// kprintf("d:%x s:%x b:%x i:%x\n",m_Directory->m_Directory->PhysicalAddress,
// m_ESP, m_EBP, m_EIP);
// }
// __attribute__((optimize("O0"))) void CTask::Yield(void)
// {
// //kprintf("Entering NextTask\n");
// CScheduler::NextTask();
// //kprintf("returned from NextTask\n");
// }
// void CTask::WaitForSemaphore(T_SEMAPHORE *Semaphore)
// {
// __asm__ volatile ("cli");
// m_Status = ETS_WAITING_FOR_SEMAPHORE;
// m_StatusData = m_Directory->Translate((u32)Semaphore);
// Yield();
// __asm__ volatile ("sti");
// }
// void CTask::WaitForSemaphore(CSemaphore *Semaphore)
// {
// __asm__ volatile ("cli");
// m_Status = ETS_WAITING_FOR_SEMAPHORE;
// m_StatusData = m_Directory->Translate((u32)Semaphore);
// Yield();
// __asm__ volatile ("sti");
// }
// void CTask::Disable(void)
// {
// __asm__ volatile ("cli");
// m_Status = ETS_DISABLED;
// Yield();
// __asm__ volatile ("sti");
// }
// void CTask::Enable(void)
// {
// __asm__ volatile ("cli");
// m_Status = ETS_RUNNING;
// __asm__ volatile ("sti");
// }
// void CTask::Sleep(u32 Ticks)
// {
// __asm__ volatile ("cli");
// m_Status = ETS_DISABLED;
// CTimer::Create(Ticks, 1, WakeUp, (u32)this);
// Yield();
// __asm__ volatile ("sti");
// }
// bool CTask::WakeUp(u32 Extra)
// {
// CTask *Task = (CTask*)Extra;
// Task->Enable();
// return true;
// }

0
Kernel/src/Tier1_32/new.cpp → Kernel/src/Tier1/new.cpp
View File

8
Kernel/src/Tier1_32/CTask.asm
View File

@ -1,8 +0,0 @@
align 4
section .text
global ctask_geteip
ctask_geteip:
pop eax
jmp eax

191
Kernel/src/Tier1_32/CTask.cpp
View File

@ -1,191 +0,0 @@
#include "Tier1/CTask.h"
using namespace cb;
extern "C" {
#include "Tier0/physical_alloc.h"
#include "Tier0/paging.h"
#include "Tier0/panic.h"
#include "Tier0/kstdio.h"
};
#include "Tier1/CScheduler.h"
#include "Tier1/CTimer.h"
extern CPageDirectory *g_KernelPageDirectory;
u32 CTaskNextPID = 0;
CTask::CTask(bool User, bool Empty)
{
m_User = User;
if (!Empty)
{
CreateDirectory();
CreateStack();
CopyKernelMemory();
m_CreatedStack = true;
}
else
m_CreatedStack = false;
m_Status = ETS_RUNNING;
m_PID = CTaskNextPID++;
m_Priority = ETP_NORMAL;
m_Owner = 0;
m_Ring = (User ? ETR_RING3 : ETR_RING0);
}
CTask::~CTask(void)
{
if (m_CreatedStack)
physmem_free_page(m_StackStart / (4 * 1024));
}
void CTask::CreateStack(void)
{
m_StackStart = physmem_allocate_page() * 4 * 1024;
m_StackSize = TASK_MAP_STACK_SIZE;
m_Directory->MapTable(TASK_MAP_STACK_START, m_StackStart, 1, 1);
}
void CTask::CreateDirectory(void)
{
m_Directory = new CPageDirectory();
}
void CTask::CopyKernelMemory(void)
{
//Copy all the kernel tables...
m_KernelStart = 0xC0000000;
m_KernelSize = 0x20000000;
u32 NumTables = m_KernelSize / (4 * 1024 * 1024);
for (u32 i = 0; i < NumTables; i++)
m_Directory->LinkTable(m_KernelStart + i * 4 * 1024 * 1024,
g_KernelPageDirectory);
m_Directory->LinkTable(0x00000000, g_KernelPageDirectory);
m_Directory->LinkTable(0x00400000, g_KernelPageDirectory);
//m_Directory->LinkTable(0x00800000, g_KernelPageDirectory);
//m_Directory->LinkTable(0x01000000, g_KernelPageDirectory);
}
void CTask::CopyStack(CTask *Source)
{
CPageDirectory *SourcePD = Source->GetPageDirectory();
SourcePD->CopyPage(TASK_MAP_STACK_START, m_Directory, m_User, 1);
}
CPageDirectory *CTask::GetPageDirectory(void)
{
return m_Directory;
}
CTask *CTask::Fork(void)
{
__asm__ volatile("cli");
volatile u32 ESP, EBP;
CTask *ParentTask = CScheduler::GetCurrentTask();
CTask *NewTask = new CTask(m_User);
NewTask->m_Owner = m_Owner;
NewTask->m_Ring = m_Ring;
if (m_User)
{
//TODO: Write code for userland
PANIC("Cannot fork usermode program!");
}
__asm__ volatile("mov %%esp, %0" : "=r"(ESP));
__asm__ volatile("mov %%ebp, %0" : "=r"(EBP));
NewTask->CopyStack(this);
volatile u32 ForkPoint = ctask_geteip();
if (CScheduler::GetCurrentTask() == ParentTask)
{
NewTask->m_ESP = ESP;
NewTask->m_EBP = EBP;
NewTask->m_EIP = ForkPoint;
kprintf("[i] Forked: TID %i, ESP %x, EBP %x, EIP %x...\n", NewTask->m_PID,
ESP, EBP, ForkPoint);
CScheduler::AddTask(NewTask);
__asm__ volatile("sti");
return ParentTask;
}
else
{
__asm__ volatile("sti");
//for(;;){}
return NewTask;
}
}
void CTask::Dump(void)
{
kprintf("d:%x s:%x b:%x i:%x\n",m_Directory->m_Directory->PhysicalAddress,
m_ESP, m_EBP, m_EIP);
}
__attribute__((optimize("O0"))) void CTask::Yield(void)
{
//kprintf("Entering NextTask\n");
CScheduler::NextTask();
//kprintf("returned from NextTask\n");
}
void CTask::WaitForSemaphore(T_SEMAPHORE *Semaphore)
{
__asm__ volatile ("cli");
m_Status = ETS_WAITING_FOR_SEMAPHORE;
m_StatusData = m_Directory->Translate((u32)Semaphore);
Yield();
__asm__ volatile ("sti");
}
void CTask::WaitForSemaphore(CSemaphore *Semaphore)
{
__asm__ volatile ("cli");
m_Status = ETS_WAITING_FOR_SEMAPHORE;
m_StatusData = m_Directory->Translate((u32)Semaphore);
Yield();
__asm__ volatile ("sti");
}
void CTask::Disable(void)
{
__asm__ volatile ("cli");
m_Status = ETS_DISABLED;
Yield();
__asm__ volatile ("sti");
}
void CTask::Enable(void)
{
__asm__ volatile ("cli");
m_Status = ETS_RUNNING;
__asm__ volatile ("sti");
}
void CTask::Sleep(u32 Ticks)
{
__asm__ volatile ("cli");
m_Status = ETS_DISABLED;
CTimer::Create(Ticks, 1, WakeUp, (u32)this);
Yield();
__asm__ volatile ("sti");
}
bool CTask::WakeUp(u32 Extra)
{
CTask *Task = (CTask*)Extra;
Task->Enable();
return true;
}

17
Kernel/src/kernel.ld
View File

@ -13,8 +13,15 @@ SECTIONS
{
_code = .;
*(.text)
*(.text.startup)
*(.rodata*)
. = ALIGN(8);
_start_ctors = .;
*(.ctors)
_end_ctors = .;
. = ALIGN(4096);
}
@ -25,13 +32,6 @@ SECTIONS
. = ALIGN(4096);
}
.ehframe : AT(ADDR(.ehframe) - KERNEL_VMA)
{
_ehframe = .;
*(.ehframe)
. = ALIGN(4096);
}
.bss : AT(ADDR(.bss) - KERNEL_VMA)
{
_bss = .;
@ -46,5 +46,6 @@ SECTIONS
{
*(.comment)
*(.debug*)
*(.eh_frame)
}
}