add a pager for windows

Author: ecordell

db/pager_unix.go

@@ -1,3 +1,5 @@
+// +build !windows
+
 // unix implementation of the `pager` interface (the file reader) with POSIX
 // advisory locking
 

db/pager_windows.go

@@ -0,0 +1,171 @@
+// windows implementation of the `pager` interface (the file reader) with LockFileEx
+// locking
+
+// references:
+// winapi docs: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-lockfileex
+// sqlite3 winlock: https://github.com/sqlite/sqlite/blob/c398c65bee850b6b8f24a44852872a27f114535d/src/os_win.c#L3236
+// golang windows syscalls from go/internal:
+//   src/cmd/go/internal/lockedfile/internal/filelock/filelock_windows.go
+//   src/internal/syscall/windows/syscall_windows.go
+
+package db
+
+import (
+	"errors"
+	"os"
+	"syscall"
+	"unsafe"
+
+	"golang.org/x/exp/mmap"
+)
+
+const (
+	seek_set             = 0 // should be defined in syscall
+	sqlite_pending_byte  = 0x40000000
+	sqlite_reserved_byte = sqlite_pending_byte + 1
+	sqlite_shared_first  = sqlite_pending_byte + 2
+	sqlite_shared_size   = 510
+)
+
+var (
+	modkernel32      = syscall.NewLazyDLL("kernel32.dll")
+	procLockFileEx   = modkernel32.NewProc("LockFileEx")
+	procUnlockFileEx = modkernel32.NewProc("UnlockFileEx")
+)
+
+const (
+	reserved                uint32 = 0
+	lockfileFailImmediately uint32 = 1
+	lockfileExclusiveLock   uint32 = 2
+	sqliteLockfileFlags     uint32 = lockfileFailImmediately | lockfileExclusiveLock
+)
+
+func lockFileEx(h syscall.Handle, flags, reserved, locklow, lockhigh uint32, ol *syscall.Overlapped) (err error) {
+	r1, _, e1 := syscall.Syscall6(procLockFileEx.Addr(), 6, uintptr(h), uintptr(flags), uintptr(reserved), uintptr(locklow), uintptr(lockhigh), uintptr(unsafe.Pointer(ol)))
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func unlockFileEx(h syscall.Handle, reserved, locklow, lockhigh uint32, ol *syscall.Overlapped) (err error) {
+	r1, _, e1 := syscall.Syscall6(procUnlockFileEx.Addr(), 5, uintptr(h), uintptr(reserved), uintptr(locklow), uintptr(lockhigh), uintptr(unsafe.Pointer(ol)), 0)
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+// LockState is used to represent the program's opinion of whether a file is locked or not
+// this does not represent the lock state of the file - we can't distinguish between
+// a file that is locked by another process and failing to acquire a lock
+type LockState int
+
+const (
+	Unlocked LockState = iota
+	Locked
+)
+
+type filePager struct {
+	f  *os.File
+	mm *mmap.ReaderAt
+
+	//TODO: mutex
+	state LockState
+}
+
+func newFilePager(file string) (*filePager, error) {
+	f, err := os.Open(file)
+	if err != nil {
+		return nil, err
+	}
+	mm, err := mmap.Open(file)
+	if err != nil {
+		f.Close()
+		return nil, err
+	}
+	return &filePager{
+		f:     f,
+		mm:    mm,
+		state: Unlocked,
+	}, nil
+}
+
+// pages start counting at 1
+func (f *filePager) page(id int, pagesize int) ([]byte, error) {
+	buf := make([]byte, pagesize)
+	_, err := f.mm.ReadAt(buf[:], int64(id-1)*int64(pagesize))
+	return buf, err
+}
+
+func (f *filePager) lock(start, len uint32) error {
+	ol := new(syscall.Overlapped)
+	ol.Offset = start
+	return lockFileEx(syscall.Handle(f.f.Fd()), sqliteLockfileFlags, reserved, len, 0, ol)
+}
+
+func (f *filePager) unlock(start, len uint32) error {
+	ol := new(syscall.Overlapped)
+	ol.Offset = start
+	return unlockFileEx(syscall.Handle(f.f.Fd()), reserved, len, 0, ol)
+}
+
+func (f *filePager) RLock() error {
+	// Set a 'SHARED' lock, following winLock() logic from sqlite3.c
+	if f.state == Locked {
+		return errors.New("trying to lock a locked lock") // panic?
+	}
+
+	// - get PENDING lock
+
+	// TODO: retry , see sqlite3.c
+	if err := f.lock(sqlite_pending_byte, 1); err != nil {
+		return err
+	}
+
+	defer func() {
+		// - drop the pending lock. No idea what to do with the error :/
+		f.unlock(sqlite_pending_byte, 1)
+	}()
+
+	// Get the read-lock
+	if err := f.lock(sqlite_shared_first, sqlite_shared_size); err != nil {
+		return err
+	}
+	f.state = Locked
+	return nil
+}
+
+func (f *filePager) RUnlock() error {
+	if f.state == Unlocked {
+		return errors.New("trying to unlock an unlocked lock") // panic?
+	}
+	if err := f.lock(sqlite_shared_first, sqlite_shared_size); err != nil {
+		return err
+	}
+	f.state = Unlocked
+	return nil
+}
+
+// True if there is a 'reserved' lock on the database, by any process.
+func (f *filePager) CheckReservedLock() (bool, error) {
+	// per SQLite's winCheckReservedLock()
+	err := f.lock(sqlite_reserved_byte, 1)
+	if err == nil {
+		f.unlock(sqlite_reserved_byte, 1)
+	}
+	return err == nil, err
+}
+
+func (f *filePager) Close() error {
+	f.f.Close()
+	return f.mm.Close()
+}