typenative 0.1.2 → 0.2.0

package/govendor/github.com/ncruces/go-sqlite3/internal/sqlite3_wrap/mem_windows.go

@@ -0,0 +1,149 @@
+package sqlite3_wrap
+
+import (
+	"math"
+	"unsafe"
+
+	"golang.org/x/sys/windows"
+)
+
+type Memory struct {
+	Buf     []byte
+	Max     int64
+	pieces  []uintptr
+	regions []*MappedRegion
+	ptr     uintptr
+}
+
+func (m *Memory) Slice() *[]byte {
+	return &m.Buf
+}
+
+func (m *Memory) Grow(delta, max int64) int64 {
+	if m.Buf == nil {
+		m.allocate(uint64(m.Max) << 16)
+	}
+
+	len := int64(len(m.Buf))
+	old := len >> 16
+	if delta == 0 {
+		return old
+	}
+	new := old + delta
+	max = min(max, m.Max, int64(math.MaxInt)>>16)
+	if new > max || new < old {
+		return -1
+	}
+	m.commit(uint64(new) << 16)
+	return old
+}
+
+func (m *Memory) allocate(max uint64) {
+	if !placeholdersSupported() {
+		return
+	}
+
+	if max > math.MaxInt {
+		// This ensures uintptr(max) overflows to a large value,
+		// and VirtualAlloc2 returns an error.
+		max = math.MaxUint64
+	}
+
+	// Reserve max bytes of address space, to ensure we won't need to move it.
+	// Use virtual memory placeholders so we can later map files.
+	// https://devblogs.microsoft.com/oldnewthing/?p=109346
+	r, err := virtualAlloc2(0, uintptr(max),
+		windows.MEM_RESERVE|_MEM_RESERVE_PLACEHOLDER, windows.PAGE_NOACCESS)
+	if err != nil {
+		panic(err)
+	}
+	m.pieces = append(m.pieces, 0)
+	m.ptr = r
+
+	ptr := *(*unsafe.Pointer)(unsafe.Pointer(&m.ptr))
+	m.Buf = unsafe.Slice((*byte)(ptr), max)[:0]
+}
+
+func (m *Memory) commit(size uint64) {
+	if m.ptr == 0 {
+		m.Buf = append(m.Buf, make([]byte, size-uint64(len(m.Buf)))...)
+		return
+	}
+
+	com := uint64(len(m.Buf))
+	res := uint64(cap(m.Buf))
+	if com < size && size <= res {
+		// Split the trailing placeholder.
+		if size < res {
+			err := windows.VirtualFree(m.ptr+uintptr(com), uintptr(size-com),
+				windows.MEM_RELEASE|_MEM_PRESERVE_PLACEHOLDER)
+			if err != nil {
+				panic(err)
+			}
+			m.pieces = append(m.pieces, uintptr(size))
+		}
+		// Replace the placeholder with committed memory.
+		_, err := virtualAlloc2(m.ptr+uintptr(com), uintptr(size-com),
+			windows.MEM_COMMIT|windows.MEM_RESERVE|_MEM_REPLACE_PLACEHOLDER, windows.PAGE_READWRITE)
+		if err != nil {
+			panic(err)
+		}
+	}
+	m.Buf = m.Buf[:size]
+}
+
+func (m *Memory) reserve(size int64) int64 {
+	if m.ptr == 0 || size <= 0 {
+		return 0
+	}
+
+	com := int64(len(m.Buf))
+	res := int64(cap(m.Buf))
+	new := com + size
+
+	if new > res || new < com {
+		return 0
+	}
+
+	// Split the trailing placeholder.
+	if new < res {
+		err := windows.VirtualFree(m.ptr+uintptr(com), uintptr(new-com),
+			windows.MEM_RELEASE|_MEM_PRESERVE_PLACEHOLDER)
+		if err != nil {
+			panic(err)
+		}
+		m.pieces = append(m.pieces, uintptr(new))
+	}
+	m.Buf = m.Buf[:new]
+	return com
+}
+
+func (m *Memory) Close() (err error) {
+	if m.ptr == 0 {
+		m.Buf = nil
+		return nil
+	}
+
+	for _, r := range m.regions {
+		e := r.Close()
+		if err == nil {
+			err = e
+		}
+	}
+
+	for _, off := range m.pieces {
+		e := windows.VirtualFree(m.ptr+off, 0, windows.MEM_RELEASE)
+		if err == nil {
+			err = e
+		}
+	}
+
+	m.Buf = nil
+	m.pieces = nil
+	m.regions = nil
+	m.ptr = 0
+	return err
+}
+
+// CanMapFiles reports whether file views can be mapped into this memory.
+func (m *Memory) CanMapFiles() bool { return m.ptr != 0 }

package/govendor/github.com/ncruces/go-sqlite3/internal/sqlite3_wrap/mmap_unix.go

@@ -0,0 +1,80 @@
+//go:build unix
+
+package sqlite3_wrap
+
+import (
+	"os"
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+)
+
+func (w *Wrapper) MapRegion(f *os.File, offset int64, size int32, readOnly bool) (*MappedRegion, error) {
+	pageSize := int64(unix.Getpagesize())
+	align := offset & (pageSize - 1)
+	size += int32(align + pageSize - 1)
+	size &^= int32(pageSize - 1)
+
+	r := w.newRegion(size)
+	if r == nil {
+		return nil, nil
+	}
+	if err := r.mmap(f, offset-align, readOnly); err != nil {
+		return nil, err
+	}
+	r.Ptr = r.base + Ptr_t(align)
+	return r, nil
+}
+
+func (w *Wrapper) newRegion(size int32) *MappedRegion {
+	// Find unused region.
+	for _, r := range w.regions {
+		if !r.used && r.size == size {
+			return r
+		}
+	}
+
+	// Allocate page aligned memmory.
+	ptr := Ptr_t(w.Xmemalign(int32(unix.Getpagesize()), size))
+	if ptr == 0 {
+		return nil
+	}
+
+	// Save the newly allocated region.
+	ret := &MappedRegion{
+		base: ptr,
+		size: size,
+		addr: unsafe.Pointer(&w.Buf[ptr]),
+	}
+	w.regions = append(w.regions, ret)
+	return ret
+}
+
+type MappedRegion struct {
+	addr unsafe.Pointer
+	base Ptr_t
+	Ptr  Ptr_t
+	size int32
+	used bool
+}
+
+func (r *MappedRegion) Unmap() error {
+	// We can't munmap the region, otherwise it could be remapped by the runtime.
+	// Instead, map anonymous (zeroed) pages readonly.
+	// If successful, the region can be reused for a subsequent mmap.
+	_, err := unix.MmapPtr(-1, 0, r.addr, uintptr(r.size),
+		unix.PROT_READ, unix.MAP_PRIVATE|unix.MAP_FIXED|unix.MAP_ANON)
+	r.used = err != nil
+	return err
+}
+
+func (r *MappedRegion) mmap(f *os.File, offset int64, readOnly bool) error {
+	prot := unix.PROT_READ
+	if !readOnly {
+		prot |= unix.PROT_WRITE
+	}
+	_, err := unix.MmapPtr(int(f.Fd()), offset, r.addr, uintptr(r.size),
+		prot, unix.MAP_SHARED|unix.MAP_FIXED)
+	r.used = err == nil
+	return err
+}

package/govendor/github.com/ncruces/go-sqlite3/internal/sqlite3_wrap/mmap_windows.go

@@ -0,0 +1,129 @@
+package sqlite3_wrap
+
+import (
+	"os"
+	"unsafe"
+
+	"golang.org/x/sys/windows"
+)
+
+func (w *Wrapper) MapRegion(f *os.File, offset int64, size int32, readOnly bool) (*MappedRegion, error) {
+	align := offset & (allocationGranularity - 1)
+	size += int32(align + allocationGranularity - 1)
+	size &^= int32(allocationGranularity - 1)
+
+	r := w.newRegion(size)
+	if r == nil {
+		return nil, nil
+	}
+	if err := r.mmap(f, offset-align, readOnly); err != nil {
+		return nil, err
+	}
+	r.Ptr = r.base + Ptr_t(align)
+	return r, nil
+}
+
+func (w *Wrapper) newRegion(size int32) *MappedRegion {
+	// Find unused region.
+	for _, r := range w.regions {
+		if !r.file && r.size == size {
+			return r
+		}
+	}
+
+	// Reserve page aligned memmory.
+	ptr := Ptr_t(w.reserve(int64(size)))
+	if ptr == 0 {
+		return nil
+	}
+
+	// Save the newly reserved region.
+	ret := &MappedRegion{
+		base: ptr,
+		size: size,
+		addr: uintptr(unsafe.Pointer(&w.Buf[ptr])),
+	}
+	w.regions = append(w.regions, ret)
+	return ret
+}
+
+type MappedRegion struct {
+	addr uintptr
+	base Ptr_t
+	Ptr  Ptr_t
+	size int32
+	file bool
+	zero bool
+}
+
+func (r *MappedRegion) Close() error {
+	if !r.file && !r.zero {
+		return nil
+	}
+
+	// Convert the file view back to a placeholder.
+	err := unmapViewOfFile2(r.addr, _MEM_PRESERVE_PLACEHOLDER)
+	if err != nil {
+		return err
+	}
+	r.file = false
+	r.zero = false
+	return nil
+}
+
+func (r *MappedRegion) Unmap() error {
+	err := r.Close()
+	if err != nil {
+		return err
+	}
+
+	err = mmapZero(r.addr, r.size)
+	r.zero = err == nil
+	return err
+}
+
+func (r *MappedRegion) mmap(f *os.File, offset int64, readOnly bool) error {
+	err := r.Close()
+	if err != nil {
+		return err
+	}
+
+	prot := uint32(windows.PAGE_READWRITE)
+	if readOnly {
+		prot = windows.PAGE_READONLY
+	}
+	err = mmapFile(f, offset, r.addr, r.size, prot)
+	r.file = err == nil
+	return err
+}
+
+func mmapFile(f *os.File, offset int64, addr uintptr, size int32, prot uint32) error {
+	maxSize := offset + int64(size)
+
+	h, err := windows.CreateFileMapping(
+		windows.Handle(f.Fd()), nil, prot,
+		uint32(maxSize>>32), uint32(maxSize), nil)
+	if h == 0 {
+		return err
+	}
+	defer windows.CloseHandle(h)
+
+	_, err = mapViewOfFile3(h, addr, uint64(offset), uintptr(size),
+		_MEM_REPLACE_PLACEHOLDER, prot)
+	return err
+}
+
+func mmapZero(addr uintptr, size int32) error {
+	maxSize := uint64(size)
+	h, err := windows.CreateFileMapping(
+		^windows.Handle(0), nil, windows.PAGE_READONLY,
+		uint32(maxSize>>32), uint32(maxSize), nil)
+	if h == 0 {
+		return err
+	}
+	defer windows.CloseHandle(h)
+
+	_, err = mapViewOfFile3(h, addr, 0, uintptr(size),
+		_MEM_REPLACE_PLACEHOLDER, windows.PAGE_READONLY)
+	return err
+}

package/govendor/github.com/ncruces/go-sqlite3/internal/sqlite3_wrap/sys_windows.go

@@ -0,0 +1,60 @@
+package sqlite3_wrap
+
+import "golang.org/x/sys/windows"
+
+// https://devblogs.microsoft.com/oldnewthing/?p=42223
+const allocationGranularity = 64 * 1024
+
+const (
+	_MEM_PRESERVE_PLACEHOLDER = 0x00000002
+	_MEM_REPLACE_PLACEHOLDER  = 0x00004000
+	_MEM_RESERVE_PLACEHOLDER  = 0x00040000
+)
+
+var (
+	kernelbase           = windows.NewLazySystemDLL("kernelbase.dll")
+	procVirtualAlloc2    = kernelbase.NewProc("VirtualAlloc2")
+	procMapViewOfFile3   = kernelbase.NewProc("MapViewOfFile3")
+	procUnmapViewOfFile2 = kernelbase.NewProc("UnmapViewOfFile2")
+)
+
+// Reports whether the placeholder APIs are available
+// (Windows 10 1803+ / Server 2019+).
+func placeholdersSupported() bool {
+	return procVirtualAlloc2.Find() == nil &&
+		procMapViewOfFile3.Find() == nil &&
+		procUnmapViewOfFile2.Find() == nil
+}
+
+func virtualAlloc2(address, size uintptr, alloctype, protect uint32) (addr uintptr, err error) {
+	addr, _, err = procVirtualAlloc2.Call(
+		^uintptr(0), // current process pseudo handle
+		address, size, uintptr(alloctype), uintptr(protect),
+		0, 0) // no extended parameters
+	if addr == 0 {
+		return 0, err
+	}
+	return addr, nil
+}
+
+func mapViewOfFile3(handle windows.Handle, address uintptr, offset uint64, size uintptr, alloctype, protect uint32) (addr uintptr, err error) {
+	addr, _, err = procMapViewOfFile3.Call(
+		uintptr(handle),
+		^uintptr(0), // current process pseudo handle
+		address, uintptr(offset), size, uintptr(alloctype), uintptr(protect),
+		0, 0) // no extended parameters
+	if addr == 0 {
+		return 0, err
+	}
+	return addr, nil
+}
+
+func unmapViewOfFile2(addr uintptr, flags uint32) (err error) {
+	r, _, err := procUnmapViewOfFile2.Call(
+		^uintptr(0), // current process pseudo handle
+		addr, uintptr(flags))
+	if r == 0 {
+		return err
+	}
+	return nil
+}

package/govendor/github.com/ncruces/go-sqlite3/internal/sqlite3_wrap/wrap.go

@@ -0,0 +1,82 @@
+package sqlite3_wrap
+
+import (
+	"io"
+
+	sqlite3_wasm "github.com/ncruces/go-sqlite3-wasm/v6"
+	"github.com/ncruces/go-sqlite3/internal/errutil"
+)
+
+type Wrapper struct {
+	*sqlite3_wasm.Module
+	*Memory
+	DB       any
+	SysError error
+
+	handles []any
+	deleted int
+}
+
+func (w *Wrapper) Close() (err error) {
+	for _, h := range w.handles {
+		if c, ok := h.(io.Closer); ok {
+			if e := c.Close(); err == nil {
+				err = e
+			}
+		}
+	}
+	if e := w.Memory.Close(); e != nil {
+		err = e
+	}
+	*w = Wrapper{}
+	return err
+}
+
+func (w *Wrapper) GetHandle(id Ptr_t) any {
+	if id == 0 {
+		return nil
+	}
+	return w.handles[^id]
+}
+
+func (w *Wrapper) DelHandle(id Ptr_t) error {
+	if id == 0 {
+		return nil
+	}
+	a := w.handles[^id]
+	w.handles[^id] = nil
+	if l := Ptr_t(len(w.handles)); l == ^id {
+		w.handles = w.handles[:l-1]
+	} else {
+		w.deleted++
+	}
+	if c, ok := a.(io.Closer); ok {
+		return c.Close()
+	}
+	return nil
+}
+
+func (w *Wrapper) AddHandle(a any) Ptr_t {
+	if a == nil {
+		panic(errutil.NilErr)
+	}
+
+	// Find an empty slot.
+	if w.deleted > cap(w.handles)-len(w.handles) {
+		for id, h := range w.handles {
+			if h == nil {
+				w.deleted--
+				w.handles[id] = a
+				return ^Ptr_t(id)
+			}
+		}
+	}
+
+	// Add a new slot.
+	w.handles = append(w.handles, a)
+	return -Ptr_t(len(w.handles))
+}
+
+func (w *Wrapper) Xmemory() sqlite3_wasm.Memory { return w.Memory }
+
+func (w *Wrapper) Xgo_destroy(pApp int32) { w.DelHandle(Ptr_t(pApp)) }

package/govendor/github.com/ncruces/go-sqlite3/internal/sqlite3_wrap/wrap_sys.go

@@ -0,0 +1,113 @@
+package sqlite3_wrap
+
+import (
+	"io"
+
+	"github.com/ncruces/go-sqlite3/internal/testenv"
+)
+
+const _MAX_NAME = 1e6 // Self-imposed limit for most NUL terminated strings.
+
+func (w *Wrapper) Xexit(c int32) {
+	testenv.Exit(c)
+}
+
+func (w *Wrapper) Xsystem(ptr int32) int32 {
+	if testenv.TB == nil || ptr == 0 {
+		return 0
+	}
+	s := w.ReadString(Ptr_t(ptr), _MAX_NAME)
+	return testenv.System(s)
+}
+
+func (w *Wrapper) Xputs(ptr int32) int32 {
+	if testenv.TB == nil {
+		return -1
+	}
+	s := w.ReadString(Ptr_t(ptr), _MAX_NAME)
+	testenv.WriteString(s)
+	testenv.WriteByte('\n')
+	return 0
+}
+
+func (w *Wrapper) Xfclose(h int32) int32 {
+	if testenv.TB == nil {
+		return -1
+	}
+	if w.DelHandle(Ptr_t(h)) != nil {
+		return -1
+	}
+	return 0
+}
+
+func (w *Wrapper) Xfopen(path, mode int32) int32 {
+	if testenv.TB == nil {
+		return 0
+	}
+	p := w.ReadString(Ptr_t(path), _MAX_NAME)
+	f, err := testenv.FS.Open(p)
+	if err != nil {
+		return 0
+	}
+	return int32(w.AddHandle(f))
+}
+
+func (w *Wrapper) Xfflush(h int32) int32 {
+	if testenv.TB == nil {
+		return -1
+	}
+	return 0
+}
+
+func (w *Wrapper) Xfputc(c, h int32) int32 {
+	if testenv.TB == nil {
+		return -1
+	}
+	if testenv.WriteByte(byte(c)) != nil {
+		return -1
+	}
+	return 0
+}
+
+func (w *Wrapper) Xfwrite(ptr, sz, cnt, h int32) int32 {
+	if testenv.TB == nil {
+		return 0
+	}
+	b := w.Buf[ptr:][:sz*cnt]
+	n, _ := testenv.Write(b)
+	return int32(n / int(sz))
+}
+
+func (w *Wrapper) Xfread(ptr, sz, cnt, h int32) int32 {
+	if testenv.TB == nil {
+		return 0
+	}
+	f := w.GetHandle(Ptr_t(h)).(io.Reader)
+	b := w.Buf[ptr:][:sz*cnt]
+	n, _ := f.Read(b)
+	return int32(n / int(sz))
+}
+
+func (w *Wrapper) Xftell(h int32) int32 {
+	if testenv.TB == nil {
+		return -1
+	}
+	f := w.GetHandle(Ptr_t(h)).(io.Seeker)
+	n, err := f.Seek(0, io.SeekCurrent)
+	if err != nil {
+		return -1
+	}
+	return int32(n)
+}
+
+func (w *Wrapper) Xfseek(h, offset, whence int32) int32 {
+	if testenv.TB == nil {
+		return -1
+	}
+	f := w.GetHandle(Ptr_t(h)).(io.Seeker)
+	_, err := f.Seek(int64(offset), int(whence))
+	if err != nil {
+		return -1
+	}
+	return 0
+}