├── .github
    └── workflows
    │   └── go.yml
├── .gitignore
├── .golangci.yaml
├── LICENSE
├── README.md
├── example_c_iovec_test.go
├── example_go_iovec_test.go
├── go.mod
├── go.sum
├── internal
    └── testhelper
    │   └── testhelper.go
├── ptrguard.go
├── ptrguard_leakpanic_test.go
├── ptrguard_test.go
└── runtime_hacks.go


/.github/workflows/go.yml:
--------------------------------------------------------------------------------
 1 | name: CI
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ master ]
 6 |   pull_request:
 7 |     branches: [ master ]
 8 | 
 9 | jobs:
10 | 
11 |   build:
12 |     runs-on: ubuntu-latest
13 |     strategy:
14 |       matrix:
15 |         go: [ '1.13', '1.17' ]
16 |     steps:
17 |     - uses: actions/checkout@v2
18 | 
19 |     - name: Set up Go
20 |       uses: actions/setup-go@v2
21 |       with:
22 |         go-version: ${{ matrix.go }}
23 | 
24 |     - name: Run golangci-lint
25 |       uses: golangci/golangci-lint-action@v2
26 |       with:
27 |         # version of golangci-lint to use in form of v1.2 or v1.2.3 or `latest` to use the latest version
28 |         version: latest
29 |         # golangci-lint command line arguments
30 |         #args: # optional, default is
31 |         # golangci-lint working directory, default is project root
32 |         #working-directory: # optional
33 |         # the token is used for fetching patch of a pull request to show only new issues
34 |         #github-token: # default is ${{ github.token }}
35 |         # if set to true and the action runs on a pull request - the action outputs only newly found issues
36 |         #only-new-issues:
37 |         # if set to true then action uses pre-installed Go
38 |         skip-go-installation: true
39 |         # if set to true then the action don't cache or restore ~/go/pkg.
40 |         #skip-pkg-cache:
41 |         # if set to true then the action don't cache or restore ~/.cache/go-build.
42 |         #skip-build-cache:
43 | 
44 |     - name: Build
45 |       run: go build -v
46 | 
47 |     - name: Test
48 |       run: go test -v
49 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Binaries for programs and plugins
 2 | *.exe
 3 | *.exe~
 4 | *.dll
 5 | *.so
 6 | *.dylib
 7 | 
 8 | # Test binary, built with `go test -c`
 9 | *.test
10 | 
11 | # Output of the go coverage tool, specifically when used with LiteIDE
12 | *.out
13 | 
14 | # Dependency directories (remove the comment below to include it)
15 | # vendor/
16 | 


--------------------------------------------------------------------------------
/.golangci.yaml:
--------------------------------------------------------------------------------
 1 | linters:
 2 |   enable-all: true
 3 |   disable:
 4 |   # deprecated linters
 5 |     - golint
 6 |     - scopelint
 7 |     - maligned
 8 |     - interfacer
 9 |   # disabled linters
10 |     - wsl
11 |     - nlreturn
12 |     - gochecknoglobals
13 |     - paralleltest
14 |     - exhaustivestruct
15 | 
16 | issues:
17 |   exclude-use-default: false
18 |   exclude:
19 |     - "^G103:"
20 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Sven Anderson
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # PtrGuard
 2 | [![Build Status](https://github.com/ansiwen/ptrguard/actions/workflows/go.yml/badge.svg)](https://github.com/ansiwen/ptrguard/actions)
 3 | [![Go Reference](https://pkg.go.dev/badge/github.com/ansiwen/ptrguard.svg)](https://pkg.go.dev/github.com/ansiwen/ptrguard)
 4 | 
 5 | PtrGuard is a small Go package that allows to pin objects referenced by a Go
 6 | pointer (that is pointing to memory allocated by the Go runtime) so that it will
 7 | not be touched by the garbage collector. This is done by creating a `Pinner`
 8 | object that has a `Pin()` method, which accepts a pointer of any type and pins
 9 | the referenced object, until the `Unpin()` method of the same `Pinner` is
10 | called. A `Pinner` can be used to pin more than one object, in which case
11 | `Unpin()` releases all the pinned objects of a `Pinner`.
12 | 
13 | Go pointers to pinned objects can either be directly stored in C memory with the
14 | `Store()` method, or are allowed to be contained in Go memory that is passed to
15 | C functions, which both usually violates the [pointer passing
16 | rules](https://golang.org/cmd/cgo/#hdr-Passing_pointers). In the second case you
17 | might need the `NoCheck()` helper function to call the C function in a context,
18 | where the cgocheck debug feature is disabled. This is necessary because PtrGuard
19 | doesn't have any possibility to tell cgocheck, that certain pointers are pinned.
20 | 
21 | ## Example
22 | Let's say we want to use a C API that uses [vectored
23 | I/O](https://en.wikipedia.org/wiki/Vectored_I/O), like the
24 | [`readv()`](https://pubs.opengroup.org/onlinepubs/000095399/functions/readv.html)
25 | POSIX system call, in order to read data into an array of buffers. Because we
26 | want to avoid making a copy of the data, we want to read directly into Go
27 | buffers. The pointer passing rules wouldn't allow that, because
28 | * either we can allocate the buffer array in C memory, but then we can't store
29 |   the pointers of the Go buffers in it. (Storing Go pointers in C memory is
30 |   forbidden.)
31 | * or we would allocate the buffer array in Go memory and store the Go buffers in
32 |   it. But then we can't pass the pointer to that buffer array to a C function.
33 |   (Passing a Go pointer that points to memory containing other Go pointers to a
34 |   C function is forbidden.)
35 | 
36 | With PtrGuard both is still possible. (See examples.)
37 | 


--------------------------------------------------------------------------------
/example_c_iovec_test.go:
--------------------------------------------------------------------------------
 1 | package ptrguard_test
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"math"
 6 | 
 7 | 	"github.com/ansiwen/ptrguard"
 8 | 	C "github.com/ansiwen/ptrguard/internal/testhelper"
 9 | )
10 | 
11 | // Example how to use PtrGuard with a C allocated iovec array.
12 | func Example_cAllocatedIovec() {
13 | 	var buffers [][]byte
14 | 	for i := 2; i < 12; i += 3 {
15 | 		buffers = append(buffers, make([]byte, i))
16 | 	}
17 | 	numberOfBuffers := len(buffers)
18 | 
19 | 	cPtr := C.Malloc(C.SizeOfIovec * uintptr(len(buffers)))
20 | 	defer C.Free(cPtr)
21 | 	// This is a trick to create a slice on top of the C allocated array, for
22 | 	// easier and safer access.
23 | 	iovec := (*[math.MaxInt32]C.Iovec)(cPtr)[:numberOfBuffers:numberOfBuffers]
24 | 
25 | 	var pinner ptrguard.Pinner
26 | 	defer pinner.Unpin()
27 | 	for i := range iovec {
28 | 		bufferPtr := &buffers[i][0]
29 | 		pinner.Pin(bufferPtr).Store(&iovec[i].Base)
30 | 		iovec[i].Len = C.Int(len(buffers[i]))
31 | 	}
32 | 
33 | 	C.FillBuffersWithX(&iovec[0], len(iovec))
34 | 
35 | 	for i := range buffers {
36 | 		fmt.Println(string(buffers[i]))
37 | 	}
38 | 	// Output:
39 | 	// XX
40 | 	// XXXXX
41 | 	// XXXXXXXX
42 | 	// XXXXXXXXXXX
43 | }
44 | 


--------------------------------------------------------------------------------
/example_go_iovec_test.go:
--------------------------------------------------------------------------------
 1 | package ptrguard_test
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"unsafe"
 6 | 
 7 | 	"github.com/ansiwen/ptrguard"
 8 | 	C "github.com/ansiwen/ptrguard/internal/testhelper"
 9 | )
10 | 
11 | // Example how to use PtrGuard with a Go allocated iovec slice.
12 | func Example_goAllocatedIovec() {
13 | 	var buffers [][]byte
14 | 	for i := 2; i < 12; i += 3 {
15 | 		buffers = append(buffers, make([]byte, i))
16 | 	}
17 | 
18 | 	iovec := make([]C.Iovec, len(buffers))
19 | 
20 | 	var pinner ptrguard.Pinner
21 | 	defer pinner.Unpin()
22 | 	for i := range iovec {
23 | 		bufferPtr := &buffers[i][0]
24 | 		pinner.Pin(bufferPtr)
25 | 		iovec[i].Base = unsafe.Pointer(bufferPtr)
26 | 		iovec[i].Len = C.Int(len(buffers[i]))
27 | 	}
28 | 
29 | 	ptrguard.NoCheck(func() {
30 | 		C.FillBuffersWithX(&iovec[0], len(iovec))
31 | 	})
32 | 
33 | 	for i := range buffers {
34 | 		fmt.Println(string(buffers[i]))
35 | 	}
36 | 	// Output:
37 | 	// XX
38 | 	// XXXXX
39 | 	// XXXXXXXX
40 | 	// XXXXXXXXXXX
41 | }
42 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
1 | module github.com/ansiwen/ptrguard
2 | 
3 | go 1.13
4 | 
5 | require github.com/stretchr/testify v1.7.0
6 | 


--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
 1 | github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 2 | github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 3 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 4 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 5 | github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 6 | github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 7 | github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 8 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 9 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
10 | gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
11 | gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
12 | 


--------------------------------------------------------------------------------
/internal/testhelper/testhelper.go:
--------------------------------------------------------------------------------
 1 | // package testhelper
 2 | package testhelper
 3 | 
 4 | /*
 5 | #include <stdlib.h>
 6 | 
 7 | void dummyCall(void* p) {}
 8 | 
 9 | typedef struct {
10 | 	void* Base;
11 | 	int Len;
12 | } iovec;
13 | 
14 | inline void fillBufsWithX(iovec* bufs, int n) {
15 | 	for (int i = 0; i<n; ++i) {
16 | 		for (int j = 0; j<bufs[i].Len ; ++j) {
17 | 			((char*)(bufs[i].Base))[j] = 'X';
18 | 		}
19 | 	}
20 | }
21 | */
22 | import "C"
23 | 
24 | import (
25 | 	"unsafe"
26 | )
27 | 
28 | // Iovec ...
29 | type Iovec C.iovec
30 | 
31 | // SizeOfIovec ...
32 | const SizeOfIovec = C.sizeof_iovec
33 | 
34 | // Int ...
35 | func Int(i int) C.int {
36 | 	return C.int(i)
37 | }
38 | 
39 | // Malloc ...
40 | func Malloc(n uintptr) unsafe.Pointer {
41 | 	return C.malloc(C.size_t(n))
42 | }
43 | 
44 | // Free ...
45 | func Free(p unsafe.Pointer) {
46 | 	C.free(p)
47 | }
48 | 
49 | // DummyCCall ...
50 | func DummyCCall(p unsafe.Pointer) {
51 | 	C.dummyCall(p)
52 | }
53 | 
54 | // FillBuffersWithX ...
55 | func FillBuffersWithX(iovec *Iovec, n int) {
56 | 	C.fillBufsWithX((*C.iovec)(iovec), C.int(n))
57 | }
58 | 


--------------------------------------------------------------------------------
/ptrguard.go:
--------------------------------------------------------------------------------
  1 | // Package ptrguard allows to pin a Go object (in memory allocated by the Go
  2 | // runtime), so that it will not be touched by the garbage collector until it is
  3 | // unpinned again.
  4 | package ptrguard
  5 | 
  6 | import (
  7 | 	"fmt"
  8 | 	"reflect"
  9 | 	"runtime"
 10 | 	"sync"
 11 | 	"unsafe"
 12 | )
 13 | 
 14 | // Pinner can pin Go objects (in memory allocated by Go runtime) with the Pin()
 15 | // method. A pinned pointer to these objects can be stored in C memory
 16 | // (allocated by malloc) with the `Store()` method. All pinned objects of a
 17 | // Pinner can be unpinned with the `Unpin()` method.
 18 | type Pinner struct {
 19 | 	*instance
 20 | }
 21 | 
 22 | // Pinned pointer that can be stored with the Store() method.
 23 | type Pinned struct {
 24 | 	ptr  unsafe.Pointer
 25 | 	data *data
 26 | }
 27 | 
 28 | // Pin the Go object referenced by pointer and return a Pinned value. The
 29 | // pointer must be a pointer of any type or unsafe.Pointer, otherwise Pin() will
 30 | // panic. The object will not be touched by the garbage collector until the
 31 | // `Unpin()` method is called. Therefore pinned pointers to this object can be
 32 | // directly stored in C memory with the `Store()` method or can be contained in
 33 | // Go memory passed to C functions, which usually violates the pointer passing
 34 | // rules[1].
 35 | //
 36 | // [1] https://golang.org/cmd/cgo/#hdr-Passing_pointers
 37 | func (p *Pinner) Pin(pointer interface{}) *Pinned {
 38 | 	if p.instance == nil {
 39 | 		p.instance = &instance{}
 40 | 		runtime.SetFinalizer(p.instance, func(i *instance) {
 41 | 			if i.data != nil {
 42 | 				leakPanic()
 43 | 			}
 44 | 		})
 45 | 	}
 46 | 	if p.data == nil {
 47 | 		p.data = &data{}
 48 | 		p.release.Lock()
 49 | 	}
 50 | 	data := p.data
 51 | 	ptr := getPtr(pointer)
 52 | 	var pinned sync.Mutex
 53 | 	pinned.Lock()
 54 | 	// Start a background go routine that lives until Unpin() is called. This
 55 | 	// calls a special function that makes sure the garbage collector doesn't
 56 | 	// touch ptr and then waits until it receives the "release" signal, after
 57 | 	// which it exits.
 58 | 	data.wg.Add(1)
 59 | 	go func() {
 60 | 		pinUntilRelease(&pinned, &data.release, uintptr(ptr))
 61 | 		data.wg.Done()
 62 | 	}()
 63 | 	pinned.Lock() // wait for the "pinned" signal from the go routine.
 64 | 	return &Pinned{ptr, data}
 65 | }
 66 | 
 67 | // Unpin all pinned objects of the Pinner and zero all memory where the pointer
 68 | // has been stored. Whenever Pin() has been called at least once on a Pinner,
 69 | // Unpin() must be called afterwards on the same Pinner, or the garbage
 70 | // collector thread will panic.
 71 | func (p *Pinner) Unpin() {
 72 | 	unpin(p.instance)
 73 | }
 74 | 
 75 | // Store a pinned pointer at target. Target must be a pointer to a pointer of
 76 | // any type or a pointer to unsafe.Pointer, otherwise Store() panics.
 77 | func (p *Pinned) Store(target interface{}) {
 78 | 	ptrPtr := getPtrPtr(target)
 79 | 	*hiddenPtr(ptrPtr) = *hiddenPtr(&p.ptr)
 80 | 	p.data.add(ptrPtr)
 81 | }
 82 | 
 83 | // NoCheck temporarily disables cgocheck, which allows passing Go memory
 84 | // containing pinned Go pointers to a C function. Since this is a global
 85 | // setting, and if you are making C calls in parallel, theoretically it could
 86 | // happen that cgocheck is also disabled for some other C calls. If this is an
 87 | // issue, it is also possible to shadow the cgocheck call instead with this code
 88 | // line
 89 | //   _cgoCheckPointer := func(interface{}, interface{}) {}
 90 | // right before the C function call.
 91 | func NoCheck(f func()) {
 92 | 	cgocheckOff()
 93 | 	f()
 94 | 	cgocheckOn()
 95 | }
 96 | 
 97 | type instance struct {
 98 | 	*data
 99 | }
100 | 
101 | type data struct {
102 | 	release sync.RWMutex
103 | 	wg      sync.WaitGroup
104 | 	refs
105 | }
106 | 
107 | func unpin(p *instance) {
108 | 	if p == nil || p.data == nil {
109 | 		return
110 | 	}
111 | 	p.refs.clear()
112 | 	p.release.Unlock() // broadcast "release" to all go routines
113 | 	p.wg.Wait()        // wait for all pinned pointers to be released
114 | 	p.data = nil
115 | }
116 | 
117 | type refs struct {
118 | 	cPtr []*unsafe.Pointer
119 | }
120 | 
121 | func (r *refs) add(target *unsafe.Pointer) {
122 | 	r.cPtr = append(r.cPtr, target)
123 | }
124 | 
125 | func (r *refs) clear() {
126 | 	for i := range r.cPtr {
127 | 		*r.cPtr[i] = nil
128 | 		r.cPtr[i] = nil
129 | 	}
130 | 	r.cPtr = nil
131 | }
132 | 
133 | var (
134 | 	cgocheckMtx sync.Mutex
135 | 	cgocheckCnt uint
136 | 	cgocheckOld int32
137 | )
138 | 
139 | func cgocheckOff() {
140 | 	cgocheckMtx.Lock()
141 | 	if cgocheckCnt == 0 {
142 | 		cgocheckOld = *cgocheck
143 | 		*cgocheck = 0
144 | 	}
145 | 	cgocheckCnt++
146 | 	cgocheckMtx.Unlock()
147 | }
148 | 
149 | func cgocheckOn() {
150 | 	cgocheckMtx.Lock()
151 | 	cgocheckCnt--
152 | 	if cgocheckCnt == 0 {
153 | 		*cgocheck = cgocheckOld
154 | 	}
155 | 	cgocheckMtx.Unlock()
156 | }
157 | 
158 | func getPtr(i interface{}) unsafe.Pointer {
159 | 	val := reflect.ValueOf(i)
160 | 	if k := val.Kind(); k == reflect.Ptr || k == reflect.UnsafePointer {
161 | 		return unsafe.Pointer(val.Pointer())
162 | 	}
163 | 	panic(fmt.Sprintf("%s is not a pointer", val.Type()))
164 | }
165 | 
166 | func getPtrPtr(i interface{}) *unsafe.Pointer {
167 | 	val := reflect.ValueOf(i)
168 | 	if k := val.Kind(); k == reflect.Ptr {
169 | 		if k = val.Elem().Kind(); k == reflect.Ptr || k == reflect.UnsafePointer {
170 | 			return (*unsafe.Pointer)(unsafe.Pointer(val.Pointer()))
171 | 		}
172 | 	}
173 | 	panic(fmt.Sprintf("%s is not a pointer to a pointer", val.Type()))
174 | }
175 | 
176 | func hiddenPtr(p *unsafe.Pointer) *[unsafe.Sizeof(unsafe.Pointer(nil))]byte {
177 | 	return (*[unsafe.Sizeof(unsafe.Pointer(nil))]byte)(unsafe.Pointer(p))
178 | }
179 | 
180 | // From https://golang.org/src/cmd/compile/internal/gc/lex.go:
181 | // For the next function declared in the file any uintptr arguments may be
182 | // pointer values converted to uintptr. This directive ensures that the
183 | // referenced allocated object, if any, is retained and not moved until the call
184 | // completes, even though from the types alone it would appear that the object
185 | // is no longer needed during the call. The conversion to uintptr must appear in
186 | // the argument list.
187 | // Also see https://golang.org/cmd/compile/#hdr-Compiler_Directives
188 | 
189 | //go:uintptrescapes
190 | func pinUntilRelease(pinned *sync.Mutex, release *sync.RWMutex, _ uintptr) {
191 | 	pinned.Unlock() // send "pinned" signal to main thread.
192 | 	release.RLock() // wait for "release" broadcast from main thread when
193 | 	//                 unpin() has been called.
194 | }
195 | 
196 | // To be able to test that the GC panics when a pinned pointer is leaking, this
197 | // panic function is a variable, that can be overwritten by a test.
198 | var leakPanic = func() {
199 | 	panic("ptrguard: Found leaking pinned pointer. Forgot to call Unpin()?")
200 | }
201 | 


--------------------------------------------------------------------------------
/ptrguard_leakpanic_test.go:
--------------------------------------------------------------------------------
 1 | package ptrguard // nolint:testpackage
 2 | 
 3 | import (
 4 | 	"runtime"
 5 | 	"testing"
 6 | 	"time"
 7 | 
 8 | 	"github.com/stretchr/testify/assert"
 9 | )
10 | 
11 | func TestLeakPanics(t *testing.T) {
12 | 	assert.Panics(t, leakPanic)
13 | 	leaked := false
14 | 	leakPanic = func() {
15 | 		leaked = true
16 | 	}
17 | 	func() {
18 | 		var pg Pinner
19 | 		defer runtime.KeepAlive(pg)
20 | 	}()
21 | 	runtime.GC()
22 | 	runtime.GC()
23 | 	assert.False(t, leaked)
24 | 	func() {
25 | 		var pg Pinner
26 | 		pg.Pin(&[1]byte{})
27 | 	}()
28 | 	runtime.GC()
29 | 	runtime.GC()
30 | 	assert.Eventually(t, func() bool { return leaked == true },
31 | 		5*time.Second, 10*time.Millisecond)
32 | }
33 | 


--------------------------------------------------------------------------------
/ptrguard_test.go:
--------------------------------------------------------------------------------
  1 | package ptrguard_test
  2 | 
  3 | import (
  4 | 	"runtime"
  5 | 	"testing"
  6 | 	"time"
  7 | 	"unsafe"
  8 | 
  9 | 	"github.com/ansiwen/ptrguard"
 10 | 	. "github.com/ansiwen/ptrguard/internal/testhelper"
 11 | 	"github.com/stretchr/testify/assert"
 12 | )
 13 | 
 14 | const (
 15 | 	ptrSize = unsafe.Sizeof(unsafe.Pointer(nil))
 16 | 	fooBar  = "fooBar"
 17 | )
 18 | 
 19 | type tracer struct {
 20 | 	p *string
 21 | 	b *bool
 22 | }
 23 | 
 24 | func newTracer() tracer {
 25 | 	var b bool
 26 | 	s := "foobar"
 27 | 	runtime.SetFinalizer(&s, func(interface{}) { b = true })
 28 | 	return tracer{&s, &b}
 29 | }
 30 | 
 31 | func TestPin(t *testing.T) {
 32 | 	tr1 := newTracer()
 33 | 	tr2 := newTracer()
 34 | 	cPtr := (*unsafe.Pointer)(Malloc(ptrSize))
 35 | 	defer Free(unsafe.Pointer(cPtr))
 36 | 	func() {
 37 | 		var p ptrguard.Pinner
 38 | 		defer p.Unpin()
 39 | 		p.Pin(tr1.p).Store(cPtr)
 40 | 		assert.Equal(t, unsafe.Pointer(tr1.p), *cPtr)
 41 | 		tr1.p = nil
 42 | 		tr2.p = nil
 43 | 		runtime.GC()
 44 | 		runtime.GC()
 45 | 		assert.False(t, *tr1.b)
 46 | 		assert.True(t, *tr2.b)
 47 | 	}()
 48 | 	runtime.GC()
 49 | 	runtime.GC()
 50 | 	assert.Eventually(t, func() bool { return *tr1.b == true },
 51 | 		5*time.Second, 10*time.Millisecond)
 52 | 	assert.Zero(t, *cPtr)
 53 | }
 54 | 
 55 | func TestReusePinner(t *testing.T) {
 56 | 	tr1 := newTracer()
 57 | 	tr2 := newTracer()
 58 | 	cPtr := (*unsafe.Pointer)(Malloc(ptrSize))
 59 | 	defer Free(unsafe.Pointer(cPtr))
 60 | 	var p ptrguard.Pinner
 61 | 	p.Pin(tr1.p).Store(cPtr)
 62 | 	assert.Equal(t, unsafe.Pointer(tr1.p), *cPtr)
 63 | 	tr1.p = nil
 64 | 	runtime.GC()
 65 | 	runtime.GC()
 66 | 	assert.False(t, *tr1.b)
 67 | 	p.Unpin()
 68 | 	runtime.GC()
 69 | 	runtime.GC()
 70 | 	assert.Eventually(t, func() bool { return *tr1.b == true },
 71 | 		5*time.Second, 10*time.Millisecond)
 72 | 	assert.Zero(t, *cPtr)
 73 | 	p.Pin(tr2.p).Store(cPtr)
 74 | 	assert.Equal(t, unsafe.Pointer(tr2.p), *cPtr)
 75 | 	tr2.p = nil
 76 | 	runtime.GC()
 77 | 	runtime.GC()
 78 | 	assert.False(t, *tr2.b)
 79 | 	p.Unpin()
 80 | 	runtime.GC()
 81 | 	runtime.GC()
 82 | 	assert.Eventually(t, func() bool { return *tr2.b == true },
 83 | 		5*time.Second, 10*time.Millisecond)
 84 | 	assert.Zero(t, *cPtr)
 85 | }
 86 | 
 87 | func TestMultiStore(t *testing.T) {
 88 | 	goPtr := &[1]byte{}
 89 | 	cPtrArr := (*[1024]unsafe.Pointer)(Malloc(ptrSize * 1024))
 90 | 	defer Free(unsafe.Pointer(&cPtrArr[0]))
 91 | 	func() {
 92 | 		var pg ptrguard.Pinner
 93 | 		defer pg.Unpin()
 94 | 		pp := pg.Pin(goPtr)
 95 | 		for i := range cPtrArr {
 96 | 			pp.Store(&cPtrArr[i])
 97 | 		}
 98 | 		for i := range cPtrArr {
 99 | 			assert.Equal(t, cPtrArr[i], unsafe.Pointer(goPtr))
100 | 		}
101 | 	}()
102 | 	for i := range cPtrArr {
103 | 		assert.Zero(t, cPtrArr[i])
104 | 	}
105 | }
106 | 
107 | func TestMultiPin(t *testing.T) {
108 | 	var trs [1024]tracer
109 | 	for i := range trs {
110 | 		trs[i] = newTracer()
111 | 	}
112 | 	func() {
113 | 		var pg ptrguard.Pinner
114 | 		defer pg.Unpin()
115 | 		for i := range trs {
116 | 			pg.Pin(trs[i].p)
117 | 			trs[i].p = nil
118 | 		}
119 | 		runtime.GC()
120 | 		runtime.GC()
121 | 		for i := range trs {
122 | 			assert.False(t, *trs[i].b)
123 | 		}
124 | 	}()
125 | 	runtime.GC()
126 | 	runtime.GC()
127 | 	assert.Eventually(t, func() bool { return *trs[len(trs)-1].b == true },
128 | 		5*time.Second, 10*time.Millisecond)
129 | 	for i := range trs {
130 | 		assert.True(t, *trs[i].b)
131 | 	}
132 | }
133 | 
134 | func TestNoCheck(t *testing.T) {
135 | 	s := fooBar
136 | 	goPtr := (unsafe.Pointer)(&s)
137 | 	goPtrPtr := (unsafe.Pointer)(&goPtr)
138 | 	assert.Panics(t,
139 | 		func() {
140 | 			DummyCCall(goPtrPtr)
141 | 		},
142 | 		"Please run tests with GODEBUG=cgocheck=2",
143 | 	)
144 | 	assert.NotPanics(t,
145 | 		func() {
146 | 			ptrguard.NoCheck(func() {
147 | 				DummyCCall(goPtrPtr)
148 | 			})
149 | 		},
150 | 	)
151 | 	assert.Panics(t,
152 | 		func() {
153 | 			DummyCCall(goPtrPtr)
154 | 		},
155 | 		"Please run tests with GODEBUG=cgocheck=2",
156 | 	)
157 | 	assert.NotPanics(t,
158 | 		func() {
159 | 			ptrguard.NoCheck(func() {
160 | 				DummyCCall(goPtrPtr)
161 | 			})
162 | 		},
163 | 	)
164 | }
165 | 
166 | func TestUnintialized(t *testing.T) {
167 | 	var pp ptrguard.Pinner
168 | 	assert.NotPanics(t,
169 | 		func() {
170 | 			pp.Unpin()
171 | 			pp.Unpin()
172 | 		},
173 | 	)
174 | }
175 | 
176 | func TestDoubleUnpin(t *testing.T) {
177 | 	s := fooBar
178 | 	var pp ptrguard.Pinner
179 | 	pp.Pin(&s)
180 | 	assert.NotPanics(t,
181 | 		func() {
182 | 			pp.Unpin()
183 | 			pp.Unpin()
184 | 		},
185 | 	)
186 | }
187 | 
188 | func TestPinNonPointerPanics(t *testing.T) {
189 | 	s := []byte("string")
190 | 	var pg ptrguard.Pinner
191 | 	defer pg.Unpin()
192 | 	assert.NotPanics(t,
193 | 		func() {
194 | 			pg.Pin(&s)
195 | 		},
196 | 	)
197 | 	assert.NotPanics(t,
198 | 		func() {
199 | 			pg.Pin(unsafe.Pointer(&s))
200 | 		},
201 | 	)
202 | 	assert.Panics(t,
203 | 		func() {
204 | 			pg.Pin(s)
205 | 		},
206 | 	)
207 | }
208 | 
209 | func TestStoreToNonPtrPtrPanics(t *testing.T) {
210 | 	s := []byte("string")
211 | 	var p1 unsafe.Pointer
212 | 	var p2 *byte
213 | 	var i uintptr
214 | 	var pg ptrguard.Pinner
215 | 	defer pg.Unpin()
216 | 	assert.NotPanics(t,
217 | 		func() {
218 | 			pg.Pin(&s).Store(&p1)
219 | 		},
220 | 	)
221 | 	assert.NotPanics(t,
222 | 		func() {
223 | 			pg.Pin(&s).Store(&p2)
224 | 		},
225 | 	)
226 | 	assert.Panics(t,
227 | 		func() {
228 | 			pg.Pin(&s).Store(&i)
229 | 		},
230 | 	)
231 | 	assert.Panics(t,
232 | 		func() {
233 | 			pg.Pin(&s).Store(unsafe.Pointer(&i))
234 | 		},
235 | 	)
236 | 	assert.Panics(t,
237 | 		func() {
238 | 			pg.Pin(&s).Store(i)
239 | 		},
240 | 	)
241 | }
242 | 


--------------------------------------------------------------------------------
/runtime_hacks.go:
--------------------------------------------------------------------------------
 1 | package ptrguard
 2 | 
 3 | import _ "unsafe" // enable go:linkname
 4 | 
 5 | type _dbgVar struct {
 6 | 	name  string
 7 | 	value *int32
 8 | }
 9 | 
10 | //go:linkname _dbgvars runtime.dbgvars
11 | var _dbgvars []_dbgVar
12 | 
13 | var cgocheck = func() *int32 {
14 | 	for i := range _dbgvars {
15 | 		if _dbgvars[i].name == "cgocheck" {
16 | 			return _dbgvars[i].value
17 | 		}
18 | 	}
19 | 	panic("Couln't find cgocheck debug variable")
20 | }()
21 | 


--------------------------------------------------------------------------------