typenative 0.1.3 → 0.2.0

package/govendor/github.com/ncruces/go-sqlite3/vfs/lock.go

@@ -0,0 +1,128 @@
+//go:build linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock || sqlite3_dotlk
+
+package vfs
+
+import "github.com/ncruces/go-sqlite3/internal/errutil"
+
+// SupportsFileLocking is false on platforms that do not support file locking.
+// To open a database file on those platforms,
+// you need to use the [nolock] or [immutable] URI parameters.
+//
+// [nolock]: https://sqlite.org/uri.html#urinolock
+// [immutable]: https://sqlite.org/uri.html#uriimmutable
+const SupportsFileLocking = true
+
+const (
+	_PENDING_BYTE  = 0x40000000
+	_RESERVED_BYTE = (_PENDING_BYTE + 1)
+	_SHARED_FIRST  = (_PENDING_BYTE + 2)
+	_SHARED_SIZE   = 510
+)
+
+func (f *vfsFile) Lock(lock LockLevel) error {
+	switch {
+	case lock != LOCK_SHARED && lock != LOCK_RESERVED && lock != LOCK_EXCLUSIVE:
+		// Argument check. SQLite never explicitly requests a pending lock.
+		panic(errutil.AssertErr())
+	case f.lock < LOCK_NONE || f.lock > LOCK_EXCLUSIVE:
+		// Connection state check.
+		panic(errutil.AssertErr())
+	case f.lock == LOCK_NONE && lock > LOCK_SHARED:
+		// We never move from unlocked to anything higher than a shared lock.
+		panic(errutil.AssertErr())
+	case f.lock != LOCK_SHARED && lock == LOCK_RESERVED:
+		// A shared lock is always held when a reserved lock is requested.
+		panic(errutil.AssertErr())
+	}
+
+	// If we already have an equal or more restrictive lock, do nothing.
+	if f.lock >= lock {
+		return nil
+	}
+
+	// Do not allow any kind of write-lock on a read-only database.
+	if lock >= LOCK_RESERVED && f.flags&OPEN_READONLY != 0 {
+		return _IOERR_LOCK
+	}
+
+	switch lock {
+	case LOCK_SHARED:
+		// Must be unlocked to get SHARED.
+		if f.lock != LOCK_NONE {
+			panic(errutil.AssertErr())
+		}
+		if err := osGetSharedLock(f.File); err != nil {
+			return err
+		}
+		f.lock = LOCK_SHARED
+		return nil
+
+	case LOCK_RESERVED:
+		// Must be SHARED to get RESERVED.
+		if f.lock != LOCK_SHARED {
+			panic(errutil.AssertErr())
+		}
+		if err := osGetReservedLock(f.File); err != nil {
+			return err
+		}
+		f.lock = LOCK_RESERVED
+		return nil
+
+	case LOCK_EXCLUSIVE:
+		// Must be SHARED, RESERVED or PENDING to get EXCLUSIVE.
+		if f.lock <= LOCK_NONE || f.lock >= LOCK_EXCLUSIVE {
+			panic(errutil.AssertErr())
+		}
+		if err := osGetExclusiveLock(f.File, &f.lock); err != nil {
+			return err
+		}
+		f.lock = LOCK_EXCLUSIVE
+		return nil
+
+	default:
+		panic(errutil.AssertErr())
+	}
+}
+
+func (f *vfsFile) Unlock(lock LockLevel) error {
+	switch {
+	case lock != LOCK_NONE && lock != LOCK_SHARED:
+		// Argument check.
+		panic(errutil.AssertErr())
+	case f.lock < LOCK_NONE || f.lock > LOCK_EXCLUSIVE:
+		// Connection state check.
+		panic(errutil.AssertErr())
+	}
+
+	// If we don't have a more restrictive lock, do nothing.
+	if f.lock <= lock {
+		return nil
+	}
+
+	switch lock {
+	case LOCK_SHARED:
+		err := osDowngradeLock(f.File, f.lock)
+		f.lock = LOCK_SHARED
+		return err
+
+	case LOCK_NONE:
+		err := osReleaseLock(f.File, f.lock)
+		f.lock = LOCK_NONE
+		return err
+
+	default:
+		panic(errutil.AssertErr())
+	}
+}
+
+func (f *vfsFile) CheckReservedLock() (bool, error) {
+	// Connection state check.
+	if f.lock < LOCK_NONE || f.lock > LOCK_EXCLUSIVE {
+		panic(errutil.AssertErr())
+	}
+
+	if f.lock >= LOCK_RESERVED {
+		return true, nil
+	}
+	return osCheckReservedLock(f.File)
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/lock_other.go

@@ -0,0 +1,23 @@
+//go:build !(linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock || sqlite3_dotlk)
+
+package vfs
+
+// SupportsFileLocking is false on platforms that do not support file locking.
+// To open a database file on those platforms,
+// you need to use the [nolock] or [immutable] URI parameters.
+//
+// [nolock]: https://sqlite.org/uri.html#urinolock
+// [immutable]: https://sqlite.org/uri.html#uriimmutable
+const SupportsFileLocking = false
+
+func (f *vfsFile) Lock(LockLevel) error {
+	return _IOERR_LOCK
+}
+
+func (f *vfsFile) Unlock(LockLevel) error {
+	return _IOERR_UNLOCK
+}
+
+func (f *vfsFile) CheckReservedLock() (bool, error) {
+	return false, _IOERR_CHECKRESERVEDLOCK
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/map.go

@@ -0,0 +1,63 @@
+//go:build linux || darwin || freebsd
+
+package vfs
+
+import (
+	"os"
+
+	"github.com/ncruces/go-sqlite3/internal/sqlite3_wrap"
+)
+
+func (f *vfsFile) MemoryMapper() MemoryMapper { return f.mmap }
+
+// NewMemoryMapper returns a memory mapper for the given file.
+// It will return nil if file mapping is not supported,
+// or not appropriate for the given flags.
+// Only databases use memory mapping.
+func NewMemoryMapper(file *os.File, flags OpenFlag) MemoryMapper {
+	if flags&(OPEN_MAIN_DB|OPEN_TEMP_DB|OPEN_TRANSIENT_DB) == 0 || flags&OPEN_MEMORY != 0 {
+		return nil
+	}
+	return &vfsMapper{File: file}
+}
+
+type vfsMapper struct {
+	*os.File
+	mmap *sqlite3_wrap.MappedRegion
+	size int32
+}
+
+func (m *vfsMapper) mmapSize(wrp *sqlite3_wrap.Wrapper, p ptr_t) {
+	size := int64(wrp.Read64(p))
+	wrp.Write64(p, uint64(m.size))
+	if size >= 0 && m.mmap == nil {
+		m.size = int32(min(size, 1024*1024*1024))
+	}
+}
+
+func (m *vfsMapper) fetch(wrp *sqlite3_wrap.Wrapper, iOfst int64, iAmt int32, pp ptr_t) error {
+	var ptr ptr_t
+	if iOfst+int64(iAmt)+256 <= int64(m.size) {
+		if m.mmap == nil {
+			var err error
+			m.mmap, err = wrp.MapRegion(m.File, 0, m.size, true)
+			if err != nil {
+				return err
+			}
+		}
+		if m.mmap != nil {
+			ptr = m.mmap.Ptr + ptr_t(iOfst)
+		}
+	}
+	wrp.Write32(pp, uint32(ptr))
+	return nil
+}
+
+func (m *vfsMapper) Close() error {
+	c := m.mmap
+	if c == nil {
+		return nil
+	}
+	m.mmap = nil
+	return c.Unmap()
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/map_other.go

@@ -0,0 +1,13 @@
+//go:build !(linux || darwin || freebsd)
+
+package vfs
+
+import "os"
+
+// NewMemoryMapper returns a memory mapper for the given file.
+// It will return nil if file mapping is not supported,
+// or not appropriate for the given flags.
+// Only databases use memory mapping.
+func NewMemoryMapper(file *os.File, flags OpenFlag) MemoryMapper {
+	return nil
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/os_bsd.go

@@ -0,0 +1,110 @@
+//go:build ((freebsd || openbsd || netbsd || dragonfly || illumos) && !sqlite3_dotlk) || sqlite3_flock
+
+package vfs
+
+import (
+	"os"
+
+	"golang.org/x/sys/unix"
+)
+
+func osGetSharedLock(file *os.File) error {
+	return osFlock(file, unix.LOCK_SH|unix.LOCK_NB, _IOERR_RDLOCK)
+}
+
+func osGetReservedLock(file *os.File) error {
+	err := osFlock(file, unix.LOCK_EX|unix.LOCK_NB, _IOERR_LOCK)
+	if err == _BUSY {
+		// The documentation states that a lock is upgraded by
+		// releasing the previous lock, then acquiring the new lock.
+		// Going over the source code of various BSDs, though,
+		// with LOCK_NB, the lock is not released,
+		// and EAGAIN is returned holding the shared lock.
+		// Still, if we're already in a transaction, we want to abort it,
+		// so return BUSY_SNAPSHOT here. If there's no transaction active,
+		// SQLite will change this back to SQLITE_BUSY,
+		// and invoke the busy handler if appropriate.
+		return _BUSY_SNAPSHOT
+	}
+	return err
+}
+
+func osGetExclusiveLock(file *os.File, state *LockLevel) error {
+	if *state >= LOCK_RESERVED {
+		return nil
+	}
+	return osGetReservedLock(file)
+}
+
+func osDowngradeLock(file *os.File, _ LockLevel) error {
+	err := osFlock(file, unix.LOCK_SH|unix.LOCK_NB, _IOERR_RDLOCK)
+	if err == _BUSY {
+		// The documentation states that a lock is downgraded by
+		// releasing the previous lock then acquiring the new lock.
+		// Going over the source code of various BSDs, though,
+		// with LOCK_SH|LOCK_NB this should never happen.
+		// Return IOERR_RDLOCK, as BUSY would cause an assert to fail.
+		return _IOERR_RDLOCK
+	}
+	return err
+}
+
+func osReleaseLock(file *os.File, _ LockLevel) error {
+	for {
+		err := unix.Flock(int(file.Fd()), unix.LOCK_UN)
+		if err == nil {
+			return nil
+		}
+		if err != unix.EINTR {
+			return sysError{err, _IOERR_UNLOCK}
+		}
+	}
+}
+
+func osCheckReservedLock(file *os.File) (bool, error) {
+	// Test the RESERVED lock with fcntl(F_GETLK).
+	// This only works on systems where fcntl and flock are compatible.
+	// However, SQLite only calls this while holding a shared lock,
+	// so the difference is immaterial.
+	lock, err := osTestLock(file, _RESERVED_BYTE, 1, _IOERR_CHECKRESERVEDLOCK)
+	return lock == unix.F_WRLCK, err
+}
+
+func osFlock(file *os.File, how int, def _ErrorCode) error {
+	err := unix.Flock(int(file.Fd()), how)
+	return osLockErrorCode(err, def)
+}
+
+func osReadLock(file *os.File, start, len int64) error {
+	return osLock(file, unix.F_RDLCK, start, len, _IOERR_RDLOCK)
+}
+
+func osWriteLock(file *os.File, start, len int64) error {
+	return osLock(file, unix.F_WRLCK, start, len, _IOERR_LOCK)
+}
+
+func osLock(file *os.File, typ int16, start, len int64, def _ErrorCode) error {
+	err := unix.FcntlFlock(file.Fd(), unix.F_SETLK, &unix.Flock_t{
+		Type:  typ,
+		Start: start,
+		Len:   len,
+	})
+	return osLockErrorCode(err, def)
+}
+
+func osUnlock(file *os.File, start, len int64) error {
+	lock := unix.Flock_t{
+		Type:  unix.F_UNLCK,
+		Start: start,
+		Len:   len,
+	}
+	for {
+		err := unix.FcntlFlock(file.Fd(), unix.F_SETLK, &lock)
+		if err == nil {
+			return nil
+		}
+		if err != unix.EINTR {
+			return sysError{err, _IOERR_UNLOCK}
+		}
+	}
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/os_darwin.go

@@ -0,0 +1,131 @@
+//go:build !sqlite3_flock
+
+package vfs
+
+import (
+	"io"
+	"os"
+	"runtime"
+	"time"
+
+	"golang.org/x/sys/unix"
+)
+
+const (
+	// https://github.com/apple/darwin-xnu/blob/main/bsd/sys/fcntl.h
+	_F_OFD_SETLK         = 90
+	_F_OFD_SETLKW        = 91
+	_F_OFD_SETLKWTIMEOUT = 93
+)
+
+type flocktimeout_t struct {
+	fl      unix.Flock_t
+	timeout unix.Timespec
+}
+
+func osSync(file *os.File, open OpenFlag, sync SyncFlag) error {
+	var cmd int
+	if sync&SYNC_FULL == SYNC_FULL {
+		// For rollback journals all we really need is a barrier.
+		if open&OPEN_MAIN_JOURNAL != 0 {
+			cmd = unix.F_BARRIERFSYNC
+		} else {
+			cmd = unix.F_FULLFSYNC
+		}
+	}
+
+	fd := file.Fd()
+	for {
+		err := error(unix.ENOTSUP)
+		if cmd != 0 {
+			_, err = unix.FcntlInt(fd, cmd, 0)
+		}
+		if err == unix.ENOTSUP {
+			err = unix.Fsync(int(fd))
+		}
+		if err != unix.EINTR {
+			return err
+		}
+	}
+}
+
+func osAllocate(file *os.File, size int64) error {
+	if size == 0 {
+		return nil
+	}
+	end, err := file.Seek(0, io.SeekEnd)
+	if err != nil {
+		return err
+	}
+	if end >= size {
+		return nil
+	}
+
+	store := unix.Fstore_t{
+		Flags:   unix.F_ALLOCATEALL | unix.F_ALLOCATECONTIG,
+		Posmode: unix.F_PEOFPOSMODE,
+		Length:  size - end,
+		Offset:  0,
+	}
+
+	// Try once to get a continuous chunk of disk space.
+	if unix.FcntlFstore(file.Fd(), unix.F_PREALLOCATE, &store) != nil {
+		// OK, perhaps we are too fragmented, allocate non-continuous.
+		store.Flags = unix.F_ALLOCATEALL
+		for {
+			err := unix.FcntlFstore(file.Fd(), unix.F_PREALLOCATE, &store)
+			if err == nil {
+				break
+			}
+			if err != unix.EINTR {
+				return err
+			}
+		}
+	}
+	return file.Truncate(size)
+}
+
+func osReadLock(file *os.File, start, len int64, timeout time.Duration) error {
+	return osLock(file, unix.F_RDLCK, start, len, timeout, _IOERR_RDLOCK)
+}
+
+func osWriteLock(file *os.File, start, len int64, timeout time.Duration) error {
+	return osLock(file, unix.F_WRLCK, start, len, timeout, _IOERR_LOCK)
+}
+
+func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, def _ErrorCode) error {
+	lock := &flocktimeout_t{fl: unix.Flock_t{
+		Type:  typ,
+		Start: start,
+		Len:   len,
+	}}
+	var err error
+	switch {
+	case timeout == 0:
+		err = unix.FcntlFlock(file.Fd(), _F_OFD_SETLK, &lock.fl)
+	case timeout < 0:
+		err = unix.FcntlFlock(file.Fd(), _F_OFD_SETLKW, &lock.fl)
+	default:
+		lock.timeout = unix.NsecToTimespec(int64(timeout / time.Nanosecond))
+		err = unix.FcntlFlock(file.Fd(), _F_OFD_SETLKWTIMEOUT, &lock.fl)
+		runtime.KeepAlive(lock)
+	}
+	return osLockErrorCode(err, def)
+}
+
+func osUnlock(file *os.File, start, len int64) error {
+	lock := unix.Flock_t{
+		Type:  unix.F_UNLCK,
+		Start: start,
+		Len:   len,
+	}
+	for {
+		err := unix.FcntlFlock(file.Fd(), _F_OFD_SETLK, &lock)
+		if err == nil {
+			return nil
+		}
+		if err != unix.EINTR {
+			return sysError{err, _IOERR_UNLOCK}
+		}
+	}
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/os_dotlk.go

@@ -0,0 +1,140 @@
+//go:build sqlite3_dotlk
+
+package vfs
+
+import (
+	"errors"
+	"io/fs"
+	"os"
+	"sync"
+
+	"github.com/ncruces/go-sqlite3/internal/dotlk"
+)
+
+var (
+	// +checklocks:vfsDotLocksMtx
+	vfsDotLocks    = map[string]*vfsDotLocker{}
+	vfsDotLocksMtx sync.Mutex
+)
+
+type vfsDotLocker struct {
+	shared   int      // +checklocks:vfsDotLocksMtx
+	pending  *os.File // +checklocks:vfsDotLocksMtx
+	reserved *os.File // +checklocks:vfsDotLocksMtx
+}
+
+func osGetSharedLock(file *os.File) error {
+	vfsDotLocksMtx.Lock()
+	defer vfsDotLocksMtx.Unlock()
+
+	name := file.Name()
+	locker := vfsDotLocks[name]
+	if locker == nil {
+		if err := dotlk.TryLock(name + ".lock"); err != nil {
+			if errors.Is(err, fs.ErrExist) {
+				return _BUSY // Another process has the lock.
+			}
+			return sysError{err, _IOERR_LOCK}
+		}
+		locker = &vfsDotLocker{}
+		vfsDotLocks[name] = locker
+	}
+
+	if locker.pending != nil {
+		return _BUSY
+	}
+	locker.shared++
+	return nil
+}
+
+func osGetReservedLock(file *os.File) error {
+	vfsDotLocksMtx.Lock()
+	defer vfsDotLocksMtx.Unlock()
+
+	name := file.Name()
+	locker := vfsDotLocks[name]
+	if locker == nil {
+		return _IOERR_LOCK
+	}
+
+	if locker.reserved != nil && locker.reserved != file {
+		return _BUSY
+	}
+	locker.reserved = file
+	return nil
+}
+
+func osGetExclusiveLock(file *os.File, _ *LockLevel) error {
+	vfsDotLocksMtx.Lock()
+	defer vfsDotLocksMtx.Unlock()
+
+	name := file.Name()
+	locker := vfsDotLocks[name]
+	if locker == nil {
+		return _IOERR_LOCK
+	}
+
+	if locker.pending != nil && locker.pending != file {
+		return _BUSY
+	}
+	locker.pending = file
+	if locker.shared > 1 {
+		return _BUSY
+	}
+	return nil
+}
+
+func osDowngradeLock(file *os.File, _ LockLevel) error {
+	vfsDotLocksMtx.Lock()
+	defer vfsDotLocksMtx.Unlock()
+
+	name := file.Name()
+	locker := vfsDotLocks[name]
+	if locker == nil {
+		return _IOERR_UNLOCK
+	}
+
+	if locker.reserved == file {
+		locker.reserved = nil
+	}
+	if locker.pending == file {
+		locker.pending = nil
+	}
+	return nil
+}
+
+func osReleaseLock(file *os.File, state LockLevel) error {
+	vfsDotLocksMtx.Lock()
+	defer vfsDotLocksMtx.Unlock()
+
+	name := file.Name()
+	locker := vfsDotLocks[name]
+	if locker == nil {
+		return _IOERR_UNLOCK
+	}
+
+	if locker.shared == 1 {
+		if err := dotlk.Unlock(name + ".lock"); err != nil {
+			return sysError{err, _IOERR_UNLOCK}
+		}
+		delete(vfsDotLocks, name)
+	}
+
+	if locker.reserved == file {
+		locker.reserved = nil
+	}
+	if locker.pending == file {
+		locker.pending = nil
+	}
+	locker.shared--
+	return nil
+}
+
+func osCheckReservedLock(file *os.File) (bool, error) {
+	vfsDotLocksMtx.Lock()
+	defer vfsDotLocksMtx.Unlock()
+
+	name := file.Name()
+	locker := vfsDotLocks[name]
+	return locker != nil && locker.reserved != nil, nil
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/os_f2fs_linux.go

@@ -0,0 +1,56 @@
+//go:build amd64 || arm64 || riscv64
+
+package vfs
+
+import (
+	"os"
+
+	"golang.org/x/sys/unix"
+)
+
+const (
+	// https://godbolt.org/z/1PcK5vea3
+	_F2FS_IOC_START_ATOMIC_WRITE  = 62721
+	_F2FS_IOC_COMMIT_ATOMIC_WRITE = 62722
+	_F2FS_IOC_ABORT_ATOMIC_WRITE  = 62725
+	_F2FS_IOC_GET_FEATURES        = 2147808524 // -2147158772
+	_F2FS_FEATURE_ATOMIC_WRITE    = 4
+)
+
+// notest
+
+func osBatchAtomic(file *os.File) bool {
+	for {
+		flags, err := unix.IoctlGetInt(int(file.Fd()), _F2FS_IOC_GET_FEATURES)
+		if err != unix.EINTR {
+			return err == nil && flags&_F2FS_FEATURE_ATOMIC_WRITE != 0
+		}
+	}
+}
+
+func (f *vfsFile) BeginAtomicWrite() error {
+	for {
+		err := unix.IoctlSetInt(int(f.Fd()), _F2FS_IOC_START_ATOMIC_WRITE, 0)
+		if err != unix.EINTR {
+			return err
+		}
+	}
+}
+
+func (f *vfsFile) CommitAtomicWrite() error {
+	for {
+		err := unix.IoctlSetInt(int(f.Fd()), _F2FS_IOC_COMMIT_ATOMIC_WRITE, 0)
+		if err != unix.EINTR {
+			return err
+		}
+	}
+}
+
+func (f *vfsFile) RollbackAtomicWrite() error {
+	for {
+		err := unix.IoctlSetInt(int(f.Fd()), _F2FS_IOC_ABORT_ATOMIC_WRITE, 0)
+		if err != unix.EINTR {
+			return err
+		}
+	}
+}