apps: Add shmem-test

apps/CMakeLists.txt

@@ -45,3 +45,4 @@ luna_app(buffer-test.cpp buffer-test)
 luna_app(socket-test.cpp socket-test)
 luna_app(socket-client.cpp socket-client)
 luna_app(input.cpp input)
+luna_app(shmem-test.cpp shmem-test)

apps/shmem-test.cpp

@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+int main()
+{
+    void* address = mmap(nullptr, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED, -1, 0);
+    if (address == MAP_FAILED)
+    {
+        perror("mmap");
+        return 1;
+    }
+
+    int* ptr = (int*)address;
+    *ptr = 16;
+
+    pid_t child = fork();
+    if (child < 0)
+    {
+        perror("fork");
+        return 1;
+    }
+    if (child == 0)
+    {
+        *ptr = 32;
+        _exit(0);
+    }
+
+    waitpid(child, NULL, 0);
+
+    printf("the value is %d\n", *ptr);
+
+    return 0;
+}

kernel/CMakeLists.txt

@@ -14,6 +14,7 @@ set(SOURCES
     src/memory/KernelVM.cpp
     src/memory/AddressSpace.cpp
     src/memory/MemoryMap.cpp
+    src/memory/SharedMemory.cpp
     src/boot/Init.cpp
     src/arch/Serial.cpp
     src/arch/Timer.cpp

kernel/src/arch/MMU.h

@@ -29,15 +29,15 @@ namespace MMU
 
     u64 translate_physical_address(u64 phys);
 
-    Result<void> map(u64 virt, u64 phys, int flags, UseHugePages use_huge_pages);
-    Result<u64> unmap(u64 virt);
-    Result<u64> get_physical(u64 virt);
-    Result<int> get_flags(u64 virt);
-    Result<void> remap(u64 virt, int flags);
-
     void switch_page_directory(PageDirectory* dir);
     PageDirectory* get_page_directory();
 
+    Result<void> map(u64 virt, u64 phys, int flags, UseHugePages use_huge_pages, PageDirectory* directory = nullptr);
+    Result<u64> unmap(u64 virt, PageDirectory* directory = nullptr);
+    Result<u64> get_physical(u64 virt, PageDirectory* directory = nullptr);
+    Result<int> get_flags(u64 virt, PageDirectory* directory = nullptr);
+    Result<void> remap(u64 virt, int flags);
+
     void flush_all();
 
     Result<PageDirectory*> create_page_directory_for_userspace();

kernel/src/arch/x86_64/MMU.cpp

@@ -110,10 +110,11 @@ namespace MMU
         return result;
     }
 
-    PageTableEntry& l4_entry(u64 virt)
+    PageTableEntry& l4_entry(u64 virt, PageDirectory* directory = nullptr)
     {
         auto index = l4_index(virt);
-        return get_virtual_page_directory()->entries[index];
+        auto* vdir = directory ? translate_physical(directory) : get_virtual_page_directory();
+        return vdir->entries[index];
     }
 
     PageDirectory& page_table(const PageTableEntry& entry)
@@ -139,9 +140,9 @@ namespace MMU
         return page_table(entry).entries[index];
     }
 
-    Result<PageTableEntry*> find_entry(u64 virt)
+    Result<PageTableEntry*> find_entry(u64 virt, PageDirectory* directory = nullptr)
     {
-        const auto& l4 = l4_entry(virt);
+        const auto& l4 = l4_entry(virt, directory);
         if (!l4.present) return err(EFAULT);
         auto& l3 = l3_entry(l4, virt);
         if (!l3.present) return err(EFAULT);
@@ -152,9 +153,9 @@ namespace MMU
         return &l1_entry(l2, virt);
     }
 
-    Result<PageTableEntry*> apply_cascading_flags(u64 virt, int flags)
+    Result<PageTableEntry*> apply_cascading_flags(u64 virt, int flags, PageDirectory* directory = nullptr)
     {
-        auto& l4 = l4_entry(virt);
+        auto& l4 = l4_entry(virt, directory);
         if (!l4.present) return err(EFAULT);
         if (flags & Flags::ReadWrite) l4.read_write = true;
         if (flags & Flags::User) l4.user = true;
@@ -183,9 +184,9 @@ namespace MMU
         entry.set_address(phys);
     }
 
-    Result<void> map(u64 virt, u64 phys, int flags, UseHugePages use_huge_pages)
+    Result<void> map(u64 virt, u64 phys, int flags, UseHugePages use_huge_pages, PageDirectory* directory)
     {
-        auto& l4 = l4_entry(virt);
+        auto& l4 = l4_entry(virt, directory);
         if (!l4.present)
         {
             const u64 addr = TRY(MemoryManager::alloc_frame());
@@ -252,9 +253,9 @@ namespace MMU
         return {};
     }
 
-    Result<u64> unmap(u64 virt)
+    Result<u64> unmap(u64 virt, PageDirectory* directory)
     {
-        auto& l1 = *TRY(find_entry(virt));
+        auto& l1 = *TRY(find_entry(virt, directory));
         if (!l1.present) return err(EFAULT);
         const u64 address = l1.get_address();
         l1.clear();
@@ -262,16 +263,16 @@ namespace MMU
         return address;
     }
 
-    Result<u64> get_physical(u64 virt)
+    Result<u64> get_physical(u64 virt, PageDirectory* directory)
     {
-        const auto& l1 = *TRY(find_entry(virt));
+        const auto& l1 = *TRY(find_entry(virt, directory));
         if (!l1.present) return err(EFAULT);
         return l1.get_address();
     }
 
-    Result<int> get_flags(u64 virt)
+    Result<int> get_flags(u64 virt, PageDirectory* directory)
     {
-        const auto& l1 = *TRY(find_entry(virt));
+        const auto& l1 = *TRY(find_entry(virt, directory));
         if (!l1.present) return err(EFAULT);
         return arch_flags_to_mmu(l1);
     }
@@ -440,12 +441,8 @@ namespace MMU
 
                     for (u64 l = 0; l < 512; l++)
                     {
-                        PageTableEntry& old_l1 = old_pt->entries[l];
-                        if (!old_l1.present) continue;
                         PageTableEntry& new_l1 = new_pt->entries[l];
-                        new_l1.set_address(TRY(MemoryManager::alloc_frame()));
-
-                        memcpy(&page_table(new_l1), &page_table(old_l1), ARCH_PAGE_SIZE);
+                        new_l1.present = false; // The entry must be filled in by the caller.
                     }
                 }
             }

kernel/src/binfmt/ELF.cpp

@@ -3,6 +3,7 @@
 #include "arch/CPU.h"
 #include "arch/MMU.h"
 #include "memory/MemoryManager.h"
+#include <bits/mmap-flags.h>
 #include <luna/Alignment.h>
 #include <luna/Alloc.h>
 #include <luna/CString.h>
@@ -108,8 +109,13 @@ Result<u64> ELFLoader::load(AddressSpace* space)
             if (can_write_segment(program_header.p_flags)) flags |= MMU::ReadWrite;
             if (can_execute_segment(program_header.p_flags)) flags &= ~MMU::NoExecute;
 
+            int prot = PROT_READ;
+            if (can_write_segment(program_header.p_flags)) prot |= PROT_WRITE;
+            if (can_execute_segment(program_header.p_flags)) prot |= PROT_EXEC;
+
             if (!TRY(space->test_and_alloc_region(
-                    base_vaddr, get_blocks_from_size(program_header.p_memsz + vaddr_diff, ARCH_PAGE_SIZE), true)))
+                    base_vaddr, get_blocks_from_size(program_header.p_memsz + vaddr_diff, ARCH_PAGE_SIZE), prot,
+                    MAP_ANONYMOUS | MAP_PRIVATE, 0, true)))
                 return err(ENOMEM);
 
             // Allocate physical memory for the segment

kernel/src/fs/VFS.h

@@ -113,6 +113,11 @@ namespace VFS
         {
         }
 
+        virtual Result<u64> query_shared_memory(off_t, usize)
+        {
+            return err(EACCES);
+        }
+
         // Directory-specific methods
         virtual Result<SharedPtr<Inode>> find(const char* name) const = 0;
 
@@ -186,6 +191,7 @@ namespace VFS
 
       protected:
         mutable InodeMetadata m_metadata;
+        Option<u64> m_shmid {};
     };
 
     class FileInode : public Inode

kernel/src/fs/ext2/Inode.h

@@ -34,6 +34,11 @@ namespace Ext2
         {
         }
 
+        Result<u64> query_shared_memory(off_t, usize) override
+        {
+            return err(ENOTSUP);
+        }
+
         Result<void> set_metadata(const VFS::InodeMetadata&) override
         {
             return err(EROFS);

kernel/src/fs/tmpfs/Inode.cpp

@@ -1,4 +1,6 @@
 #include "fs/tmpfs/Inode.h"
+#include "arch/MMU.h"
+#include "memory/SharedMemory.h"
 
 namespace TmpFS
 {
@@ -127,4 +129,28 @@ namespace TmpFS
 
         return {};
     }
+
+    Result<u64> FileInode::query_shared_memory(off_t offset, usize count)
+    {
+        if (offset + (count * ARCH_PAGE_SIZE) > m_data_buffer.size()) return err(EINVAL);
+
+        if (!m_shmid.has_value())
+        {
+            u64 shmid = TRY(SharedMemory::create(m_data_buffer.data() + offset, offset, count));
+            m_shmid = shmid;
+            return shmid;
+        }
+
+        auto* shm = g_shared_memory_map.try_get_ref(*m_shmid);
+        if (shm->offset > offset)
+        {
+            TRY(shm->grow_backward(m_data_buffer.data() + offset, (shm->offset - offset) / ARCH_PAGE_SIZE));
+        }
+        if (shm->frames.size() < count)
+        {
+            TRY(shm->grow_forward(m_data_buffer.data() + offset + (shm->frames.size() * ARCH_PAGE_SIZE),
+                                  count - shm->frames.size()));
+        }
+        return *m_shmid;
+    }
 }

kernel/src/fs/tmpfs/Inode.h

@@ -33,6 +33,8 @@ namespace TmpFS
 
         Result<void> truncate(usize size) override;
 
+        Result<u64> query_shared_memory(off_t offset, usize count) override;
+
         void did_link() override
         {
             m_metadata.nlinks++;

kernel/src/memory/AddressSpace.cpp

@@ -1,7 +1,9 @@
 #include "memory/AddressSpace.h"
-#include "Log.h"
 #include "arch/MMU.h"
 #include "memory/Heap.h"
+#include "memory/MemoryManager.h"
+#include "memory/SharedMemory.h"
+#include <bits/mmap-flags.h>
 #include <luna/CString.h>
 #include <luna/ScopeGuard.h>
 
@@ -49,14 +51,25 @@ Result<OwnedPtr<AddressSpace>> AddressSpace::clone()
 {
     OwnedPtr<AddressSpace> ptr = TRY(make_owned<AddressSpace>());
 
+    ptr->m_directory = TRY(MMU::clone_userspace_page_directory(m_directory));
+
     for (const auto* region : m_regions)
     {
         auto* new_region = TRY(make<VMRegion>());
         memcpy(new_region, region, sizeof(*region));
         ptr->m_regions.append(new_region);
-    }
 
-    ptr->m_directory = TRY(MMU::clone_userspace_page_directory(m_directory));
+        if (new_region->used && new_region->prot != 0 && new_region->flags & MAP_SHARED)
+        {
+            TRY(MemoryManager::copy_region(new_region->start, new_region->count, m_directory, ptr->m_directory));
+            auto* shm = g_shared_memory_map.try_get_ref(new_region->shmid);
+            if (shm) shm->refs++;
+        }
+        else if (new_region->used && new_region->prot != 0)
+        {
+            TRY(MemoryManager::copy_region_data(new_region->start, new_region->count, m_directory, ptr->m_directory));
+        }
+    }
 
     return move(ptr);
 }
@@ -81,8 +94,16 @@ AddressSpace& AddressSpace::operator=(AddressSpace&& other)
     return *this;
 }
 
-Result<u64> AddressSpace::alloc_region(usize count, bool persistent)
+Result<u64> AddressSpace::alloc_region(usize count, int prot, int flags, u64 shmid, bool persistent)
 {
+    auto update_region = [=](VMRegion* region) {
+        region->used = true;
+        region->persistent = persistent;
+        region->prot = prot;
+        region->flags = flags;
+        region->shmid = shmid;
+    };
+
     for (auto* region = m_regions.expect_last(); region; region = m_regions.previous(region).value_or(nullptr))
     {
         if (!region->used)
@@ -90,8 +111,7 @@ Result<u64> AddressSpace::alloc_region(usize count, bool persistent)
             if (region->count < count) continue;
             if (region->count == count)
             {
-                region->used = true;
-                region->persistent = persistent;
+                update_region(region);
                 u64 address = region->start;
                 try_merge_region_with_neighbors(region);
                 return address;
@@ -100,8 +120,7 @@ Result<u64> AddressSpace::alloc_region(usize count, bool persistent)
             u64 boundary = region->end - (count * ARCH_PAGE_SIZE);
 
             auto* new_region = TRY(split_region(region, boundary));
-            new_region->used = true;
-            new_region->persistent = persistent;
+            update_region(new_region);
             try_merge_region_with_neighbors(new_region);
 
             return boundary;
@@ -111,12 +130,22 @@ Result<u64> AddressSpace::alloc_region(usize count, bool persistent)
     return err(ENOMEM);
 }
 
-Result<bool> AddressSpace::set_region(u64 address, usize count, bool used, bool persistent)
+Result<bool> AddressSpace::set_region(u64 address, usize count, bool used, int prot, int flags, u64 shmid,
+                                      bool persistent)
 {
     if (address >= VM_END) return err(EINVAL);
 
     u64 end = address + (count * ARCH_PAGE_SIZE);
 
+    auto update_region = [=](VMRegion* region) {
+        if (!used) region->cleanup_shared();
+        region->used = used;
+        region->persistent = persistent;
+        region->prot = prot;
+        region->flags = flags;
+        region->shmid = shmid;
+    };
+
     for (auto* region : m_regions)
     {
         if (region->end < address) continue;
@@ -131,13 +160,13 @@ Result<bool> AddressSpace::set_region(u64 address, usize count, bool used, bool
 
         if (region->start >= address && region->end <= end)
         {
-            region->used = used;
-            region->persistent = persistent;
+            update_region(region);
             if (region->start == address && region->end == end)
             {
                 try_merge_region_with_neighbors(region);
                 return true;
             }
+            try_merge_region_with_neighbors(region);
             continue;
         }
 
@@ -145,8 +174,7 @@ Result<bool> AddressSpace::set_region(u64 address, usize count, bool used, bool
         {
             auto* middle_region = TRY(split_region(region, address));
             TRY(split_region(middle_region, end));
-            middle_region->used = used;
-            middle_region->persistent = persistent;
+            update_region(middle_region);
             return true;
         }
 
@@ -154,8 +182,7 @@ Result<bool> AddressSpace::set_region(u64 address, usize count, bool used, bool
         {
             bool finished = region->end == end;
             auto* split = TRY(split_region(region, address));
-            split->used = used;
-            split->persistent = persistent;
+            update_region(split);
             try_merge_region_with_neighbors(split);
             if (!finished) continue;
             return true;
@@ -164,8 +191,7 @@ Result<bool> AddressSpace::set_region(u64 address, usize count, bool used, bool
         if (region->end > end)
         {
             TRY(split_region(region, end));
-            region->used = used;
-            region->persistent = persistent;
+            update_region(region);
             try_merge_region_with_neighbors(region);
             return true;
         }
@@ -184,18 +210,24 @@ void AddressSpace::merge_contiguous_regions(VMRegion* a, VMRegion* b)
 
 void AddressSpace::try_merge_region_with_neighbors(VMRegion* region)
 {
+    auto equals = [](VMRegion* a, VMRegion* b) {
+        if (a->used != b->used) return false;
+        if (a->persistent != b->persistent) return false;
+        if (a->prot != b->prot) return false;
+        if (a->flags != b->flags) return false;
+        if (a->shmid != b->shmid) return false;
+        return true;
+    };
+
     auto prev = m_regions.previous(region);
-    if (prev.has_value() && (*prev)->used == region->used && (*prev)->persistent == region->persistent)
+    if (prev.has_value() && equals(*prev, region))
     {
         merge_contiguous_regions(*prev, region);
         region = *prev;
     }
 
     auto next = m_regions.next(region);
-    if (next.has_value() && (*next)->used == region->used && (*next)->persistent == region->persistent)
-    {
-        merge_contiguous_regions(region, *next);
-    }
+    if (next.has_value() && equals(*next, region)) { merge_contiguous_regions(region, *next); }
 }
 
 Result<VMRegion*> AddressSpace::split_region(VMRegion* parent, u64 boundary)
@@ -207,6 +239,9 @@ Result<VMRegion*> AddressSpace::split_region(VMRegion* parent, u64 boundary)
     region->count = (region->end - region->start) / ARCH_PAGE_SIZE;
     region->used = parent->used;
     region->persistent = parent->persistent;
+    region->prot = parent->prot;
+    region->flags = parent->flags;
+    region->shmid = parent->shmid;
     m_regions.add_after(parent, region);
 
     parent->end = boundary;
@@ -217,6 +252,30 @@ Result<VMRegion*> AddressSpace::split_region(VMRegion* parent, u64 boundary)
 
 AddressSpace::~AddressSpace()
 {
-    m_regions.consume([](VMRegion* region) { delete region; });
+    auto* directory = MMU::get_page_directory();
+    MMU::switch_page_directory(this->m_directory);
+    m_regions.consume([this](VMRegion* region) {
+        region->cleanup_shared();
+        delete region;
+    });
+    MMU::switch_page_directory(directory);
+
     if (m_directory) MMU::delete_userspace_page_directory(m_directory);
 }
+
+void VMRegion::cleanup_shared()
+{
+    if (used && (flags & MAP_SHARED))
+    {
+        SharedMemory* shmem = g_shared_memory_map.try_get_ref(shmid);
+        if (shmem)
+        {
+            for (u64 addr = start; addr < end; addr += ARCH_PAGE_SIZE) { MMU::unmap(addr); }
+            if (--shmem->refs == 0)
+            {
+                shmem->free();
+                g_shared_memory_map.try_remove(shmid);
+            }
+        }
+    }
+}

kernel/src/memory/AddressSpace.h

@@ -12,6 +12,11 @@ class VMRegion : LinkedListNode<VMRegion>
     usize count;
     bool used { true };
     bool persistent { false };
+    int flags { 0 };
+    int prot { 0 };
+    u64 shmid;
+
+    void cleanup_shared();
 };
 
 class AddressSpace
@@ -22,16 +27,17 @@ class AddressSpace
 
     AddressSpace& operator=(AddressSpace&& other);
 
-    Result<u64> alloc_region(usize count, bool persistent = false);
+    Result<u64> alloc_region(usize count, int prot, int flags, u64 shmid = 0, bool persistent = false);
 
-    Result<bool> test_and_alloc_region(u64 address, usize count, bool persistent = false)
+    Result<bool> test_and_alloc_region(u64 address, usize count, int prot, int flags, u64 shmid = 0,
+                                       bool persistent = false)
     {
-        return set_region(address, count, true, persistent);
+        return set_region(address, count, true, prot, flags, shmid, persistent);
     }
 
     Result<bool> free_region(u64 address, usize count)
     {
-        return set_region(address, count, false, false);
+        return set_region(address, count, false, 0, 0, 0, false);
     }
 
     static Result<OwnedPtr<AddressSpace>> try_create();
@@ -44,7 +50,7 @@ class AddressSpace
     }
 
   private:
-    Result<bool> set_region(u64 address, usize count, bool used, bool persistent);
+    Result<bool> set_region(u64 address, usize count, bool used, int prot, int flags, u64 shmid, bool persistent);
     Result<void> create_default_region();
     Result<void> create_null_region();
     void try_merge_region_with_neighbors(VMRegion* region);

kernel/src/memory/MemoryManager.cpp

@@ -1,4 +1,5 @@
 #include "memory/MemoryManager.h"
+#include "Log.h"
 #include "arch/MMU.h"
 #include "memory/KernelVM.h"
 #include "memory/MemoryMap.h"
@@ -226,6 +227,57 @@ namespace MemoryManager
         return {};
     }
 
+    Result<void> copy_region(u64 virt, usize count, PageDirectory* oldpd, PageDirectory* newpd)
+    {
+        CHECK_PAGE_ALIGNED(virt);
+
+        usize pages_mapped = 0;
+
+        // Let's clean up after ourselves if we fail.
+        auto guard = make_scope_guard(
+            [=, &pages_mapped] { kwarnln("copy_region failed, sorry! cannot reclaim already copied pages"); });
+
+        while (pages_mapped < count)
+        {
+            u64 phys = TRY(MMU::get_physical(virt, oldpd));
+            int flags = TRY(MMU::get_flags(virt, oldpd));
+            TRY(MMU::map(virt, phys, flags, MMU::UseHugePages::No, newpd));
+            virt += ARCH_PAGE_SIZE;
+            pages_mapped++;
+        }
+
+        guard.deactivate();
+
+        return {};
+    }
+
+    Result<void> copy_region_data(u64 virt, usize count, PageDirectory* oldpd, PageDirectory* newpd)
+    {
+        CHECK_PAGE_ALIGNED(virt);
+
+        usize pages_mapped = 0;
+
+        // Let's clean up after ourselves if we fail.
+        auto guard = make_scope_guard(
+            [=, &pages_mapped] { kwarnln("copy_region_data failed, sorry! cannot reclaim already copied pages"); });
+
+        while (pages_mapped < count)
+        {
+            u64 frame = TRY(alloc_frame());
+            u64 phys = TRY(MMU::get_physical(virt, oldpd));
+            int flags = TRY(MMU::get_flags(virt, oldpd));
+            memcpy((void*)MMU::translate_physical_address(frame), (void*)MMU::translate_physical_address(phys),
+                   ARCH_PAGE_SIZE);
+            TRY(MMU::map(virt, frame, flags, MMU::UseHugePages::No, newpd));
+            virt += ARCH_PAGE_SIZE;
+            pages_mapped++;
+        }
+
+        guard.deactivate();
+
+        return {};
+    }
+
     Result<void> map_huge_frames_at(u64 virt, u64 phys, usize count, int flags)
     {
         CHECK_PAGE_ALIGNED(virt);
@@ -358,6 +410,20 @@ namespace MemoryManager
         return {};
     }
 
+    Result<void> unmap_owned_if_possible(u64 virt, usize count)
+    {
+        CHECK_PAGE_ALIGNED(virt);
+
+        while (count--)
+        {
+            const auto frame = MMU::unmap(virt);
+            if (frame.has_value()) TRY(free_frame(frame.value()));
+            virt += ARCH_PAGE_SIZE;
+        }
+
+        return {};
+    }
+
     Result<void> unmap_owned_and_free_vm(u64 virt, usize count)
     {
         CHECK_PAGE_ALIGNED(virt);

kernel/src/memory/MemoryManager.h

@@ -67,6 +67,9 @@ namespace MemoryManager
     Result<void> map_frames_at(u64 virt, u64 phys, usize count, int flags);
     Result<void> map_huge_frames_at(u64 virt, u64 phys, usize count, int flags);
 
+    Result<void> copy_region(u64 virt, usize count, PageDirectory* oldpd, PageDirectory* newpd);
+    Result<void> copy_region_data(u64 virt, usize count, PageDirectory* oldpd, PageDirectory* newpd);
+
     Result<u64> alloc_at(u64 virt, usize count, int flags);
     Result<u64> alloc_at_zeroed(u64, usize count, int flags);
     Result<u64> alloc_for_kernel(usize count, int flags);
@@ -75,6 +78,7 @@ namespace MemoryManager
 
     Result<void> unmap_owned(u64 virt, usize count);
     Result<void> unmap_owned_and_free_vm(u64 virt, usize count);
+    Result<void> unmap_owned_if_possible(u64 virt, usize count);
     Result<void> unmap_weak(u64 virt, usize count);
     Result<void> unmap_weak_and_free_vm(u64 virt, usize count);
 

kernel/src/memory/SharedMemory.cpp

@@ -0,0 +1,120 @@
+#include "memory/SharedMemory.h"
+#include "memory/MemoryManager.h"
+#include <bits/mmap-flags.h>
+#include <luna/ScopeGuard.h>
+
+HashMap<u64, SharedMemory> g_shared_memory_map;
+Atomic<u64> g_next_shmem_id;
+
+Result<u64> SharedMemory::create(u8* mem, off_t offset, usize count)
+{
+    SharedMemory shmem;
+    shmem.offset = offset;
+
+    auto guard = make_scope_guard([&shmem] {
+        for (u64 frame : shmem.frames) { MemoryManager::free_frame(frame); }
+    });
+
+    while (count--)
+    {
+        u64 frame = TRY(MemoryManager::alloc_frame());
+        TRY(shmem.frames.try_append(frame));
+        if (mem)
+        {
+            memcpy((void*)MMU::translate_physical_address(frame), mem, ARCH_PAGE_SIZE);
+            mem += ARCH_PAGE_SIZE;
+        }
+        else { memset((void*)MMU::translate_physical_address(frame), 0, ARCH_PAGE_SIZE); }
+    }
+
+    const u64 id = g_next_shmem_id++;
+
+    check(TRY(g_shared_memory_map.try_set(id, move(shmem))));
+
+    guard.deactivate();
+
+    return id;
+}
+
+Result<void> SharedMemory::grow_forward(u8* mem, usize count)
+{
+    u64 old_count = frames.size();
+
+    auto guard = make_scope_guard([old_count, this] {
+        while (old_count < this->frames.size()) { MemoryManager::free_frame(*this->frames.try_pop()); }
+    });
+
+    while (count--)
+    {
+        u64 frame = TRY(MemoryManager::alloc_frame());
+        TRY(frames.try_append(frame));
+        if (mem)
+        {
+            memcpy((void*)MMU::translate_physical_address(frame), mem, ARCH_PAGE_SIZE);
+            mem += ARCH_PAGE_SIZE;
+        }
+    }
+
+    guard.deactivate();
+
+    return {};
+}
+
+Result<void> SharedMemory::grow_backward(u8* mem, usize count)
+{
+    Vector<u64> new_frames;
+
+    const usize bytes = count * ARCH_PAGE_SIZE;
+
+    auto guard = make_scope_guard([&new_frames, count] {
+        for (u64 i = 0; i < count && i < new_frames.size(); i++) { MemoryManager::free_frame(new_frames[i]); }
+    });
+
+    while (count--)
+    {
+        u64 frame = TRY(MemoryManager::alloc_frame());
+        TRY(new_frames.try_append(frame));
+        if (mem)
+        {
+            memcpy((void*)MMU::translate_physical_address(frame), mem, ARCH_PAGE_SIZE);
+            mem += ARCH_PAGE_SIZE;
+        }
+    }
+
+    for (u64 frame : frames) { TRY(new_frames.try_append(frame)); }
+
+    frames = move(new_frames);
+    offset -= bytes;
+
+    guard.deactivate();
+
+    return {};
+}
+
+Result<void> SharedMemory::map(u64 virt, int flags, off_t _offset, usize count)
+{
+    usize off = _offset / ARCH_PAGE_SIZE;
+    if (off + count > frames.size()) return err(EINVAL);
+
+    for (usize i = off; i < count; i++)
+    {
+        TRY(MMU::map(virt, frames[i], flags, MMU::UseHugePages::No));
+        virt += ARCH_PAGE_SIZE;
+    }
+
+    return {};
+}
+
+void SharedMemory::free()
+{
+    if (inode && (prot & PROT_WRITE))
+    {
+        for (u64 i = 0; i < frames.size(); i++)
+        {
+            inode->write((u8*)MMU::translate_physical_address(frames[i]), offset + (i * ARCH_PAGE_SIZE),
+                         ARCH_PAGE_SIZE);
+        }
+    }
+
+    for (u64 frame : frames) { MemoryManager::free_frame(frame); }
+}

kernel/src/memory/SharedMemory.h

@@ -0,0 +1,25 @@
+#pragma once
+#include "fs/VFS.h"
+#include <luna/HashMap.h>
+#include <luna/Vector.h>
+#include <sys/types.h>
+
+struct SharedMemory
+{
+    Vector<u64> frames;
+    off_t offset;
+    int prot;
+    SharedPtr<VFS::Inode> inode {};
+    int refs { 0 };
+
+    static Result<u64> create(u8* mem, off_t offset, usize count);
+
+    Result<void> grow_forward(u8* mem, usize count);
+    Result<void> grow_backward(u8* mem, usize count);
+
+    Result<void> map(u64 virt, int flags, off_t offset, usize count);
+
+    void free();
+};
+
+extern HashMap<u64, SharedMemory> g_shared_memory_map;

kernel/src/sys/mmap.cpp

@@ -1,62 +1,90 @@
 #include "Log.h"
 #include "arch/MMU.h"
 #include "memory/MemoryManager.h"
+#include "memory/SharedMemory.h"
 #include "sys/Syscall.h"
 #include "thread/Scheduler.h"
 #include <bits/mmap-flags.h>
+#include <bits/mmap.h>
+#include <bits/open-flags.h>
 #include <luna/Alignment.h>
 
 constexpr uintptr_t USERSPACE_HEAP_BASE = 0x3000000;
 
 Result<u64> sys_mmap(Registers*, SyscallArgs args)
 {
-    void* addr = (void*)args[0];
-    usize len = (usize)args[1];
-    int prot = (int)args[2];
-    int flags = (int)args[3];
+    mmap_params params;
+    if (!MemoryManager::copy_from_user_typed((const mmap_params*)args[0], &params)) return err(EFAULT);
 
-    if (len == 0) return err(EINVAL);
+    kdbgln("mmap: address=%p, len=%zu, prot=%d, flags=%d, fd=%d, offset=%lu", params.addr, params.len, params.prot,
+           params.flags, params.fd, params.offset);
 
-    if (flags < 0) return err(EINVAL);
+    if (params.len == 0) return err(EINVAL);
 
-    // We support only anonymous mappings for now.
-    if ((flags & MAP_ANONYMOUS) != MAP_ANONYMOUS)
-    {
-        kwarnln("mmap: FIXME: attempt to mmap file instead of anonymous memory");
-        return err(ENOTSUP);
-    }
-
-    if (flags & MAP_SHARED)
-    {
-        kwarnln("mmap: FIXME: attempt to mmap shared memory");
-        return err(ENOTSUP);
-    }
-
-    len = align_up<ARCH_PAGE_SIZE>(len);
+    if (params.flags < 0) return err(EINVAL);
 
     Thread* current = Scheduler::current();
 
+    SharedPtr<OpenFileDescription> description;
+    if ((params.flags & MAP_ANONYMOUS) != MAP_ANONYMOUS)
+    {
+        description = TRY(current->resolve_fd(params.fd))->description;
+        if (!(description->flags & O_RDONLY)) return err(EACCES);
+        if (description->flags & O_APPEND) return err(EACCES);
+    }
+
+    if (!is_aligned<ARCH_PAGE_SIZE>(params.offset)) return err(EINVAL);
+
+    params.len = align_up<ARCH_PAGE_SIZE>(params.len);
+
+    SharedMemory* shmem = nullptr;
+    u64 shmid = 0;
+    if (params.flags & MAP_SHARED)
+    {
+        if (!description)
+        {
+            params.offset = 0;
+            shmid = TRY(SharedMemory::create(nullptr, 0, params.len / ARCH_PAGE_SIZE));
+        }
+        else
+        {
+            if ((params.prot & PROT_WRITE) && !(description->flags & O_WRONLY)) return err(EACCES);
+            shmid = TRY(description->inode->query_shared_memory(params.offset, params.len));
+        }
+        shmem = g_shared_memory_map.try_get_ref(shmid);
+        shmem->refs++;
+    }
+
     u64 address;
-    if (!addr) address = TRY(current->address_space->alloc_region(get_blocks_from_size(len, ARCH_PAGE_SIZE)));
+    if (!params.addr)
+        address = TRY(current->address_space->alloc_region(get_blocks_from_size(params.len, ARCH_PAGE_SIZE),
+                                                           params.prot, params.flags, shmid));
     else
     {
         // FIXME: We should be more flexible if MAP_FIXED was not specified.
-        address = align_down<ARCH_PAGE_SIZE>((u64)addr);
-        if (!TRY(current->address_space->test_and_alloc_region(address, get_blocks_from_size(len, ARCH_PAGE_SIZE))))
+        address = align_down<ARCH_PAGE_SIZE>((u64)params.addr);
+        if (!TRY(current->address_space->test_and_alloc_region(
+                address, get_blocks_from_size(params.len, ARCH_PAGE_SIZE), params.prot, params.flags, shmid)))
             return err(ENOMEM);
     }
 
     int mmu_flags = MMU::User | MMU::NoExecute;
-    if (prot & PROT_WRITE) mmu_flags |= MMU::ReadWrite;
-    if (prot & PROT_EXEC) mmu_flags &= ~MMU::NoExecute;
-    if (prot == PROT_NONE) mmu_flags = MMU::NoExecute;
+    if (params.prot & PROT_WRITE) mmu_flags |= MMU::ReadWrite;
+    if (params.prot & PROT_EXEC) mmu_flags &= ~MMU::NoExecute;
+    if (params.prot == PROT_NONE) mmu_flags = MMU::NoExecute;
 
 #ifdef MMAP_DEBUG
     kdbgln("mmap: mapping memory at %#lx, size=%zu", address, len);
 #endif
 
-    // FIXME: This leaks VM if it fails.
-    return MemoryManager::alloc_at_zeroed(address, get_blocks_from_size(len, ARCH_PAGE_SIZE), mmu_flags);
+    if (shmem) { TRY(shmem->map(address, mmu_flags, params.offset, get_blocks_from_size(params.len, ARCH_PAGE_SIZE))); }
+    else
+    {
+        TRY(MemoryManager::alloc_at_zeroed(address, get_blocks_from_size(params.len, ARCH_PAGE_SIZE), mmu_flags));
+        if (description) { TRY(description->inode->read((u8*)address, params.offset, params.len)); }
+    }
+
+    return address;
 }
 
 Result<u64> sys_munmap(Registers*, SyscallArgs args)
@@ -78,7 +106,7 @@ Result<u64> sys_munmap(Registers*, SyscallArgs args)
     kdbgln("munmap: unmapping memory at %#lx, size=%zu", address, size);
 #endif
 
-    TRY(MemoryManager::unmap_owned(address, get_blocks_from_size(size, ARCH_PAGE_SIZE)));
+    TRY(MemoryManager::unmap_owned_if_possible(address, get_blocks_from_size(size, ARCH_PAGE_SIZE)));
 
     return { 0 };
 }

kernel/src/thread/ThreadImage.cpp

@@ -1,6 +1,7 @@
 #include "thread/ThreadImage.h"
 #include "memory/MemoryManager.h"
 #include "thread/Thread.h"
+#include <bits/mmap-flags.h>
 #include <luna/Alignment.h>
 #include <luna/CString.h>
 
@@ -15,7 +16,9 @@ static Result<void> create_user_stack(Stack& user_stack, AddressSpace* space)
 
     auto guard = make_scope_guard([] { MemoryManager::unmap_owned(THREAD_STACK_BASE, DEFAULT_USER_STACK_PAGES); });
 
-    if (!TRY(space->test_and_alloc_region(THREAD_STACK_BASE, DEFAULT_USER_STACK_PAGES, true))) return err(ENOMEM);
+    if (!TRY(space->test_and_alloc_region(THREAD_STACK_BASE, DEFAULT_USER_STACK_PAGES, PROT_READ | PROT_WRITE,
+                                          MAP_ANONYMOUS | MAP_PRIVATE, 0, true)))
+        return err(ENOMEM);
 
     guard.deactivate();
 

libc/include/bits/mmap.h

@@ -0,0 +1,13 @@
+#pragma once
+#include <stdint.h>
+#include <sys/types.h>
+
+struct mmap_params
+{
+    void* addr;
+    size_t len;
+    int prot;
+    int flags;
+    int fd;
+    off_t offset;
+};

libc/src/sys/mman.cpp

@@ -1,4 +1,5 @@
 #include <bits/errno-return.h>
+#include <bits/mmap.h>
 #include <luna/Heap.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
@@ -6,9 +7,10 @@
 
 extern "C"
 {
-    void* mmap(void* addr, size_t len, int prot, int flags, int, off_t)
+    void* mmap(void* addr, size_t len, int prot, int flags, int fd, off_t offset)
     {
-        long rc = syscall(SYS_mmap, addr, len, prot, flags);
+        const mmap_params params { addr, len, prot, flags, fd, offset };
+        long rc = syscall(SYS_mmap, &params);
         __errno_return(rc, void*);
     }
 

libluna/include/luna/HashMap.h

@@ -20,6 +20,11 @@ template <typename K, typename V> u64 hash(const HashPair<K, V>& value, u64 salt
 template <typename K, typename V> struct HashMap
 {
   public:
+    Result<bool> try_set(const K& key, V&& value)
+    {
+        return m_table.try_set(HashPair<K, V> { key, move(value) });
+    }
+
     Result<bool> try_set(const K& key, const V& value)
     {
         return m_table.try_set(HashPair<K, V> { key, value });