Merge pull request #1 from nsip/mmap-windows

windows support

Author: matt-farmer

consts_win.go

@@ -0,0 +1,69 @@
+// +build windows
+
+package gommap
+
+const (
+	// RDONLY maps the memory read-only.
+	// Attempts to write to the MMap object will result in undefined behavior.
+	RDONLY = 0
+	// RDWR maps the memory as read-write. Writes to the MMap object will update the
+	// underlying file.
+	RDWR = 1 << iota
+	// COPY maps the memory as copy-on-write. Writes to the MMap object will affect
+	// memory, but the underlying file will remain unchanged.
+	COPY
+	// If EXEC is set, the mapped memory is marked as executable.
+	EXEC
+)
+
+type ProtFlags uint
+
+const (
+	// PROT_NONE  ProtFlags = 0x0
+	// PROT_READ  ProtFlags = 0x1
+	// PROT_WRITE ProtFlags = 0x2
+	// PROT_EXEC  ProtFlags = 0x4
+
+	// PROT_NONE  ProtFlags = 0x0	/* No PROT_NONE on windows */
+	PROT_READ  ProtFlags = RDONLY
+	PROT_WRITE ProtFlags = RDWR
+	PROT_COPY  ProtFlags = COPY /* PROT_COPY Only on windows, use this flag to implement MAP_PRIVATE */
+	PROT_EXEC  ProtFlags = EXEC
+)
+
+/* on win, use ProtFlags to simulate MapFlags */
+
+type MapFlags uint
+
+const (
+	MAP_SHARED    MapFlags = 0x1
+	MAP_PRIVATE   MapFlags = 0x2
+	MAP_FIXED     MapFlags = 0x10
+	MAP_ANONYMOUS MapFlags = 0x20
+	MAP_GROWSDOWN MapFlags = 0x100
+	MAP_LOCKED    MapFlags = 0x2000
+	MAP_NONBLOCK  MapFlags = 0x10000
+	MAP_NORESERVE MapFlags = 0x4000
+	MAP_POPULATE  MapFlags = 0x8000
+)
+
+type SyncFlags uint
+
+const (
+	MS_SYNC       SyncFlags = 0x4
+	MS_ASYNC      SyncFlags = 0x1
+	MS_INVALIDATE SyncFlags = 0x2
+)
+
+type AdviseFlags uint
+
+const (
+	MADV_NORMAL     AdviseFlags = 0x0
+	MADV_RANDOM     AdviseFlags = 0x1
+	MADV_SEQUENTIAL AdviseFlags = 0x2
+	MADV_WILLNEED   AdviseFlags = 0x3
+	MADV_DONTNEED   AdviseFlags = 0x4
+	MADV_REMOVE     AdviseFlags = 0x9
+	MADV_DONTFORK   AdviseFlags = 0xa
+	MADV_DOFORK     AdviseFlags = 0xb
+)

gommap_win.go

@@ -0,0 +1,166 @@
+// This package offers the MMap type that manipulates a memory mapped file or
+// device.
+//
+// IMPORTANT NOTE (1): The MMap type is backed by an unsafe memory region,
+// which is not covered by the normal rules of Go's memory management. If a
+// slice is taken out of it, and then the memory is explicitly unmapped through
+// one of the available methods, both the MMap value itself and the slice
+// obtained will now silently point to invalid memory.  Attempting to access
+// data in them will crash the application.
+
+// +build windows
+
+package gommap
+
+import (
+	"errors"
+	"os"
+	"reflect"
+	"syscall"
+	"unsafe"
+)
+
+// The MMap type represents a memory mapped file or device. The slice offers
+// direct access to the memory mapped content.
+//
+// IMPORTANT: Please see note in the package documentation regarding the way
+// in which this type behaves.
+type MMap []byte
+
+// In order to implement 'Protect', use this to get back the original MMap properties from the memory address.
+var mmapAttrs = map[uintptr]*struct {
+	fd     uintptr
+	offset int64
+	length int64
+	prot   ProtFlags
+	flags  MapFlags
+}{}
+
+// GetFileSize gets the file length from its fd
+func GetFileSize(fd uintptr) (int64, error) {
+	fh := syscall.Handle(fd)
+	fsize, err := syscall.Seek(syscall.Handle(fh), 0, 2)
+	syscall.Seek(fh, 0, 0)
+	return fsize, err
+}
+
+// Map creates a new mapping in the virtual address space of the calling process.
+// This function will attempt to map the entire file by using the fstat system
+// call with the provided file descriptor to discover its length.
+func Map(fd uintptr, prot ProtFlags, flags MapFlags) (MMap, error) {
+	return MapRegion(fd, 0, -1, prot, flags)
+}
+
+// MapRegion creates a new mapping in the virtual address space of the calling
+// process, using the specified region of the provided file or device. If -1 is
+// provided as length, this function will attempt to map until the end of the
+// provided file descriptor by using the fstat system call to discover its
+// length.
+func MapRegion(fd uintptr, offset, length int64, prot ProtFlags, flags MapFlags) (MMap, error) {
+	if offset%int64(os.Getpagesize()) != 0 {
+		return nil, errors.New("offset parameter must be a multiple of the system's page size")
+	}
+	if length == -1 {
+		length, _ = GetFileSize(fd)
+	}
+	/* on windows, use PROT_COPY to do the same thing as linux MAP_PRIVATE flag do */
+	if flags == MAP_PRIVATE {
+		prot = PROT_COPY
+	}
+	// return mmap(length, uintptr(prot), uintptr(flags), fd, offset)
+
+	/*******************************/
+	m, e := mmap(length, uintptr(prot), uintptr(flags), fd, offset)
+	dh := (*reflect.SliceHeader)(unsafe.Pointer(&m))
+	mmapAttrs[dh.Data] = &struct {
+		fd     uintptr
+		offset int64
+		length int64
+		prot   ProtFlags
+		flags  MapFlags
+	}{fd, offset, length, prot, flags}
+	return m, e
+}
+
+func (mmap *MMap) header() *reflect.SliceHeader {
+	return (*reflect.SliceHeader)(unsafe.Pointer(mmap))
+}
+
+// UnsafeUnmap deletes the memory mapped region defined by the mmap slice. This
+// will also flush any remaining changes, if necessary.  Using mmap or any
+// other slices based on it after this method has been called will crash the
+// application.
+func (mmap MMap) UnsafeUnmap() error {
+	dh := mmap.header()
+	return unmap(dh.Data, uintptr(dh.Len))
+}
+
+// Sync flushes changes made to the region determined by the mmap slice
+// back to the device. Without calling this method, there are no guarantees
+// that changes will be flushed back before the region is unmapped.  The
+// flags parameter specifies whether flushing should be done synchronously
+// (before the method returns) with MS_SYNC, or asynchronously (flushing is just
+// scheduled) with MS_ASYNC.
+func (mmap MMap) Sync(flags SyncFlags) error {
+	dh := mmap.header()
+	return flush(dh.Data, uintptr(dh.Len))
+}
+
+// // Advise advises the kernel about how to handle the mapped memory
+// // region in terms of input/output paging within the memory region
+// // defined by the mmap slice.
+// func (mmap MMap) Advise(advice AdviseFlags) error {
+// 	// rh := *(*reflect.SliceHeader)(unsafe.Pointer(&mmap))
+// 	// _, _, err := syscall.Syscall(syscall.SYS_MADVISE, uintptr(rh.Data), uintptr(rh.Len), uintptr(advice))
+// 	// if err != 0 {
+// 	// 	return err
+// 	// }
+// 	// return nil
+// }
+
+// Protect changes the protection flags for the memory mapped region
+// defined by the mmap slice.
+// We use unmap & map again to implement this on windows. So can only change the protect flags on the whole
+func (mmap *MMap) Protect(prot ProtFlags) (err error) {
+	dh := mmap.header()
+	var m MMap
+	if err = mmap.UnsafeUnmap(); err == nil {
+		fd, offset, length, flags := mmapAttrs[dh.Data].fd, mmapAttrs[dh.Data].offset, mmapAttrs[dh.Data].length, mmapAttrs[dh.Data].flags
+		mmapAttrs[dh.Data] = nil
+		if m, err = MapRegion(fd, offset, length, prot, flags); err == nil {
+			mmap = &m
+		}
+	}
+	return
+}
+
+// Lock locks the mapped region defined by the mmap slice,
+// preventing it from being swapped out.
+func (mmap MMap) Lock() error {
+	dh := mmap.header()
+	return lock(dh.Data, uintptr(dh.Len))
+}
+
+// Unlock unlocks the mapped region defined by the mmap slice,
+// allowing it to swap out again.
+func (mmap MMap) Unlock() error {
+	dh := mmap.header()
+	return unlock(dh.Data, uintptr(dh.Len))
+}
+
+// // IsResident returns a slice of booleans informing whether the respective
+// // memory page in mmap was mapped at the time the call was made.
+// func (mmap MMap) IsResident() ([]bool, error) {
+// 	pageSize := os.Getpagesize()
+// 	result := make([]bool, (len(mmap)+pageSize-1)/pageSize)
+// 	rh := *(*reflect.SliceHeader)(unsafe.Pointer(&mmap))
+// 	resulth := *(*reflect.SliceHeader)(unsafe.Pointer(&result))
+// 	_, _, err := syscall.Syscall(syscall.SYS_MINCORE, uintptr(rh.Data), uintptr(rh.Len), uintptr(resulth.Data))
+// 	for i := range result {
+// 		*(*uint8)(unsafe.Pointer(&result[i])) &= 1
+// 	}
+// 	if err != 0 {
+// 		return nil, err
+// 	}
+// 	return result, nil
+// }

mmap_windows.go

@@ -0,0 +1,143 @@
+// Copyright 2011 Evan Shaw. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package gommap
+
+import (
+	"errors"
+	"os"
+	"sync"
+	"syscall"
+)
+
+// mmap on Windows is a two-step process.
+// First, we call CreateFileMapping to get a handle.
+// Then, we call MapviewToFile to get an actual pointer into memory.
+// Because we want to emulate a POSIX-style mmap, we don't want to expose
+// the handle -- only the pointer. We also want to return only a byte slice,
+// not a struct, so it's convenient to manipulate.
+
+// We keep this map so that we can get back the original handle from the memory address.
+var handleLock sync.Mutex
+var handleMap = map[uintptr]syscall.Handle{}
+var addrLocked = map[uintptr]bool{}
+
+func mmap(len int64, prot, flags, hfile uintptr, off int64) ([]byte, error) {
+	flProtect := uint32(syscall.PAGE_READONLY)
+	dwDesiredAccess := uint32(syscall.FILE_MAP_READ)
+	switch {
+	case prot&COPY != 0:
+		flProtect = syscall.PAGE_WRITECOPY
+		dwDesiredAccess = syscall.FILE_MAP_COPY
+	case prot&RDWR != 0:
+		flProtect = syscall.PAGE_READWRITE
+		dwDesiredAccess = syscall.FILE_MAP_WRITE
+	}
+	if prot&EXEC != 0 {
+		flProtect <<= 4
+		dwDesiredAccess |= syscall.FILE_MAP_EXECUTE
+	}
+
+	// The maximum size is the area of the file, starting from 0,
+	// that we wish to allow to be mappable. It is the sum of
+	// the length the user requested, plus the offset where that length
+	// is starting from. This does not map the data into memory.
+	maxSizeHigh := uint32((off + len) >> 32)
+	maxSizeLow := uint32((off + len) & 0xFFFFFFFF)
+	// TODO: Do we need to set some security attributes? It might help portability.
+	h, errno := syscall.CreateFileMapping(syscall.Handle(hfile), nil, flProtect, maxSizeHigh, maxSizeLow, nil)
+	if h == 0 {
+		if errno == syscall.ERROR_ACCESS_DENIED {
+			return nil, syscall.EACCES
+		}
+		return nil, os.NewSyscallError("CreateFileMapping", errno)
+	}
+
+	// Actually map a view of the data into memory. The view's size
+	// is the length the user requested.
+	fileOffsetHigh := uint32(off >> 32)
+	fileOffsetLow := uint32(off & 0xFFFFFFFF)
+	addr, errno := syscall.MapViewOfFile(h, dwDesiredAccess, fileOffsetHigh, fileOffsetLow, uintptr(len))
+	if addr == 0 {
+		return nil, os.NewSyscallError("MapViewOfFile", errno)
+	}
+	handleLock.Lock()
+	handleMap[addr] = h
+	handleLock.Unlock()
+
+	m := MMap{}
+	dh := m.header()
+	dh.Data = addr
+	dh.Len = int(len)
+	dh.Cap = dh.Len
+
+	return m, nil
+}
+
+func flush(addr, len uintptr) error {
+	errno := syscall.FlushViewOfFile(addr, len)
+	if errno != nil {
+		return os.NewSyscallError("FlushViewOfFile", errno)
+	}
+
+	handleLock.Lock()
+	defer handleLock.Unlock()
+	handle, ok := handleMap[addr]
+	if !ok {
+		// should be impossible; we would've errored above
+		return errors.New("unknown base address")
+	}
+
+	errno = syscall.FlushFileBuffers(handle)
+	return os.NewSyscallError("FlushFileBuffers", errno)
+}
+
+func lock(addr, len uintptr) error {
+	if addrLocked[addr] {
+		return nil
+	}
+	errno := syscall.VirtualLock(addr, len)
+	if errno == nil {
+		addrLocked[addr] = true
+	}
+	return os.NewSyscallError("VirtualLock", errno)
+}
+
+func unlock(addr, len uintptr) error {
+	if !addrLocked[addr] {
+		return nil
+	}
+	errno := syscall.VirtualUnlock(addr, len)
+	if errno == nil {
+		addrLocked[addr] = false
+	}
+	return os.NewSyscallError("VirtualUnlock", errno)
+}
+
+func unmap(addr, len uintptr) error {
+	flush(addr, len)
+	// Lock the UnmapViewOfFile along with the handleMap deletion.
+	// As soon as we unmap the view, the OS is free to give the
+	// same addr to another new map. We don't want another goroutine
+	// to insert and remove the same addr into handleMap while
+	// we're trying to remove our old addr/handle pair.
+	handleLock.Lock()
+	defer handleLock.Unlock()
+	err := syscall.UnmapViewOfFile(addr)
+	if err != nil {
+		return err
+	}
+
+	handle, ok := handleMap[addr]
+	if !ok {
+		// should be impossible; we would've errored above
+		return errors.New("unknown base address")
+	}
+	delete(handleMap, addr)
+
+	e := syscall.CloseHandle(syscall.Handle(handle))
+	return os.NewSyscallError("CloseHandle", e)
+}