użycie mmap w linuxie

0

Witam
Czy ktoś ma może doświadczenie w używaniu mmap i wie może jakie warunki warto sprawdzić przed użyciem tej metody? Ja wywnioskowałem z googlowania że takie warunki jak przy (*).
Ale być może coś więcej? W moim driverze access może być po słowach 32-bitowych, 16 bitowych jak i 8 bitowych tzn. metoda read może przyjąć argumenty:
read(0+n, zmienna u8,u16,u32)
read(1+n, zmienna u8)
read(2+n, zmienna u8,u16)
read(3+n, zmienna u8)
gdzie n to wielokrotność czwórki

mFd - int
mMem, mBaseAddress (address in bytes unit), mByteSize  - std::uint_32t

RET_CODE MemoryDriver::open(bool isForReadPurpose)
{
    if(mFd != FILE_NOT_OPEN || mMem != nullptr)
    {
        return NOK;
    }

    long pageSize = sysconf(_SC_PAGESIZE);

    //(*)
    if(pageSize <= 0 ||
       0 == (mByteSize) ||
        (mBaseAddress % pageSize) != 0 ||
        ((mByteSize) % sizeof(std::uint32_t)) != 0)
    {
        return NOK;
    }

    mFd = open("/dev/mem", ((isForReadPurpose == true) ? O_RDONLY : O_RDWR) | O_SYNC);

    if(FILE_NOT_OPEN == mFd)
    {
        return NOK;
    }

    mMem = static_cast<std::uint32_t*>(mmap(nullptr, mByteSize,
            (isForReadPurpose == true) ? PROT_READ : PROT_WRITE, MAP_SHARED, mFd, mBaseAddress));

    if (MAP_FAILED == mMem)
    {
        return NOK;
    }

    return OK;
}

void MemoryDriver::close()
{
    if(mMem != nullptr)
    {
        munmap(reinterpret_cast<volatile void *>(m_mem), mByteSize);
        mMem = nullptr;
    }

    if(mFd != FILE_NOT_OPEN)
    {
        close(mFd);
        mFd = FILE_NOT_OPEN;
    }
}

odczyt w postaci:

template<typename T>
void MemoryDriver::read(const std::uint32_t& addrOffset, T& data)
{
    data = *(volatile T*)(mBaseAddress + addrOffset);
}
0

Zwykle rozmiar strony jest znacznie większy niż rozmiar inta i z pewnością jest jego wielokrotnością, więc ostatni warunek nie do końca jest potrzebny.

0

mozesz tylko alokować bloki łatwo o segfault generalnie.

1 użytkowników online, w tym zalogowanych: 0, gości: 1