/*
 * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include <sys/mman.h>

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <pthread.h>

#include <OS.h>

#include <runtime_loader/runtime_loader.h>
#include <errno_private.h>
#include <syscall_utils.h>
#include <syscalls.h>
#include <vm_defs.h>


static const char* kSharedMemoryDir = "/var/shared_memory/";


static bool
append_string(char*& path, size_t& bytesLeft, const char* toAppend, size_t size)
{
        if (bytesLeft <= size)
                return false;

        memcpy(path, toAppend, size);
        path += size;
        path[0] = '\0';
        bytesLeft -= size;

        return true;
}


static bool
append_string(char*& path, size_t& bytesLeft, const char* toAppend)
{
        return append_string(path, bytesLeft, toAppend, strlen(toAppend));
}


static status_t
shm_name_to_path(const char* name, char* path, size_t pathSize)
{
        if (name == NULL)
                return B_BAD_VALUE;

        // skip leading slashes
        while (*name == '/')
                name++;

        if (*name == '\0')
                return B_BAD_VALUE;

        // create the path; replace occurrences of '/' by "%s" and '%' by "%%"
        if (!append_string(path, pathSize, kSharedMemoryDir))
                return ENAMETOOLONG;

        while (const char* found = strpbrk(name, "%/")) {
                // append section that doesn't need escaping
                if (found != name) {
                        if (!append_string(path, pathSize, name, found - name))
                                return ENAMETOOLONG;
                }

                // append escaped char
                const char* append = (*found == '%' ? "%%" : "%s");
                if (!append_string(path, pathSize, append, 2))
                        return ENAMETOOLONG;
                name = found + 1;
        }

        // append remaining string
        if (!append_string(path, pathSize, name))
                return ENAMETOOLONG;

        return B_OK;
}


// #pragma mark -


void*
mmap(void* address, size_t length, int protection, int flags, int fd,
        off_t offset)
{
        // offset and length must be page-aligned
        if (length == 0 || offset % B_PAGE_SIZE != 0) {
                __set_errno(B_BAD_VALUE);
                return MAP_FAILED;
        }

        // check anonymous mapping
        if ((flags & MAP_ANONYMOUS) != 0) {
                fd = -1;
        } else if (fd < 0) {
                __set_errno(EBADF);
                return MAP_FAILED;
        }

        // either MAP_SHARED or MAP_PRIVATE must be specified
        if (((flags & MAP_SHARED) != 0) == ((flags & MAP_PRIVATE) != 0)) {
                __set_errno(B_BAD_VALUE);
                return MAP_FAILED;
        }

        // translate mapping, address specification, and protection
        int mapping = (flags & MAP_SHARED) != 0
                ? REGION_NO_PRIVATE_MAP : REGION_PRIVATE_MAP;

        uint32 addressSpec;
        if ((flags & MAP_FIXED) != 0)
                addressSpec = B_EXACT_ADDRESS;
        else if (address != NULL)
                addressSpec = B_BASE_ADDRESS;
        else
                addressSpec = B_RANDOMIZED_ANY_ADDRESS;

        uint32 areaProtection = 0;
        if ((protection & PROT_READ) != 0)
                areaProtection |= B_READ_AREA;
        if ((protection & PROT_WRITE) != 0)
                areaProtection |= B_WRITE_AREA;
        if ((protection & PROT_EXEC) != 0)
                areaProtection |= B_EXECUTE_AREA;

        if ((flags & MAP_NORESERVE) != 0)
                areaProtection |= B_OVERCOMMITTING_AREA;

        // create a name for this area based on calling image
        void* addr = __builtin_return_address(0);
        char* imageName;
        char areaName[B_OS_NAME_LENGTH];
        status_t status = __gRuntimeLoader->get_nearest_symbol_at_address(
                addr, NULL, NULL, &imageName, NULL, NULL, NULL, NULL);
        if (status == B_OK)
                snprintf(areaName, sizeof(areaName), "%s mmap area", imageName);
        else
                strlcpy(areaName, "mmap area", sizeof(areaName));

        // ask the kernel to map
        area_id area = _kern_map_file(areaName, &address, addressSpec,
                length, areaProtection, mapping, true, fd, offset);
        if (area < 0) {
                __set_errno(area);
                return MAP_FAILED;
        }

        return address;
}


int
munmap(void* address, size_t length)
{
        RETURN_AND_SET_ERRNO(_kern_unmap_memory(address, length));
}


int
mprotect(void* address, size_t length, int protection)
{
        RETURN_AND_SET_ERRNO(_kern_set_memory_protection(address, length,
                protection));
}


int
msync(void* address, size_t length, int flags)
{
        RETURN_AND_SET_ERRNO_TEST_CANCEL(_kern_sync_memory(address, length, flags));
}


int
madvise(void* address, size_t length, int advice)
{
        RETURN_AND_SET_ERRNO(_kern_memory_advice(address, length, advice));
}


int
posix_madvise(void* address, size_t length, int advice)
{
        return madvise(address, length, advice);
}


int
mlock(const void* address, size_t length)
{
        RETURN_AND_SET_ERRNO(_kern_mlock(address, length));
}


int
munlock(const void* address, size_t length)
{
        RETURN_AND_SET_ERRNO(_kern_munlock(address, length));
}


int
shm_open(const char* name, int openMode, mode_t permissions)
{
        char path[PATH_MAX];
        status_t error = shm_name_to_path(name, path, sizeof(path));
        if (error != B_OK)
                RETURN_AND_SET_ERRNO(error);

        return open(path, openMode | O_CLOEXEC, permissions);
}


int
shm_unlink(const char* name)
{
        char path[PATH_MAX];
        status_t error = shm_name_to_path(name, path, sizeof(path));
        if (error != B_OK)
                RETURN_AND_SET_ERRNO(error);

        return unlink(path);
}