2016-11-29 17:26:36 +01:00
|
|
|
package bolt
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"os"
|
|
|
|
"syscall"
|
|
|
|
"time"
|
|
|
|
"unsafe"
|
|
|
|
)
|
|
|
|
|
|
|
|
// LockFileEx code derived from golang build filemutex_windows.go @ v1.5.1
|
|
|
|
var (
|
|
|
|
modkernel32 = syscall.NewLazyDLL("kernel32.dll")
|
|
|
|
procLockFileEx = modkernel32.NewProc("LockFileEx")
|
|
|
|
procUnlockFileEx = modkernel32.NewProc("UnlockFileEx")
|
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
lockExt = ".lock"
|
|
|
|
|
|
|
|
// see https://msdn.microsoft.com/en-us/library/windows/desktop/aa365203(v=vs.85).aspx
|
|
|
|
flagLockExclusive = 2
|
|
|
|
flagLockFailImmediately = 1
|
|
|
|
|
|
|
|
// see https://msdn.microsoft.com/en-us/library/windows/desktop/ms681382(v=vs.85).aspx
|
|
|
|
errLockViolation syscall.Errno = 0x21
|
|
|
|
)
|
|
|
|
|
|
|
|
func lockFileEx(h syscall.Handle, flags, reserved, locklow, lockhigh uint32, ol *syscall.Overlapped) (err error) {
|
|
|
|
r, _, err := procLockFileEx.Call(uintptr(h), uintptr(flags), uintptr(reserved), uintptr(locklow), uintptr(lockhigh), uintptr(unsafe.Pointer(ol)))
|
|
|
|
if r == 0 {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func unlockFileEx(h syscall.Handle, reserved, locklow, lockhigh uint32, ol *syscall.Overlapped) (err error) {
|
|
|
|
r, _, err := procUnlockFileEx.Call(uintptr(h), uintptr(reserved), uintptr(locklow), uintptr(lockhigh), uintptr(unsafe.Pointer(ol)), 0)
|
|
|
|
if r == 0 {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// fdatasync flushes written data to a file descriptor.
|
|
|
|
func fdatasync(db *DB) error {
|
|
|
|
return db.file.Sync()
|
|
|
|
}
|
|
|
|
|
|
|
|
// flock acquires an advisory lock on a file descriptor.
|
|
|
|
func flock(db *DB, mode os.FileMode, exclusive bool, timeout time.Duration) error {
|
|
|
|
// Create a separate lock file on windows because a process
|
|
|
|
// cannot share an exclusive lock on the same file. This is
|
|
|
|
// needed during Tx.WriteTo().
|
|
|
|
f, err := os.OpenFile(db.path+lockExt, os.O_CREATE, mode)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
db.lockfile = f
|
|
|
|
|
|
|
|
var t time.Time
|
|
|
|
for {
|
|
|
|
// If we're beyond our timeout then return an error.
|
|
|
|
// This can only occur after we've attempted a flock once.
|
|
|
|
if t.IsZero() {
|
|
|
|
t = time.Now()
|
|
|
|
} else if timeout > 0 && time.Since(t) > timeout {
|
|
|
|
return ErrTimeout
|
|
|
|
}
|
|
|
|
|
|
|
|
var flag uint32 = flagLockFailImmediately
|
|
|
|
if exclusive {
|
|
|
|
flag |= flagLockExclusive
|
|
|
|
}
|
|
|
|
|
|
|
|
err := lockFileEx(syscall.Handle(db.lockfile.Fd()), flag, 0, 1, 0, &syscall.Overlapped{})
|
|
|
|
if err == nil {
|
|
|
|
return nil
|
|
|
|
} else if err != errLockViolation {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Wait for a bit and try again.
|
|
|
|
time.Sleep(50 * time.Millisecond)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// funlock releases an advisory lock on a file descriptor.
|
|
|
|
func funlock(db *DB) error {
|
|
|
|
err := unlockFileEx(syscall.Handle(db.lockfile.Fd()), 0, 1, 0, &syscall.Overlapped{})
|
|
|
|
db.lockfile.Close()
|
2017-04-06 03:50:33 +02:00
|
|
|
os.Remove(db.path + lockExt)
|
2016-11-29 17:26:36 +01:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// mmap memory maps a DB's data file.
|
|
|
|
// Based on: https://github.com/edsrzf/mmap-go
|
|
|
|
func mmap(db *DB, sz int) error {
|
|
|
|
if !db.readOnly {
|
|
|
|
// Truncate the database to the size of the mmap.
|
|
|
|
if err := db.file.Truncate(int64(sz)); err != nil {
|
|
|
|
return fmt.Errorf("truncate: %s", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Open a file mapping handle.
|
|
|
|
sizelo := uint32(sz >> 32)
|
|
|
|
sizehi := uint32(sz) & 0xffffffff
|
|
|
|
h, errno := syscall.CreateFileMapping(syscall.Handle(db.file.Fd()), nil, syscall.PAGE_READONLY, sizelo, sizehi, nil)
|
|
|
|
if h == 0 {
|
|
|
|
return os.NewSyscallError("CreateFileMapping", errno)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create the memory map.
|
|
|
|
addr, errno := syscall.MapViewOfFile(h, syscall.FILE_MAP_READ, 0, 0, uintptr(sz))
|
|
|
|
if addr == 0 {
|
|
|
|
return os.NewSyscallError("MapViewOfFile", errno)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Close mapping handle.
|
|
|
|
if err := syscall.CloseHandle(syscall.Handle(h)); err != nil {
|
|
|
|
return os.NewSyscallError("CloseHandle", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert to a byte array.
|
|
|
|
db.data = ((*[maxMapSize]byte)(unsafe.Pointer(addr)))
|
|
|
|
db.datasz = sz
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// munmap unmaps a pointer from a file.
|
|
|
|
// Based on: https://github.com/edsrzf/mmap-go
|
|
|
|
func munmap(db *DB) error {
|
|
|
|
if db.data == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
addr := (uintptr)(unsafe.Pointer(&db.data[0]))
|
|
|
|
if err := syscall.UnmapViewOfFile(addr); err != nil {
|
|
|
|
return os.NewSyscallError("UnmapViewOfFile", err)
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|