Add initial fork implementation

Author: eminakgun

makefile Makefile

@@ -6,6 +6,8 @@ GCCPARAMS = -m32 -Iinclude -fno-use-cxa-atexit -nostdlib -fno-builtin -fno-rtti
 ASPARAMS = --32
 LDPARAMS = -melf_i386
 
+VirtualBoxVM = /mnt/c/Program\ Files/Oracle/VirtualBox/VirtualBoxVM.exe
+
 objects = obj/loader.o \
           obj/gdt.o \
           obj/memorymanagement.o \
@@ -19,23 +21,12 @@ objects = obj/loader.o \
           obj/hardwarecommunication/pci.o \
           obj/drivers/keyboard.o \
           obj/drivers/mouse.o \
-          obj/drivers/vga.o \
-          obj/drivers/ata.o \
-          obj/gui/widget.o \
-          obj/gui/window.o \
-          obj/gui/desktop.o \
-          obj/net/etherframe.o \
-          obj/net/arp.o \
-          obj/net/ipv4.o \
-          obj/net/icmp.o \
-          obj/net/udp.o \
-          obj/net/tcp.o \
           obj/kernel.o
 
 
-run: mykernel.iso
-	(killall VirtualBox && sleep 1) || true
-	VirtualBox --startvm 'My Operating System' &
+run: clean mykernel.iso
+	(killall $(VirtualBoxVM) && sleep 1) || true
+	$(VirtualBoxVM) --startvm 'EminOS' &
 
 obj/%.o: src/%.cpp
 	mkdir -p $(@D)

ReadMe.txt

@@ -0,0 +1,9 @@
+
+
+On fork
+The child process and the parent process run in separate memory spaces.  At the time of fork() both memory spaces have the same content.
+Memory writes, file mappings (mmap(2)), and unmappings (munmap(2)) performed by one of the processes do not affect the other.
+The child has its own unique process ID,.
+The child's parent process ID is the same as the parent's process ID.
+- RETURN VALUE
+    On success, the PID of the child process is returned in the parent, and 0 is returned in the child.  On failure, -1 is returned in the parent, no child process is created, and errno is set appropriately.

include/multitasking.h

@@ -5,59 +5,111 @@
 #include <common/types.h>
 #include <gdt.h>
 
+using namespace myos;
+using namespace myos::common;
+
+void printf(char* str);
+void printInt(int i);
+
+
 namespace myos
 {
+
+    enum ProcessState {
+        READY,
+        RUNNING,
+        BLOCKED,
+        TERMINATED
+    };
+
 
     struct CPUState
     {
-        common::uint32_t eax;
-        common::uint32_t ebx;
-        common::uint32_t ecx;
-        common::uint32_t edx;
+        uint32_t eax;
+        uint32_t ebx;
+        uint32_t ecx;
+        uint32_t edx;
 
-        common::uint32_t esi;
-        common::uint32_t edi;
-        common::uint32_t ebp;
+        uint32_t esi;
+        uint32_t edi;
+        uint32_t ebp;
 
         /*
         common::uint32_t gs;
         common::uint32_t fs;
         common::uint32_t es;
         common::uint32_t ds;
         */
-        common::uint32_t error;
+        uint32_t error;
 
-        common::uint32_t eip;
-        common::uint32_t cs;
-        common::uint32_t eflags;
-        common::uint32_t esp;
-        common::uint32_t ss;        
+        // already on stack:
+        uint32_t eip;
+        uint32_t cs;
+        uint32_t eflags;
+        uint32_t esp;
+        uint32_t ss;        
     } __attribute__((packed));
 
+
+    struct PCB
+    {
+        uint32_t pid;  // Process ID
+        uint32_t ppid; // Parent Process ID
+        ProcessState state;
+    };
 
     class Task
     {
     friend class TaskManager;
     private:
         common::uint8_t stack[4096]; // 4 KiB
         CPUState* cpustate;
+        PCB pcb;
+
     public:
         Task(GlobalDescriptorTable *gdt, void entrypoint());
         ~Task();
+        uint8_t* StackStartAddr(){return stack;};
+        uint32_t GetPID(){return pcb.pid;};
+        void SetCPUState(CPUState* cpustate_) {cpustate = cpustate_;};
     };
 
 
     class TaskManager
     {
+    friend class SyscallHandler;
     private:
-        Task* tasks[256];
+        Task* tasks[256]; // aka process-table
         int numTasks;
         int currentTask;
     public:
         TaskManager();
         ~TaskManager();
+        Task* GetCurrent();
+        Task* AddTask();
         bool AddTask(Task* task);
         CPUState* Schedule(CPUState* cpustate);
+        void printTasks(){
+            for (size_t i = 0; i < numTasks; i++)
+            {
+                printf("\nTask number: ");
+                printInt(i);
+                printf("\n\t");
+
+                printf("pid: ");
+                printInt(tasks[i]->pcb.pid);
+                printf("\n\t");
+
+                printf("ppid: ");
+                printInt(tasks[i]->pcb.ppid);
+                printf("\n\t");
+
+                printf("state: ");
+                printInt(tasks[i]->pcb.state);
+                printf("\n");
+            }
+            
+        }
     };
 
 

include/syscalls.h

@@ -8,16 +8,19 @@
 
 namespace myos
 {
+
+    const uint32_t FORK_INT = 2;
 
     class SyscallHandler : public hardwarecommunication::InterruptHandler
     {
-        
+    private:
+        TaskManager* taskManager;
     public:
-        SyscallHandler(hardwarecommunication::InterruptManager* interruptManager, myos::common::uint8_t InterruptNumber);
+        SyscallHandler(hardwarecommunication::InterruptManager* interruptManager, myos::common::uint8_t InterruptNumber, TaskManager* taskManager);
         ~SyscallHandler();
 
         virtual myos::common::uint32_t HandleInterrupt(myos::common::uint32_t esp);
-
+        void fork(uint32_t esp);
     };