mmap_win.c

Go to the documentation of this file.

/*
 * $Id: mmap_win.c 36271 2011-04-21 13:11:51Z campbellbarton $
 *
 * ***** 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