mman.hxx

Go to the documentation of this file.

#pragma once
 
// C++
#include <optional>
 
// Linux
#include <sys/mman.h>
#include <linux/mman.h> // also pull in kernel header for MAP_UNINITIALIZED
 
// libcosmos
#include <cosmos/BitMask.hxx>
#include <cosmos/fs/FileDescriptor.hxx>
 
namespace cosmos::mem {
 
enum class MapType : int {
        SHARED          = MAP_SHARED,
        SHARED_VALIDATE = MAP_SHARED_VALIDATE,
        PRIVATE         = MAP_PRIVATE
};
enum class MapType : int {…};
 
// this constant hasn't made it into userspace headers yet it seems
#ifndef PROT_SAO
#       define PROT_SAO   0x10
#endif
 
enum class AccessFlag : int {
        EXEC  = PROT_EXEC,  
        READ  = PROT_READ,  
        WRITE = PROT_WRITE, 
        NONE  = PROT_NONE,  
        SEM   = PROT_SEM,   
        SAO   = PROT_SAO,   
};
enum class AccessFlag : int {…};
 
using AccessFlags = BitMask<AccessFlag>;
 
enum class MapFlag : int {
#ifdef MAP_32BIT // this is not defined on non-x86 architectures?
 
        INTO_32BIT      = MAP_32BIT,
#endif
 
        ANONYMOUS       = MAP_ANONYMOUS,
        FIXED           = MAP_FIXED,
        FIXED_NOREPLACE = MAP_FIXED_NOREPLACE,
        GROWSDOWN       = MAP_GROWSDOWN,
        HUGETLB         = MAP_HUGETLB,
        LOCKED          = MAP_LOCKED,
        NONBLOCK        = MAP_NONBLOCK,
 
        NORESERVE       = MAP_NORESERVE,
 
        POPULATE        = MAP_POPULATE,
        STACK           = MAP_STACK,
 
        SYNC            = MAP_SYNC,
 
        UNINITIALIZED   = MAP_UNINITIALIZED,
};
enum class MapFlag : int {…};
 
class COSMOS_API MapFlags :
                public BitMask<MapFlag> {
public:
        using BitMask<MapFlag>::BitMask;
 
 
        void setTLBPageSize(size_t page_size);
};
class COSMOS_API MapFlags : {…};
 
struct MapSettings {
        MapType type;
        AccessFlags access;
        MapFlags flags = {};
        off_t offset = 0;       
        FileDescriptor fd = {}; 
        void *addr = nullptr;   
};
struct MapSettings {…};
 
 
COSMOS_API void* map(const size_t length, const MapSettings &settings);
 
 
COSMOS_API void unmap(void *addr, const size_t length);
 
 
 
enum class ProtectFlag : int {
        GROWSUP   = PROT_GROWSUP,   
        GROWSDOWN = PROT_GROWSDOWN, 
};
enum class ProtectFlag : int {…};
 
using ProtectFlags = BitMask<ProtectFlag>;
 
 
COSMOS_API void protect(void *addr, const size_t length, const AccessFlags flags, const ProtectFlags extra = {});
 
 
 
enum class RemapFlag : int {
        MAYMOVE   = MREMAP_MAYMOVE,   
        FIXED     = MREMAP_FIXED,     
        DONTUNMAP = MREMAP_DONTUNMAP, 
};
enum class RemapFlag : int {…};
 
using RemapFlags = BitMask<RemapFlag>;
 
 
COSMOS_API void* remap(void *old_addr, const size_t old_size, const size_t new_size,
                const RemapFlags flags = {}, std::optional<void*> new_addr = {});
 
 
 
 
enum class SyncFlag : int {
        ASYNC      = MS_ASYNC, 
        SYNC       = MS_SYNC,  
        INVALIDATE = MS_INVALIDATE 
};
enum class SyncFlag : int {…};
 
using SyncFlags = BitMask<SyncFlag>;
 
 
COSMOS_API void sync(void *addr, const size_t length,
                const SyncFlags flags = SyncFlags{SyncFlag::SYNC});
 
 
 
enum class LockFlag : unsigned int {
        LOCK_ON_FAULT = MLOCK_ONFAULT, 
};
enum class LockFlag : unsigned int {…};
 
using LockFlags = BitMask<LockFlag>;
 
 
COSMOS_API void lock(void *addr, const size_t length, const LockFlags flags = {});
 
 
COSMOS_API void unlock(void *addr, const size_t length);
 
 
 
enum class LockAllFlag : int {
        CURRENT = MCL_CURRENT, 
        FUTURE  = MCL_FUTURE,  
        ONFAULT = MCL_ONFAULT, 
};
enum class LockAllFlag : int {…};
 
using LockAllFlags = BitMask<LockAllFlag>;
 
 
COSMOS_API void lock_all(const LockAllFlags flags);
 
 
COSMOS_API void unlock_all();
 
} // end ns