Ticket #15804: mem.cpp

// build cmd: g++ -I "/boot/system/develop/headers/private/system" -I "/boot/system/develop/headers/private/system/arch/x86_64"  mem.cpp -o mem

#include <errno.h>
#include <sys/mman.h>
#include <stdio.h>
#include <string.h>

#include <OS.h>
#include <syscalls.h>

#define CRASH() debugger("crash")
#define UNUSED_PARAM(x) x;

void* reserveUncommitted(size_t bytes, bool writable, bool executable, bool includesGuardPages)
{
    UNUSED_PARAM(writable);
    UNUSED_PARAM(executable);

    addr_t result = 0;
    if (_kern_reserve_address_range(&result, B_ANY_ADDRESS, bytes) != B_OK) {
        fprintf(stderr, "reserveUncommitted: %p, %zu bytes, %s\n", (void*)result, bytes, strerror(errno));
        return NULL;
    }
    fprintf(stderr, "reserveUncommitted: %p, %zu bytes, %s\n", (void*)result, bytes, strerror(errno));
    return (void*)result;
}

void* reserveAndCommit(size_t bytes, bool writable, bool executable, bool includesGuardPages)
{
    // All POSIX reservations start out logically committed.
    int protection = PROT_READ;
    if (writable)
        protection |= PROT_WRITE;
    if (executable)
        protection |= PROT_EXEC;

    int flags = MAP_PRIVATE | MAP_ANON;
    int fd = -1;

    void* result = 0;

    result = mmap(result, bytes, protection, flags, fd, 0);
    if (result == MAP_FAILED) {
        if (executable)
            result = 0;
        else
            CRASH();
    }
    return result;
}

void commit(void* address, size_t bytes, bool writable, bool executable)
{
    int protection = PROT_READ;
    if (writable)
        protection |= PROT_WRITE;
    if (executable)
        protection |= PROT_EXEC;

    int flags = MAP_PRIVATE | MAP_ANON | MAP_FIXED;

    void* effective = mmap(address, bytes, protection, flags, -1, 0);
    fprintf(stderr, "commit: %zu bytes %p %p: %s\n", bytes, address, effective, strerror(errno));
    if (effective != address) {
        if(errno == EINVAL) {
            int result = munmap(address, bytes);
            fprintf(stderr, "commit unmap %d\n", result);
            effective = mmap(address, bytes, protection, flags, -1, 0);
            fprintf(stderr, "commit again: %zu bytes %p %p: %s\n", bytes, address, effective, strerror(errno));
            if(effective == address) {
                return;
            }
        }
        CRASH();
    }
}

void decommit(void* address, size_t bytes)
{
    int result = munmap(address, bytes);
    fprintf(stderr, "decommit: %zu bytes %p %d: %s\n", bytes, address, result, strerror(errno));
    if (result == -1)
        CRASH();
}

void releaseDecommitted(void* address, size_t bytes)
{
    int result = _kern_unreserve_address_range((addr_t)address, bytes);
    fprintf(stderr, "releaseDecommitted: %zu bytes %p %d: %s\n", bytes, address, result, strerror(errno));
    if (result != B_OK)
        CRASH();
}

int main(int argc, char** argv)
{
    void* address = reserveUncommitted(4096*4, false, false, false);
    commit(address, 4096*2, false, false);
    //decommit(address, 4096*2);
    commit(address, 4096*3, false, false);
    return 0;
}