mmap_win.c

Go to the documentation of this file.

/*
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version. 
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2008 Blender Foundation.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): Andrea Weikert.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#if defined(WIN32)

#include <windows.h>
#include <errno.h>
#include <io.h>
#include <sys/types.h>
#include <stdio.h>

#include "mmap_win.h"

#ifndef FILE_MAP_EXECUTE
//not defined in earlier versions of the Platform  SDK (before February 2003)
#define FILE_MAP_EXECUTE 0x0020
#endif

/* copied from BKE_utildefines.h ugh */
#ifdef __GNUC__
#  define UNUSED(x) UNUSED_ ## x __attribute__((__unused__))
#else
#  define UNUSED(x) x
#endif

/* --------------------------------------------------------------------- */
/* local storage definitions                                                    */
/* --------------------------------------------------------------------- */
/* all memory mapped chunks are put in linked lists */
typedef struct mmapLink
{
    struct mmapLink *next,*prev;
} mmapLink;

typedef struct mmapListBase 
{
    void *first, *last;
} mmapListBase;

typedef struct MemMap {
    struct MemMap *next,*prev;
    void *mmap;
    HANDLE fhandle;
    HANDLE maphandle;
} MemMap;

/* --------------------------------------------------------------------- */
/* local functions                                                       */
/* --------------------------------------------------------------------- */

static void mmap_addtail(volatile mmapListBase *listbase, void *vlink);
static void mmap_remlink(volatile mmapListBase *listbase, void *vlink);
static void *mmap_findlink(volatile mmapListBase *listbase, void *ptr);

static int mmap_get_prot_flags (int flags);
static int mmap_get_access_flags (int flags);

/* --------------------------------------------------------------------- */
/* vars                                                                  */
/* --------------------------------------------------------------------- */
volatile static struct mmapListBase _mmapbase;
volatile static struct mmapListBase *mmapbase = &_mmapbase;


/* --------------------------------------------------------------------- */
/* implementation                                                        */
/* --------------------------------------------------------------------- */

/* mmap for windows */
void *mmap(void *UNUSED(start), size_t len, int prot, int flags, int fd, off_t offset)
{
    HANDLE fhandle = INVALID_HANDLE_VALUE;
    HANDLE maphandle;
    int prot_flags = mmap_get_prot_flags(prot);
    int access_flags = mmap_get_access_flags(prot);
    MemMap *mm = NULL;
    void *ptr = NULL;

    if ( flags & MAP_FIXED ) {
        return MAP_FAILED;
    }

    /*
    if ( fd == -1 ) {
        _set_errno( EBADF );
        return MAP_FAILED;
    }
    */

    if ( fd != -1 ) {
        fhandle = (HANDLE) _get_osfhandle (fd);
    }
    if ( fhandle == INVALID_HANDLE_VALUE ) {
        if (!(flags & MAP_ANONYMOUS)) {
            errno = EBADF;
            return MAP_FAILED;
        }
    } else {
        if ( !DuplicateHandle( GetCurrentProcess(), fhandle, GetCurrentProcess(),
        &fhandle, 0, FALSE, DUPLICATE_SAME_ACCESS ) ) {
            return MAP_FAILED;
        }
    }

    maphandle = CreateFileMapping(fhandle, NULL, prot_flags, 0, len, NULL);
    if ( maphandle == 0 ) {
        errno = EBADF;
        return MAP_FAILED;
    }

    ptr = MapViewOfFile(maphandle, access_flags, 0, offset, 0);
    if ( ptr == NULL ) {
        DWORD dwLastErr = GetLastError();
        if ( dwLastErr == ERROR_MAPPED_ALIGNMENT )
            errno=EINVAL;
        else
            errno=EACCES;
        CloseHandle(maphandle);
        return MAP_FAILED;
    }

    mm= (MemMap *)malloc(sizeof(MemMap));
    if (!mm) {
        errno=ENOMEM;
    }
    mm->fhandle = fhandle;
    mm->maphandle = maphandle;
    mm->mmap = ptr;
    mmap_addtail(mmapbase, mm);

    return ptr;
}

/* munmap for windows */
intptr_t munmap(void *ptr, intptr_t UNUSED(size))
{
    MemMap *mm = mmap_findlink(mmapbase, ptr);
    if (!mm) {
        errno=EINVAL;
        return -1;
    }
    UnmapViewOfFile( mm->mmap );
    CloseHandle( mm->maphandle );
    CloseHandle( mm->fhandle);
    mmap_remlink(mmapbase, mm);
    free(mm);
    return 0;
}

/* --------------------------------------------------------------------- */
/* local functions                                                       */
/* --------------------------------------------------------------------- */

static void mmap_addtail(volatile mmapListBase *listbase, void *vlink)
{
    struct mmapLink *link= vlink;

    if (link == 0) return;
    if (listbase == 0) return;

    link->next = 0;
    link->prev = listbase->last;

    if (listbase->last) ((struct mmapLink *)listbase->last)->next = link;
    if (listbase->first == 0) listbase->first = link;
    listbase->last = link;
}

static void mmap_remlink(volatile mmapListBase *listbase, void *vlink)
{
    struct mmapLink *link= vlink;

    if (link == 0) return;
    if (listbase == 0) return;

    if (link->next) link->next->prev = link->prev;
    if (link->prev) link->prev->next = link->next;

    if (listbase->last == link) listbase->last = link->prev;
    if (listbase->first == link) listbase->first = link->next;
}

static void *mmap_findlink(volatile mmapListBase *listbase, void *ptr)
{
    MemMap *mm;

    if (ptr == 0) return NULL;
    if (listbase == 0) return NULL;
    
    mm = (MemMap *)listbase->first;
    while (mm) {
        if (mm->mmap == ptr) {
            return mm;
        }
        mm = mm->next;
    }
    return NULL;
}

static int mmap_get_prot_flags (int flags)
{
    int prot = PAGE_NOACCESS;

    if ( ( flags & PROT_READ ) == PROT_READ ) {
        if ( ( flags & PROT_WRITE ) == PROT_WRITE ) {
            prot = (flags & PROT_EXEC) ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
        } else {
            prot = (flags & PROT_EXEC) ? PAGE_EXECUTE_READ : PAGE_READONLY;
        }
    } else if ( ( flags & PROT_WRITE ) == PROT_WRITE ) {
        prot = (flags & PROT_EXEC) ? PAGE_EXECUTE_READ : PAGE_WRITECOPY;
    } else if ( ( flags & PROT_EXEC ) == PROT_EXEC ) {
        prot = PAGE_EXECUTE_READ;
    }
    return prot;
}

static int mmap_get_access_flags (int flags)
{
    int access = 0;

    if ( ( flags & PROT_READ ) == PROT_READ ) {
        if ( ( flags & PROT_WRITE ) == PROT_WRITE ) {
            access = FILE_MAP_WRITE;
        } else {
            access = (flags & PROT_EXEC) ? FILE_MAP_EXECUTE : FILE_MAP_READ;
        }
    } else if ( ( flags & PROT_WRITE ) == PROT_WRITE ) {
        access = FILE_MAP_COPY;
    } else if ( ( flags & PROT_EXEC ) == PROT_EXEC ) {
        access = FILE_MAP_EXECUTE;
    }
    return access;
}


#endif // WIN32