typenative 0.1.2 → 0.2.0

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

@@ -0,0 +1,258 @@
+//go:build ((freebsd || openbsd || netbsd || dragonfly || illumos) && !sqlite3_dotlk) || sqlite3_flock
+
+package vfs
+
+import (
+	"cmp"
+	"errors"
+	"io"
+	"io/fs"
+	"os"
+	"sync"
+	"sync/atomic"
+
+	"golang.org/x/sys/unix"
+
+	"github.com/ncruces/go-sqlite3/internal/errutil"
+	"github.com/ncruces/go-sqlite3/internal/sqlite3_wrap"
+)
+
+type vfsShmParent struct {
+	*os.File
+	info os.FileInfo
+
+	refs int // +checklocks:vfsShmListMtx
+
+	lock [_SHM_NLOCK]int8 // +checklocks:Mutex
+	sync.Mutex
+}
+
+var (
+	// +checklocks:vfsShmListMtx
+	vfsShmList    []*vfsShmParent
+	vfsShmListMtx sync.Mutex
+)
+
+type vfsShm struct {
+	*vfsShmParent
+	path    string
+	lock    [_SHM_NLOCK]bool
+	regions []*sqlite3_wrap.MappedRegion
+}
+
+func (s *vfsShm) Close() error {
+	if s.vfsShmParent == nil {
+		return nil
+	}
+
+	vfsShmListMtx.Lock()
+	defer vfsShmListMtx.Unlock()
+
+	// Unlock everything.
+	s.shmLock(0, _SHM_NLOCK, _SHM_UNLOCK)
+
+	// Decrease reference count.
+	if s.vfsShmParent.refs > 0 {
+		s.vfsShmParent.refs--
+		s.vfsShmParent = nil
+		return nil
+	}
+
+	err := s.File.Close()
+	for i, g := range vfsShmList {
+		if g == s.vfsShmParent {
+			vfsShmList[i] = nil
+			s.vfsShmParent = nil
+			return err
+		}
+	}
+	panic(errutil.AssertErr())
+}
+
+func (s *vfsShm) shmOpen() (err error) {
+	if s.vfsShmParent != nil {
+		return nil
+	}
+
+	vfsShmListMtx.Lock()
+	defer vfsShmListMtx.Unlock()
+
+	// Stat file without opening it.
+	// Closing it would release all POSIX locks on it.
+	fi, err := os.Stat(s.path)
+	if err != nil && !errors.Is(err, fs.ErrNotExist) {
+		return sysError{err, _IOERR_FSTAT}
+	}
+
+	// Find a shared file, increase the reference count.
+	for _, g := range vfsShmList {
+		if g != nil && os.SameFile(fi, g.info) {
+			s.vfsShmParent = g
+			g.refs++
+			return nil
+		}
+	}
+
+	// Always open file read-write, as it will be shared.
+	f, err := os.OpenFile(s.path,
+		os.O_RDWR|os.O_CREATE|_O_NOFOLLOW, 0666)
+	if err != nil {
+		return sysError{err, _CANTOPEN}
+	}
+	defer func() {
+		if err != nil {
+			f.Close()
+		}
+	}()
+
+	// Dead man's switch.
+	if lock, err := osTestLock(f, _SHM_DMS, 1, _IOERR_LOCK); err != nil {
+		return err
+	} else if lock == unix.F_WRLCK {
+		return _BUSY
+	} else if lock == unix.F_UNLCK {
+		if err := osWriteLock(f, _SHM_DMS, 1); err != nil {
+			return err
+		}
+		if err := f.Truncate(0); err != nil {
+			return sysError{err, _IOERR_SHMOPEN}
+		}
+	}
+	if err := osReadLock(f, _SHM_DMS, 1); err != nil {
+		return err
+	}
+
+	fi, err = f.Stat()
+	if err != nil {
+		return sysError{err, _IOERR_FSTAT}
+	}
+
+	// Add the new shared file.
+	s.vfsShmParent = &vfsShmParent{
+		File: f,
+		info: fi,
+	}
+	for i, g := range vfsShmList {
+		if g == nil {
+			vfsShmList[i] = s.vfsShmParent
+			return nil
+		}
+	}
+	vfsShmList = append(vfsShmList, s.vfsShmParent)
+	return nil
+}
+
+func (s *vfsShm) shmMap(wrp *sqlite3_wrap.Wrapper, id, size int32, extend bool) (ptr_t, error) {
+	// Ensure pages are reasonably sized.
+	if unix.Getpagesize() > int(size)*2 {
+		return 0, _IOERR_SHMMAP
+	}
+
+	if err := s.shmOpen(); err != nil {
+		return 0, err
+	}
+
+	// Check if file is big enough.
+	o, err := s.Seek(0, io.SeekEnd)
+	if err != nil {
+		return 0, sysError{err, _IOERR_SHMSIZE}
+	}
+	if n := (int64(id) + 1) * int64(size); n > o {
+		if !extend {
+			return 0, nil
+		}
+		if err := osAllocate(s.File, n); err != nil {
+			return 0, sysError{err, _IOERR_SHMSIZE}
+		}
+	}
+
+	r, err := wrp.MapRegion(s.File, int64(id)*int64(size), size, false)
+	if err != nil {
+		return 0, err
+	}
+	if r == nil {
+		return 0, _IOERR_NOMEM
+	}
+	s.regions = append(s.regions, r)
+	return r.Ptr, nil
+}
+
+func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) error {
+	if s.vfsShmParent == nil {
+		return _IOERR_SHMLOCK
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	// Check if we can obtain/release locks locally.
+	err := s.shmMemLock(offset, n, flags)
+	if err != nil {
+		return err
+	}
+
+	// Obtain/release the appropriate file locks.
+	switch {
+	case flags&_SHM_UNLOCK != 0:
+		// Relasing a shared lock decrements the counter,
+		// but may leave parts of the range still locked.
+		begin, end := offset, offset+n
+		for i := begin; i < end; i++ {
+			if s.vfsShmParent.lock[i] != 0 {
+				if i > begin {
+					err = cmp.Or(err,
+						osUnlock(s.File, _SHM_BASE+int64(begin), int64(i-begin)))
+				}
+				begin = i + 1
+			}
+		}
+		if end > begin {
+			err = cmp.Or(err,
+				osUnlock(s.File, _SHM_BASE+int64(begin), int64(end-begin)))
+		}
+		return err
+	case flags&_SHM_SHARED != 0:
+		// Acquiring a new shared lock on the file is only necessary
+		// if there was a new shared lock in the range.
+		for i := offset; i < offset+n; i++ {
+			if s.vfsShmParent.lock[i] == 1 {
+				err = osReadLock(s.File, _SHM_BASE+int64(offset), int64(n))
+				break
+			}
+		}
+	case flags&_SHM_EXCLUSIVE != 0:
+		// Acquiring an exclusive lock on the file is always necessary.
+		err = osWriteLock(s.File, _SHM_BASE+int64(offset), int64(n))
+	default:
+		panic(errutil.AssertErr())
+	}
+
+	if err != nil {
+		// Release the local locks we had acquired.
+		s.shmMemLock(offset, n, flags^(_SHM_UNLOCK|_SHM_LOCK))
+	}
+	return err
+}
+
+func (s *vfsShm) shmUnmap(delete bool) {
+	if s.vfsShmParent == nil {
+		return
+	}
+
+	// Unmap regions.
+	for _, r := range s.regions {
+		r.Unmap()
+	}
+	s.regions = nil
+
+	// Close the file.
+	if delete {
+		os.Remove(s.path)
+	}
+	s.Close()
+}
+
+func (s *vfsShm) shmBarrier() {
+	var b atomic.Bool
+	b.Swap(true)
+}

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

@@ -0,0 +1,90 @@
+//go:build sqlite3_dotlk
+
+package vfs
+
+import (
+	"sync/atomic"
+	"unsafe"
+)
+
+const (
+	_WALINDEX_HDR_SIZE = 136
+	_WALINDEX_PGSZ     = 32768
+)
+
+// This seems a safe way of keeping the WAL-index in sync.
+//
+// The WAL-index file starts with a header,
+// and the index doesn't meaningfully change if the header doesn't change.
+//
+// The header starts with two 48 byte, checksummed, copies of the same information,
+// which are accessed independently between memory barriers.
+// The checkpoint information that follows uses 4 byte aligned words.
+//
+// Finally, we have the WAL-index hash tables,
+// which are only modified holding the exclusive WAL_WRITE_LOCK.
+//
+// Since all the data is either redundant+checksummed,
+// 4 byte aligned, or modified under an exclusive lock,
+// the copies below should correctly keep memory in sync.
+//
+// https://sqlite.org/walformat.html#the_wal_index_file_format
+
+func (s *vfsShm) shmAcquire(errp *error) {
+	if errp != nil && *errp != nil {
+		return
+	}
+	if len(s.ptrs) == 0 || shmEqual(s.shadow[0][:], s.shared[0][:]) {
+		return
+	}
+	// Copies modified words from shared to private memory.
+	for id, p := range s.ptrs {
+		shared := shmPage(s.shared[id][:])
+		shadow := shmPage(s.shadow[id][:])
+		privat := shmPage(s.wrp.Bytes(p, _WALINDEX_PGSZ))
+		for i, shared := range shared {
+			if shadow[i] != shared {
+				shadow[i] = shared
+				privat[i] = shared
+			}
+		}
+	}
+}
+
+func (s *vfsShm) shmRelease() {
+	if len(s.ptrs) == 0 || shmEqual(s.shadow[0][:], s.wrp.Bytes(s.ptrs[0], _WALINDEX_HDR_SIZE)) {
+		return
+	}
+	// Copies modified words from private to shared memory.
+	for id, p := range s.ptrs {
+		shared := shmPage(s.shared[id][:])
+		shadow := shmPage(s.shadow[id][:])
+		privat := shmPage(s.wrp.Bytes(p, _WALINDEX_PGSZ))
+		for i, privat := range privat {
+			if shadow[i] != privat {
+				shadow[i] = privat
+				shared[i] = privat
+			}
+		}
+	}
+}
+
+func (s *vfsShm) shmBarrier() {
+	var b atomic.Bool
+	s.Lock()
+	s.shmAcquire(nil)
+	b.Swap(true)
+	s.shmRelease()
+	s.Unlock()
+}
+
+//go:nosplit
+func shmPage(s []byte) *[_WALINDEX_PGSZ / 4]uint32 {
+	p := (*uint32)(unsafe.Pointer(unsafe.SliceData(s)))
+	return (*[_WALINDEX_PGSZ / 4]uint32)(unsafe.Slice(p, _WALINDEX_PGSZ/4))
+}
+
+//go:nosplit
+func shmEqual(v1, v2 []byte) bool {
+	return *(*[_WALINDEX_HDR_SIZE]byte)(v1[:]) == *(*[_WALINDEX_HDR_SIZE]byte)(v2[:])
+}

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

@@ -0,0 +1,168 @@
+//go:build sqlite3_dotlk
+
+package vfs
+
+import (
+	"errors"
+	"io/fs"
+	"sync"
+
+	"github.com/ncruces/go-sqlite3/internal/dotlk"
+	"github.com/ncruces/go-sqlite3/internal/sqlite3_wrap"
+)
+
+type vfsShmParent struct {
+	shared [][_WALINDEX_PGSZ]byte
+	refs   int // +checklocks:vfsShmListMtx
+
+	lock [_SHM_NLOCK]int8 // +checklocks:Mutex
+	sync.Mutex
+}
+
+var (
+	// +checklocks:vfsShmListMtx
+	vfsShmList    = map[string]*vfsShmParent{}
+	vfsShmListMtx sync.Mutex
+)
+
+type vfsShm struct {
+	*vfsShmParent
+	wrp    *sqlite3_wrap.Wrapper
+	path   string
+	shadow [][_WALINDEX_PGSZ]byte
+	ptrs   []ptr_t
+	lock   [_SHM_NLOCK]bool
+}
+
+func (s *vfsShm) Close() error {
+	if s.vfsShmParent == nil {
+		return nil
+	}
+
+	vfsShmListMtx.Lock()
+	defer vfsShmListMtx.Unlock()
+
+	// Unlock everything.
+	s.shmLock(0, _SHM_NLOCK, _SHM_UNLOCK)
+
+	// Decrease reference count.
+	if s.vfsShmParent.refs > 0 {
+		s.vfsShmParent.refs--
+		s.vfsShmParent = nil
+		return nil
+	}
+
+	if err := dotlk.Unlock(s.path); err != nil {
+		return sysError{err, _IOERR_UNLOCK}
+	}
+	delete(vfsShmList, s.path)
+	s.vfsShmParent = nil
+	return nil
+}
+
+func (s *vfsShm) shmOpen() error {
+	if s.vfsShmParent != nil {
+		return nil
+	}
+
+	vfsShmListMtx.Lock()
+	defer vfsShmListMtx.Unlock()
+
+	// Find a shared buffer, increase the reference count.
+	if g, ok := vfsShmList[s.path]; ok {
+		s.vfsShmParent = g
+		g.refs++
+		return nil
+	}
+
+	// Dead man's switch.
+	err := dotlk.LockShm(s.path)
+	if errors.Is(err, fs.ErrExist) {
+		return _BUSY
+	}
+	if err != nil {
+		return sysError{err, _IOERR_LOCK}
+	}
+
+	// Add the new shared buffer.
+	s.vfsShmParent = &vfsShmParent{}
+	vfsShmList[s.path] = s.vfsShmParent
+	return nil
+}
+
+func (s *vfsShm) shmMap(wrp *sqlite3_wrap.Wrapper, id, size int32, extend bool) (ptr_t, error) {
+	if size != _WALINDEX_PGSZ {
+		return 0, _IOERR_SHMMAP
+	}
+	if s.wrp == nil {
+		s.wrp = wrp
+	}
+	if err := s.shmOpen(); err != nil {
+		return 0, err
+	}
+
+	s.Lock()
+	defer s.Unlock()
+	defer s.shmAcquire(nil)
+
+	// Extend shared memory.
+	if int(id) >= len(s.shared) {
+		if !extend {
+			return 0, nil
+		}
+		s.shared = append(s.shared, make([][_WALINDEX_PGSZ]byte, int(id)-len(s.shared)+1)...)
+	}
+
+	// Allocate shadow memory.
+	if int(id) >= len(s.shadow) {
+		s.shadow = append(s.shadow, make([][_WALINDEX_PGSZ]byte, int(id)-len(s.shadow)+1)...)
+	}
+
+	// Allocate local memory.
+	for int(id) >= len(s.ptrs) {
+		ptr := wrp.Xsqlite3_malloc64(int64(size))
+		if ptr == 0 {
+			return 0, _IOERR_NOMEM
+		}
+		clear(wrp.Bytes(ptr_t(ptr), _WALINDEX_PGSZ))
+		s.ptrs = append(s.ptrs, ptr_t(ptr))
+	}
+
+	s.shadow[0][4] = 1
+	return s.ptrs[id], nil
+}
+
+func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) (err error) {
+	if s.vfsShmParent == nil {
+		return _IOERR_SHMLOCK
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	switch {
+	case flags&_SHM_LOCK != 0:
+		defer s.shmAcquire(&err)
+	case flags&_SHM_EXCLUSIVE != 0:
+		s.shmRelease()
+	}
+
+	return s.shmMemLock(offset, n, flags)
+}
+
+func (s *vfsShm) shmUnmap(delete bool) {
+	if s.vfsShmParent == nil {
+		return
+	}
+	defer s.Close()
+
+	s.Lock()
+	s.shmRelease()
+	defer s.Unlock()
+
+	for _, p := range s.ptrs {
+		s.wrp.Xsqlite3_free(int32(p))
+	}
+	s.ptrs = nil
+	s.shadow = nil
+}

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

@@ -0,0 +1,52 @@
+//go:build freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock || sqlite3_dotlk
+
+package vfs
+
+import "github.com/ncruces/go-sqlite3/internal/errutil"
+
+// +checklocks:s.Mutex
+func (s *vfsShm) shmMemLock(offset, n int32, flags _ShmFlag) error {
+	switch {
+	case flags&_SHM_UNLOCK != 0:
+		for i := offset; i < offset+n; i++ {
+			if s.lock[i] {
+				if s.vfsShmParent.lock[i] <= 0 {
+					s.vfsShmParent.lock[i] = 0
+				} else {
+					s.vfsShmParent.lock[i]--
+				}
+				s.lock[i] = false
+			}
+		}
+	case flags&_SHM_SHARED != 0:
+		for i := offset; i < offset+n; i++ {
+			if !s.lock[i] &&
+				s.vfsShmParent.lock[i]+1 <= 0 {
+				return _BUSY
+			}
+		}
+		for i := offset; i < offset+n; i++ {
+			if !s.lock[i] {
+				s.vfsShmParent.lock[i]++
+				s.lock[i] = true
+			}
+		}
+	case flags&_SHM_EXCLUSIVE != 0:
+		for i := offset; i < offset+n; i++ {
+			if s.lock[i] {
+				// SQLite never requests an exclusive lock that it already holds.
+				panic(errutil.AssertErr())
+			}
+			if s.vfsShmParent.lock[i] != 0 {
+				return _BUSY
+			}
+		}
+		for i := offset; i < offset+n; i++ {
+			s.vfsShmParent.lock[i] = -1
+			s.lock[i] = true
+		}
+	default:
+		panic(errutil.AssertErr())
+	}
+	return nil
+}