Fixed fork issues

Author: Oxmose

Source/Config/arch/x86_64/Artifacts/kernel/config.h

@@ -27,7 +27,7 @@
 #define KERNEL_STACK_SIZE 0x1000
 
 /* Maximal number of CPU supported by the architecture */
-#define SOC_CPU_COUNT 4
+#define SOC_CPU_COUNT 1
 
 /* Kernel log level */
 #define KERNEL_LOG_LEVEL DEBUG_LOG_LEVEL

Source/Config/arch/x86_64/Artifacts/kernel/settings.mk

@@ -26,7 +26,7 @@ endif
 KERNEL_LINKER_FILE = ../../Config/arch/x86_64/Artifacts/kernel/kernel_linker.ld
 
 DEBUG_FLAGS = -O0 -g
-EXTRA_FLAGS = -O3 -fno-asynchronous-unwind-tables
+EXTRA_FLAGS = -O3 -fno-asynchronous-unwind-tables -g
 
 CFLAGS = -std=c11 -nostdinc -fno-builtin -nostdlib  \
          -nostartfiles -nodefaultlibs -Wall -Wextra -Werror -c -fno-pie \

Source/Config/arch/x86_64/x86_64_fdt.dts

@@ -203,7 +203,7 @@
             compatible = "x86,x86-vesa";
             resolution = <1024 768>;
             depth = <32>;
-            refresh-rate = <1>;
+            refresh-rate = <60>;
             device = "/dev/vesa";
         };
 

Source/Kernel/arch/bsp/x86/src/core_mgt.c

@@ -115,6 +115,8 @@
  */
 static bool _ipiInterruptHandler(kernel_thread_t* pCurrThread);
 
+#endif /* #if SOC_CPU_COUNT > 1 */
+
 /**
  * @brief Attaches the Core Manager driver to the system.
  *
@@ -133,6 +135,8 @@ static OS_RETURN_E _coreMgtAttach(const fdt_node_t* pkFdtNode);
  * GLOBAL VARIABLES
  ******************************************************************************/
 
+#if SOC_CPU_COUNT > 1
+
 /************************* Imported global variables **************************/
 /** @brief Stores the number of enabled (running) cores in the system. */
 extern volatile uint32_t _bootedCPUCount;
@@ -467,7 +471,8 @@ void cpuMgtSendIpi(const uint32_t kFlags,
                    const bool     kAllocateParam)
 {
     (void)kFlags;
-    (void)kpParams;
+    (void)pParams;
+    (void)kAllocateParam;
 }
 
 #endif /* SOC_CPU_COUNT > 1 */

Source/Kernel/arch/cpu/i386/src/memory.c

@@ -858,9 +858,9 @@ static void _pageFaultHandler(kernel_thread_t* pCurrentThread)
                 /* Check if the entry is set as COW */
                 if((flags & MEMMGR_MAP_COW) == MEMMGR_MAP_COW)
                 {
-                    error = _memoryManageCOW(faultAddress,
-                                             physAddr,
-                                             pCurrentThread);
+                    error = memoryManageCOW(faultAddress,
+                                            physAddr,
+                                            pCurrentThread);
                     if(error != OS_NO_ERR)
                     {
                         staleEntry = false;

Source/Kernel/arch/cpu/includes/memory.h

@@ -76,6 +76,17 @@ typedef struct
     uintptr_t limit;
 } mem_range_t;
 
+/** @brief Structure that defines an information about a memory page. */
+typedef struct 
+{
+    /** @brief Virtual address of the memory page. */
+    uintptr_t virtAddress;
+    /** @brief Physical address of the memory page. */
+    uintptr_t physAddress;
+    /** @brief Mapping flags */
+    uintptr_t flags;
+} memory_page_info_t;
+
 /*******************************************************************************
  * MACROS
  ******************************************************************************/
@@ -370,10 +381,10 @@ OS_RETURN_E memoryUserMapDirect(const void*       kPhysicalAddress,
                                 kernel_process_t* pProcess);
 
 /**
- * @brief Unmaps a virtual region (memory or hardware) from the kernel address
+ * @brief Unmaps a virtual region (memory or hardware) from the user address
  * space.
  *
- * @details Unmaps a virtual region (memory or hardware) from the kernel address
+ * @details Unmaps a virtual region (memory or hardware) from the user address
  * space. The virtual address and the size must be aligned on page
  * boundaries. If not, the unmapping fails and an error is returned.
  *
@@ -436,6 +447,38 @@ OS_RETURN_E memoryUserFree(const void*       kVirtualAddress,
                            const size_t      kSize,
                            kernel_process_t* pProcess);
 
+/**
+ * @brief Handles a CopyOnWrite event.
+ *
+ * @details Handles a CopyOnWrite event. If the faulted page is COW, copies it
+ * if the reference count is greater than 1, otherwise simply set the page as
+ * writable.
+ *
+ * @param[in] kFaultVirtAddr The virtual address that generated to fault.
+ * @param[in] kPhysAddr The physical address that corresponds to the faulted
+ * page.
+ * @param[in] kpThread The thread that raised the COW exception.
+ *
+ * @return The function returns the success or error status.
+ */
+OS_RETURN_E memoryManageCOW(const uintptr_t        kFaultVirtAddr,
+                            const uintptr_t        kPhysAddr,
+                            const kernel_thread_t* kpThread);
+
+/**
+ * @brief Returns the page informations of a thread.
+ * 
+ * @details Returns the page informations of a thread. This function will fill
+ * the table given as parameter with the page information of the given thread.
+ * 
+ * @param[in] kpThread The thread for which the information should be extracted.
+ * @param[out] pPageInfo The table to fill.
+ * @param[in/out] pSize The size of the table. This value is updated with the 
+ * actual size of the table after filling it.
+ */
+void memoryGetPagesInfo(const kernel_thread_t* kpThread,
+                        memory_page_info_t*    pPageInfo,
+                        size_t*                pSize);
 #endif /* #ifndef __MEMORY_MGR_ */
 
 /************************************ EOF *************************************/

Source/Kernel/arch/cpu/x86_64/src/cpu.c

@@ -4935,6 +4935,9 @@ OS_RETURN_E cpuCopyVirtualCPUs(const kernel_thread_t* kpSrcThread,
                                        pStackOffset;
     }
 
+    /* Update kernel stack end */
+    pCurVCpu->kernelStackEnd = pDstThread->kernelStackEnd - 0x10;
+
     return OS_NO_ERR;
 }
 
@@ -5425,10 +5428,8 @@ OS_RETURN_E cpuCopyLocalStorage(kernel_thread_t*       pThread,
     size_t      align;
     size_t      size;
     OS_RETURN_E error;
-    OS_RETURN_E intError;
-    uintptr_t   tls;
-    uintptr_t   tlsPhys;
-    void*       pTmpData;
+    uintptr_t   srcTls;
+    uintptr_t   srcTlsPhys;
 
     if(pThread->type == THREAD_TYPE_KERNEL)
     {
@@ -5444,68 +5445,39 @@ OS_RETURN_E cpuCopyLocalStorage(kernel_thread_t*       pThread,
         return OS_NO_ERR;
     }
 
-    /* Compute the memory size with alignement */
+    
+    /* Get the original thread TLS virtual and physical addresses */
     align = MAX(pThread->pProcess->mainTlsAlign, __alignof__(user_thread_t));
-    /* We do not support more than a page alignement */
-    if(align > KERNEL_PAGE_SIZE)
-    {
-        return OS_ERR_NOT_SUPPORTED;
-    }
+    srcTls = (uintptr_t)kpSrcThread->pUserThreadData -
+             ALIGN_UP(pThread->pProcess->mainTlsSize, align);
+    srcTlsPhys = memoryMgrGetPhysAddr(srcTls, kpSrcThread->pProcess, NULL);
 
+    /* Copy the thread local storage that was COW */
     size = ALIGN_UP(pThread->pProcess->mainTlsSize, align) +
            sizeof(user_thread_t);
 
     /* Align to page size */
     size = ALIGN_UP(size, KERNEL_PAGE_SIZE);
-
-    pThread->pUserThreadData = memoryUserAllocate(size,
-                                                  MEMMGR_MAP_RW |
-                                                  MEMMGR_MAP_USER,
-                                                  pThread->pProcess,
-                                                  &error);
-    if(error != OS_NO_ERR)
-    {
-        return error;
-    }
-
-    tlsPhys = memoryMgrGetPhysAddr((uintptr_t)pThread->pUserThreadData,
-                                   pThread->pProcess,
-                                   NULL);
-    CPU_ASSERT(tlsPhys != MEMMGR_PHYS_ADDR_ERROR,
-               "Failed to get mapped physical address",
-                OS_ERR_INCORRECT_VALUE);
-
-    pTmpData = memoryKernelMap((void*)tlsPhys,
-                               size,
-                               MEMMGR_MAP_KERNEL | MEMMGR_MAP_RW,
-                               &error);
-    if(error != OS_NO_ERR)
+    while(size > 0)
     {
-        intError = memoryUserFree(pThread->pUserThreadData,
-                                  size,
-                                  pThread->pProcess);
-        CPU_ASSERT(intError == OS_NO_ERR,
-                   "Failed to free allocated memory",
-                    OS_ERR_INCORRECT_VALUE);
-        return error;
+        error = memoryManageCOW(srcTls, srcTlsPhys, pThread);
+        if(error != OS_NO_ERR)
+        {
+            return error;
+        }
+        error = memoryManageCOW(srcTls, srcTlsPhys, kpSrcThread);
+        if(error != OS_NO_ERR)
+        {
+            return error;
+        }
+        size -= KERNEL_PAGE_SIZE;
+        srcTls += KERNEL_PAGE_SIZE;
+        srcTlsPhys += KERNEL_PAGE_SIZE;
     }
 
-    /* Get the TLS and copy */
-    tls = (uintptr_t)kpSrcThread->pUserThreadData -
-          ALIGN_UP(pThread->pProcess->mainTlsSize, align);
-    memcpy(pTmpData,
-           (void*)tls,
-           (uintptr_t)kpSrcThread->pUserThreadData - tls);
-
-    intError = memoryKernelUnmap(pTmpData, size);
-    CPU_ASSERT(intError == OS_NO_ERR,
-               "Failed to unmap mapped memory",
-               OS_ERR_INCORRECT_VALUE);
-
     /* Setup the user data pointer */
-    pThread->pUserThreadData = (void*)((uintptr_t)pThread->pUserThreadData +
-                               ALIGN_UP(pThread->pProcess->mainTlsSize, align));
-
+    pThread->pUserThreadData = kpSrcThread->pUserThreadData;
+    
     return OS_NO_ERR;
 }
 

Source/Kernel/arch/cpu/x86_64/src/cpuContext.s

@@ -269,7 +269,6 @@ cpuSignalHandlerLoop:
 ; Param:
 ;     Input: rdi: The address to return to when restoring the context
 ;            rsi: The current thread
-
 cpuSwitchKernelSyscallContext:
     ; Save the return address in rcx
     pop rcx

Source/Kernel/arch/cpu/x86_64/src/cpuSyscall.s

@@ -91,6 +91,8 @@ cpuSystemCallInit:
 ;     Input: rdi: The systen call ID
 ;            rsi: A pointer to the system call parameters.
 cpuUserSyscallHandler:
+    cli
+
     ; Save the user stack
     push r11
     push rcx
@@ -120,18 +122,29 @@ cpuUserSyscallHandler:
     mov  [r12 + VCPU_OFF_SYSCALL_RSP], rsp
 
     ; Call the main C handler
+    sti
     call syscallHandle
 
     ; Discard the scheduler return that was pushed in case the call generated a
     ; scheduling.
     add rsp, 8
 
+    ; Get the current thread handle and VCPU
+    push rdi
+    push rsi
+    call schedGetCurrentThread
+    pop rsi
+    pop rdi
+    mov rax, [rax]
+
     ; Clear the syscall stack registration
-    xor rax, rax
-    mov [r12 + VCPU_OFF_SYSCALL_RSP], rax
+    xor rbx, rbx
+    mov [rax + VCPU_OFF_SYSCALL_RSP], rbx
 
 
 __cpuUserSyscallReturn:
+    cli
+
     ; Restore the user stack
     pop rax
     mov rsp, rax
@@ -148,6 +161,7 @@ __cpuUserSyscallReturn:
 
     ; Return from syscall
     o64 sysret
+    
 
 ;-------------------------------------------------------------------------------
 ; Raise a kernel space system call.

Source/Kernel/arch/cpu/x86_64/src/intHandlers.s

@@ -42,6 +42,23 @@ __intHandler%1:
     jmp     __intHandlerEntry       ; jump to the common handler
 %endmacro
 
+%macro ERR_CODE_INT_HANDLER_DBG 1       ; Interrupt that do not come with an
+                                        ; err code.
+
+global __intHandler%1
+__intHandler%1:
+    cli
+    pop rax
+    pop rbx
+    pop rcx
+    pop rdx
+    pop r8
+    mov rsp, r8
+_dbg_loop%1:
+    cli
+    jmp     _dbg_loop%1       ; jump to the common handler
+%endmacro
+
 ;-------------------------------------------------------------------------------
 ; EXTERN DATA
 ;-------------------------------------------------------------------------------
@@ -77,11 +94,11 @@ __intHandlerEntry:
     call interruptMainHandler
 
 ; Now create handlers for each interrupt
-ERR_CODE_INT_HANDLER 8
+ERR_CODE_INT_HANDLER_DBG 8
 ERR_CODE_INT_HANDLER 10
 ERR_CODE_INT_HANDLER 11
 ERR_CODE_INT_HANDLER 12
-ERR_CODE_INT_HANDLER 13
+ERR_CODE_INT_HANDLER_DBG 13
 ERR_CODE_INT_HANDLER 14
 ERR_CODE_INT_HANDLER 17
 ERR_CODE_INT_HANDLER 30