Shm

sources/kernel/include/fs/drivers/shm_fs.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <fs/filesystem.h>
+#include <process/resource_manager.h>
+
+class CShm_FS_Driver : public IFilesystem_Driver
+{
+    public:
+        virtual void On_Register() override
+        {
+            //
+        }
+
+        virtual IFile *Open_File(const char* path, NFile_Open_Mode mode) override
+        {
+            return sProcess_Resource_Manager.Alloc_Shm_File(path);
+        }
+};
+
+CShm_FS_Driver fsShm_FS_Driver;

sources/kernel/include/fs/filesystem.h

@@ -22,6 +22,7 @@ enum class NFile_Type_Major
     Semaphore       = 3, // semaphore virtual file
     Condition_Var   = 4, // podminkova promenna
     Pipe            = 5, // roura
+    Shm_File        = 6
 };
 
 enum class NFile_Open_Mode

sources/kernel/include/memory/memmap.h

@@ -25,4 +25,6 @@ namespace mem
 
     // kolik stranek vlastne muzeme pridelit?
     constexpr uint32_t PageCount = PagingMemorySize / PageSize;
+
+    constexpr uint32_t Invalid_Virtual_Address = 0xFFFF'FFFF - PageSize;
 }

sources/kernel/include/memory/mmu.h

@@ -188,3 +188,10 @@ extern "C" void mmu_invalidate_tlb();
 void copy_kernel_page_table_to(uint32_t* target);
 // namapuje do zadane tabulky dane adresy; pro ted jde jen o stranky velikosti 1MB
 void map_memory(uint32_t* target_pt, uint32_t phys, uint32_t virt);
+
+// mapuje file do tabulky stranek procesu; vraci virtualni adresu
+// v pripade, ze dany file handler jeste neobsahuje adresu ramce, vyzada si ji od sPage_Manager
+// NOTE: I presto, ze je zde parametr size, tak bylo domluveno se zadavetelem, ze
+// zatim bude alokovana pouze jedna sdilena stranka. Kontinualni alokace bude pravdepodobne tematem
+// dalsich semestralnich praci
+uint32_t map_shm(uint32_t size, uint32_t file);

sources/kernel/include/process/resource_manager.h

@@ -6,6 +6,7 @@
 #include "semaphore.h"
 #include "condvar.h"
 #include "pipe.h"
+#include "shm.h"
 
 // pocet predalokovanych mutexu (a zaroven max. pocet)
 constexpr uint32_t Mutex_Count = 32;
@@ -27,6 +28,9 @@ constexpr uint32_t Pipe_Count = 16;
 // maximalni delka jmena pipe
 constexpr uint32_t Max_Pipe_Name_Length = 16;
 
+constexpr uint32_t Shm_Count = 16;
+constexpr uint32_t Max_Memory_Name_Length = 16;
+
 // pri otevirani semaforu = pokud uz musel byt semafor otevreny
 constexpr uint32_t Semaphore_Initial_Res_Count_Unknown = static_cast<uint32_t>(-1);
 // pokud je pri otevirani pipe velikost neznama
@@ -63,10 +67,18 @@ class CProcess_Resource_Manager
             unsigned int alloc_count;
         };
 
+        struct TShared_Memory_Record
+        {
+            CShared_Memory memory;
+            char name [Max_Memory_Name_Length];
+            unsigned int alloc_count;
+        };
+
         TMutex_Record mMutexes[Mutex_Count];
         TSemaphore_Record mSemaphores[Semaphore_Count];
         TCond_Var_Record mCondVars[Cond_Var_Count];
         TPipe_Record mPipes[Pipe_Count];
+        TShared_Memory_Record mShm_Records[Shm_Count];
 
     public:
         CProcess_Resource_Manager();
@@ -83,6 +95,8 @@ class CProcess_Resource_Manager
 
         CPipe* Alloc_Pipe(const char* name, uint32_t pipe_size);
         void Free_Pipe(CPipe* pipe);
+
+        CShared_Memory *Alloc_Shm_File(const char* name);
 };
 
 extern CProcess_Resource_Manager sProcess_Resource_Manager;

sources/kernel/include/process/shm.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <fs/filesystem.h>
+
+class CShared_Memory : public IFile
+{
+    private:
+        uint32_t mPhys_Addrs;
+
+        public:
+
+        CShared_Memory();
+        ~CShared_Memory() = default;
+
+        uint32_t Get_Phys_Addrs() const
+        {
+            return mPhys_Addrs;
+        }
+
+        void Set_Phys_Addrs(uint32_t phys_addrs)
+        {
+            mPhys_Addrs = phys_addrs;
+        }
+
+        virtual uint32_t Read(char* buffer, uint32_t num) override;
+        virtual uint32_t Write(const char* buffer, uint32_t num) override;
+        virtual bool Close() override;
+        virtual bool Wait(uint32_t count) override;
+        virtual uint32_t Notify(uint32_t count) override;
+};

sources/kernel/include/process/swi.h

@@ -96,6 +96,8 @@ enum class NSWI_Filesystem_Service
     // IN:  r0 = handle otevreneho souboru, r1 = pocet zdroju, r2 = nova deadline po probuzeni (nebo Deadline_Unchanged pokud se nema menit, nebo Indefinite pokud se ma zrusit)
     // OUT: r0 = indikator uspechu (NSWI_Result_Code)
     Wait            = 6,
+
+    MemMap          = 7,
 };
 
 // mozne IOCtl operace nad souborem

sources/kernel/src/fs/filesystem_drivers.cpp

@@ -11,6 +11,7 @@
 #include <fs/drivers/mutex_fs.h>
 #include <fs/drivers/condvar_fs.h>
 #include <fs/drivers/pipe_fs.h>
+#include <fs/drivers/shm_fs.h>
 
 // pole driveru - tady uvedeme vsechny, ktere jsou v systemu dostupne a ktere je zadouci pro tuto instanci naseho OS pripojit
 const CFilesystem::TFS_Driver CFilesystem::gFS_Drivers[] = {
@@ -27,6 +28,7 @@ const CFilesystem::TFS_Driver CFilesystem::gFS_Drivers[] = {
     { "Semaphore", "SYS:sem", &fsSemaphore_FS_Driver },
     { "CondVar", "SYS:cv", &fsCond_Var_FS_Driver },
     { "Pipe", "SYS:pipe", &fsPipe_FS_Driver },
+    { "SharedMem", "SYS:shm", &fsShm_FS_Driver},
 };
 
 // pocet FS driveru - je staticky spocitan z velikosti vyse uvedeneho pole

sources/kernel/src/main.cpp

@@ -39,11 +39,11 @@ extern "C" int _kernel_main(void)
 
 	// vytvoreni vsech tasku
 	// TODO: presunuti do init procesu a nejake inicializacni sekce
-	sProcessMgr.Create_Process(__sos_task_elf, __sos_task_elf_len, false);
+	// sProcessMgr.Create_Process(__sos_task_elf, __sos_task_elf_len, false);
 	sProcessMgr.Create_Process(__oled_task_elf, __oled_task_elf_len, false);
 	sProcessMgr.Create_Process(__logger_task_elf, __logger_task_elf_len, false);
-	sProcessMgr.Create_Process(__counter_task_elf, __counter_task_elf_len, false);
-	sProcessMgr.Create_Process(__tilt_task_elf, __tilt_task_elf_len, false);
+	// sProcessMgr.Create_Process(__counter_task_elf, __counter_task_elf_len, false);
+	// sProcessMgr.Create_Process(__tilt_task_elf, __tilt_task_elf_len, false);
 
 	// zatim zakazeme IRQ casovace
 	sInterruptCtl.Disable_Basic_IRQ(hal::IRQ_Basic_Source::Timer);

sources/kernel/src/memory/mmu.cpp

@@ -1,5 +1,9 @@
 #include <hal/peripherals.h>
 #include <memory/mmu.h>
+#include <process/process_manager.h>
+#include <process/resource_manager.h>
+#include <memory/pages.h>
+#include <drivers/uart.h>
 
 extern volatile __attribute__((section(".initsys.data"))) uint32_t Page_Directory_Kernel[PT_Size];
 
@@ -52,3 +56,57 @@ void map_memory(uint32_t* target_pt, uint32_t phys, uint32_t virt)
             | DL1_Flags::TEX_001
             | DL1_Flags::Shareable;
 }
+
+uint32_t map_shm(uint32_t size, uint32_t file)
+{
+    if (size == 0 || size % mem::PageSize != 0 || file > Max_Process_Opened_Files)
+    {
+        return mem::Invalid_Virtual_Address;
+    }
+
+    TTask_Struct *current = sProcessMgr.Get_Current_Process();
+    if(!current)
+    {
+        return mem::Invalid_Virtual_Address;
+    }
+
+    if (!current->opened_files[file] || current->opened_files[file]->Get_File_Type() != NFile_Type_Major::Shm_File)
+    {
+        return mem::Invalid_Virtual_Address;
+    }
+
+    CShared_Memory *record = static_cast<CShared_Memory *>(current->opened_files[file]);
+    uint32_t phys_addrs = record->Get_Phys_Addrs();
+    if (phys_addrs == 0)
+    {
+        uint32_t new_virt_addrs = sPage_Manager.Alloc_Page();
+        if (new_virt_addrs == 0)
+        {
+            return mem::Invalid_Virtual_Address;
+        }
+        phys_addrs = new_virt_addrs - mem::MemoryVirtualBase;
+        record->Set_Phys_Addrs(phys_addrs);
+    }
+
+    unsigned long pt_phys_addrs = current->cpu_context.ttbr0 & (~ 0x3FFF);
+    volatile uint32_t *pt_virt_addrs = reinterpret_cast<volatile uint32_t *>(pt_phys_addrs + mem::MemoryVirtualBase);
+
+    for (uint32_t i = 0; i < PT_Size; i++)
+    {
+        if ((pt_virt_addrs[i] & 0b11U) == DL1_Flags::Access_Type_Translation_Fault)
+        {
+            pt_virt_addrs[i] = (phys_addrs & 0xFFF00000)
+                        | DL1_Flags::Access_Type_Section_Address
+                        | DL1_Flags::Bufferable
+                        | DL1_Flags::Cacheable
+                        | DL1_Flags::Shareable
+                        | DL1_Flags::Domain_0
+                        | DL1_Flags::Access_Full_RW;
+            mmu_invalidate_tlb();
+            return i * PT_Region_Size;
+        }
+    }
+
+
+    return mem::Invalid_Virtual_Address;
+}

sources/kernel/src/process/process_manager.cpp

@@ -10,7 +10,6 @@
 
 #include <fs/filesystem.h>
 
-#include <drivers/uart.h>
 #include <drivers/timer.h>
 
 // "importovane" funkce z asm
@@ -400,6 +399,11 @@ void CProcess_Manager::Handle_Filesystem_SWI(NSWI_Filesystem_Service svc_idx, ui
             mCurrent_Task_Node->task->notified_deadline = Deadline_Unchanged;
             break;
         }
+        case NSWI_Filesystem_Service::MemMap:
+        {
+            target.r0 = map_shm(r0, r1);
+            break;
+        }
     }
 }
 

sources/kernel/src/process/resource_manager.cpp

@@ -1,5 +1,6 @@
 #include <process/resource_manager.h>
 #include <stdstring.h>
+#include <memory/pages.h>
 
 CProcess_Resource_Manager sProcess_Resource_Manager;
 
@@ -10,6 +11,12 @@ CProcess_Resource_Manager::CProcess_Resource_Manager()
         mMutexes[i].name[0] = '\0';
         mMutexes[i].alloc_count = 0;
     }
+
+    for (uint32_t i = 0; i < Shm_Count; i++)
+    {
+        mShm_Records[i].name[0] = '\0';
+        mShm_Records[i].alloc_count = 0;
+    }
 }
 
 CProcess_Resource_Manager::~CProcess_Resource_Manager()
@@ -127,6 +134,7 @@ CCondition_Variable* CProcess_Resource_Manager::Alloc_Condition_Variable(const c
 
             strncpy(mCondVars[i].name, name, Max_Cond_Var_Name_Length);
             mCondVars[i].alloc_count++;
+            mCondVars[i].cv.Reset(cvmtx);
             return &mCondVars[i].cv;
         }
     }
@@ -191,3 +199,30 @@ void CProcess_Resource_Manager::Free_Pipe(CPipe* pipe)
         }
     }
 }
+
+CShared_Memory *CProcess_Resource_Manager::Alloc_Shm_File(const char* name)
+{
+    for (uint32_t i = 0; i < Shm_Count; i++)
+    {
+        if (mShm_Records[i].alloc_count > 0)
+        {
+            if (strncmp(mShm_Records[i].name, name, Max_Memory_Name_Length) == 0)
+            {
+                mShm_Records[i].alloc_count++;
+                return &mShm_Records[i].memory;
+            }
+        }
+    }
+
+    for (uint32_t i = 0; i < Shm_Count; i++)
+    {
+        if (mShm_Records[i].alloc_count == 0)
+        {
+            strncpy(mShm_Records[i].name, name, Max_Memory_Name_Length);
+            mShm_Records[i].alloc_count++;
+            return &mShm_Records[i].memory;
+        }
+    }
+
+    return nullptr;
+}

sources/kernel/src/process/shm.cpp

@@ -0,0 +1,28 @@
+#include <process/shm.h>
+
+
+CShared_Memory::CShared_Memory() : IFile{NFile_Type_Major::Shm_File}, mPhys_Addrs {0}
+{
+    //
+}
+
+uint32_t CShared_Memory::Read(char* buffer, uint32_t num)
+{
+    return 0;
+}
+uint32_t CShared_Memory::Write(const char* buffer, uint32_t num)
+{
+    return 0;
+}
+bool CShared_Memory::Close()
+{
+    return false;
+}
+bool CShared_Memory::Wait(uint32_t count)
+{
+    return false;
+}
+uint32_t CShared_Memory::Notify(uint32_t count)
+{
+    return 0;
+}

sources/stdlib/include/stdfile.h

@@ -21,5 +21,7 @@ uint32_t ioctl(uint32_t file, NIOCtl_Operation operation, void* param);
 uint32_t notify(uint32_t file, uint32_t count = 1);
 NSWI_Result_Code wait(uint32_t file, uint32_t count = 1, uint32_t notified_deadline = Deadline_Unchanged);
 bool sleep(uint32_t ticks, uint32_t notified_deadline = Deadline_Unchanged);
+char *mmap(uint32_t size, uint32_t file);
 
 uint32_t pipe(const char* name, uint32_t buf_size);
+

sources/stdlib/src/stdfile.cpp

@@ -104,6 +104,17 @@ NSWI_Result_Code wait(uint32_t file, uint32_t count, uint32_t notified_deadline)
     return retcode;
 }
 
+char *mmap(uint32_t size, uint32_t file)
+{
+    uint32_t ret_addrs;
+    asm volatile("mov r0, %0" : : "r" (size));
+    asm volatile("mov r1, %0" : : "r" (file));
+    asm volatile("swi 71");
+    asm volatile("mov %0, r0" : "=r" (ret_addrs));
+
+    return reinterpret_cast<char*>(ret_addrs);
+}
+
 bool sleep(uint32_t ticks, uint32_t notified_deadline)
 {
     uint32_t retcode;