posix_shm.h

Go to the documentation of this file.

 
#pragma once
#include <string>
#include <stdexcept>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstring>
#include <atomic>
#include <cerrno>
#include "shm_table.h"
 
template<typename TableType = shm_table>
class posix_shm_impl
{
private:
    struct header
    {
        std::atomic<int> ref_count;  
        TableType table;              
 
        void inc()
        {
            ref_count.fetch_add(1, std::memory_order_relaxed);
        }
 
        int dec()
        {
            return ref_count.fetch_sub(1, std::memory_order_release) - 1;
        }
    };
 
    void *base_addr;     
    size_t total_size;   
    std::string name;    
    int fd;             
    header *hdr;        
 
public:
    posix_shm_impl(const std::string &name, size_t size = 0)
        : name(name), total_size(size + sizeof(header))
    {
        bool created = false;
        
        if (size == 0) {
            // Size 0 means attach to existing only
            fd = shm_open(name.c_str(), O_RDWR, 0666);
            if (fd == -1)
            {
                throw std::runtime_error("Failed to open existing shared memory: " + std::string(strerror(errno)));
            }
            // Need to get the actual size
            struct stat sb;
            if (fstat(fd, &sb) == -1) {
                close(fd);
                throw std::runtime_error("Failed to get shared memory size: " + std::string(strerror(errno)));
            }
            total_size = sb.st_size;
        }
        else {
            // Size > 0 means create new or attach to existing
            fd = shm_open(name.c_str(), O_CREAT | O_EXCL | O_RDWR, 0666);
            if (fd == -1)
            {
                if (errno == EEXIST)
                {
                    fd = shm_open(name.c_str(), O_RDWR, 0666);
                    if (fd == -1)
                    {
                        throw std::runtime_error("Failed to open existing shared memory: " + std::string(strerror(errno)));
                    }
                }
                else
                {
                    throw std::runtime_error("Failed to create shared memory: " + std::string(strerror(errno)));
                }
            }
            else
            {
                created = true;
            }
        }
 
        if (created && ftruncate(fd, total_size) == -1)
        {
            close(fd);
            shm_unlink(name.c_str());
            throw std::runtime_error("Failed to set size of shared memory: " + std::string(strerror(errno)));
        }
 
        base_addr = mmap(NULL, total_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
        if (base_addr == MAP_FAILED)
        {
            close(fd);
            if (created)
                shm_unlink(name.c_str());
            throw std::runtime_error("Failed to map shared memory: " + std::string(strerror(errno)));
        }
 
        hdr = static_cast<header *>(base_addr);
        if (created)
        {
            // Initialize header with reference count 1 and empty table
            new (hdr) header{{1}, TableType{}};
        }
        else
        {
            hdr->inc();
        }
    }
 
    ~posix_shm_impl()
    {
        hdr->dec();
        munmap(base_addr, total_size);
        close(fd);
    }
 
    void *get_base_addr() const
    {
        return &hdr->table;
    }
 
    size_t get_total_size() const
    {
        return total_size - sizeof(header);
    }
 
    TableType* get_table()
    {
        return &hdr->table;
    }
 
    const TableType* get_table() const
    {
        return &hdr->table;
    }
 
    int get_ref_count() const
    {
        return hdr->ref_count.load(std::memory_order_acquire);
    }
 
    bool unlink()
    {
        if (shm_unlink(name.c_str()) == -1)
        {
            return false;
        }
        return true;
    }
 
    posix_shm_impl(const posix_shm_impl &) = delete;
    
    posix_shm_impl &operator=(const posix_shm_impl &) = delete;
 
    using table_type = TableType;
};
 
using posix_shm = posix_shm_impl<shm_table>;
 
using posix_shm_small = posix_shm_impl<shm_table_small>;
 
using posix_shm_large = posix_shm_impl<shm_table_large>;
 
using posix_shm_huge = posix_shm_impl<shm_table_huge>;