Debian Codegraph @

unix/syscall_internal_solaris_test.go

raw
1 // Copyright 2022 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4
5 //go:build solaris
6
7 package unix
8
9 import (
10 "fmt"
11 "os"
12 "runtime"
13 "testing"
14 )
15
16 func (e *EventPort) checkInternals(t *testing.T, fds, paths, cookies, pending int) {
17 t.Helper()
18 p, err := e.Pending()
19 if err != nil {
20 t.Fatalf("failed to query how many events are pending")
21 }
22 if len(e.fds) != fds || len(e.paths) != paths || len(e.cookies) != cookies || p != pending {
23 format := "| fds: %d | paths: %d | cookies: %d | pending: %d |"
24 expected := fmt.Sprintf(format, fds, paths, cookies, pending)
25 got := fmt.Sprintf(format, len(e.fds), len(e.paths), len(e.cookies), p)
26 t.Errorf("Internal state mismatch\nfound: %s\nexpected: %s", got, expected)
27 }
28 }
29
30 // getOneRetry wraps EventPort.GetOne which in turn wraps a syscall that can be
31 // interrupted causing us to receive EINTR.
32 // To prevent our tests from flaking, we retry the syscall until it works
33 // rather than get unexpected results in our tests.
34 func getOneRetry(t *testing.T, p *EventPort, timeout *Timespec) (e *PortEvent, err error) {
35 t.Helper()
36 for {
37 e, err = p.GetOne(timeout)
38 if err != EINTR {
39 break
40 }
41 }
42 return e, err
43 }
44
45 // getRetry wraps EventPort.Get which in turn wraps a syscall that can be
46 // interrupted causing us to receive EINTR.
47 // To prevent our tests from flaking, we retry the syscall until it works
48 // rather than get unexpected results in our tests.
49 func getRetry(t *testing.T, p *EventPort, s []PortEvent, min int, timeout *Timespec) (n int, err error) {
50 t.Helper()
51 for {
52 n, err = p.Get(s, min, timeout)
53 if err != EINTR {
54 break
55 }
56 // If we did get EINTR, make sure we got 0 events
57 if n != 0 {
58 t.Fatalf("EventPort.Get returned events on EINTR.\ngot: %d\nexpected: 0", n)
59 }
60 }
61 return n, err
62 }
63
64 // Regression test for DissociatePath returning ENOENT
65 // This test is intended to create a linear worst
66 // case scenario of events being associated and
67 // fired but not consumed before additional
68 // calls to dissociate and associate happen
69 // This needs to be an internal test so that
70 // we can validate the state of the private maps
71 func TestEventPortDissociateAlreadyGone(t *testing.T) {
72 port, err := NewEventPort()
73 if err != nil {
74 t.Fatalf("failed to create an EventPort")
75 }
76 defer port.Close()
77 dir := t.TempDir()
78 tmpfile, err := os.CreateTemp(dir, "eventport")
79 if err != nil {
80 t.Fatalf("unable to create a tempfile: %v", err)
81 }
82 path := tmpfile.Name()
83 stat, err := os.Stat(path)
84 if err != nil {
85 t.Fatalf("unexpected failure to Stat file: %v", err)
86 }
87 err = port.AssociatePath(path, stat, FILE_MODIFIED, "cookie1")
88 if err != nil {
89 t.Fatalf("unexpected failure associating file: %v", err)
90 }
91 // We should have 1 path registered and 1 cookie in the jar
92 port.checkInternals(t, 0, 1, 1, 0)
93 // The path is associated, let's delete it.
94 err = os.Remove(path)
95 if err != nil {
96 t.Fatalf("unexpected failure deleting file: %v", err)
97 }
98 // The file has been deleted, some sort of pending event is probably
99 // queued in the kernel waiting for us to get it AND the kernel is
100 // no longer watching for events on it. BUT... Because we haven't
101 // consumed the event, this API thinks it's still watched:
102 watched := port.PathIsWatched(path)
103 if !watched {
104 t.Errorf("unexpected result from PathIsWatched")
105 }
106 // Ok, let's dissociate the file even before reading the event.
107 // Oh, ENOENT. I guess it's not associated any more
108 err = port.DissociatePath(path)
109 if err != ENOENT {
110 t.Errorf("unexpected result dissociating a seemingly associated path we know isn't: %v", err)
111 }
112 // As established by the return value above, this should clearly be false now:
113 // Narrator voice: in the first version of this API, it wasn't.
114 watched = port.PathIsWatched(path)
115 if watched {
116 t.Errorf("definitively unwatched file still in the map")
117 }
118 // We should have nothing registered, but 1 pending event corresponding
119 // to the cookie in the jar
120 port.checkInternals(t, 0, 0, 1, 1)
121 f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE, 0666)
122 if err != nil {
123 t.Fatalf("creating test file failed: %s", err)
124 }
125 err = f.Close()
126 if err != nil {
127 t.Fatalf("unexpected failure closing file: %v", err)
128 }
129 stat, err = os.Stat(path)
130 if err != nil {
131 t.Fatalf("unexpected failure to Stat file: %v", err)
132 }
133 c := "cookie2" // c is for cookie, that's good enough for me
134 err = port.AssociatePath(path, stat, FILE_MODIFIED, c)
135 if err != nil {
136 t.Errorf("unexpected failure associating file: %v", err)
137 }
138 // We should have 1 registered path and its cookie
139 // as well as a second cookie corresponding to the pending event
140 port.checkInternals(t, 0, 1, 2, 1)
141
142 // Fire another event
143 err = os.Remove(path)
144 if err != nil {
145 t.Fatalf("unexpected failure deleting file: %v", err)
146 }
147 port.checkInternals(t, 0, 1, 2, 2)
148 err = port.DissociatePath(path)
149 if err != ENOENT {
150 t.Errorf("unexpected result dissociating a seemingly associated path we know isn't: %v", err)
151 }
152 // By dissociating this path after deletion we ensure that the paths map is now empty
153 // If we're not careful we could trigger a nil pointer exception
154 port.checkInternals(t, 0, 0, 2, 2)
155
156 f, err = os.OpenFile(path, os.O_WRONLY|os.O_CREATE, 0666)
157 if err != nil {
158 t.Fatalf("creating test file failed: %s", err)
159 }
160 err = f.Close()
161 if err != nil {
162 t.Fatalf("unexpected failure closing file: %v", err)
163 }
164 stat, err = os.Stat(path)
165 if err != nil {
166 t.Fatalf("unexpected failure to Stat file: %v", err)
167 }
168 // Put a seemingly duplicate cookie in the jar to see if we can trigger an incorrect removal from the paths map
169 err = port.AssociatePath(path, stat, FILE_MODIFIED, c)
170 if err != nil {
171 t.Errorf("unexpected failure associating file: %v", err)
172 }
173 port.checkInternals(t, 0, 1, 3, 2)
174
175 // run the garbage collector so that if we messed up it should be painfully clear
176 runtime.GC()
177
178 // Before the fix, this would cause a nil pointer exception
179 e, err := getOneRetry(t, port, nil)
180 if err != nil {
181 t.Errorf("failed to get an event: %v", err)
182 }
183 port.checkInternals(t, 0, 1, 2, 1)
184 if e.Cookie != "cookie1" {
185 t.Errorf(`expected "cookie1", got "%v"`, e.Cookie)
186 }
187 // Make sure that a cookie of the same value doesn't cause removal from the paths map incorrectly
188 e, err = getOneRetry(t, port, nil)
189 if err != nil {
190 t.Errorf("failed to get an event: %v", err)
191 }
192 port.checkInternals(t, 0, 1, 1, 0)
193 if e.Cookie != "cookie2" {
194 t.Errorf(`expected "cookie2", got "%v"`, e.Cookie)
195 }
196
197 err = os.Remove(path)
198 if err != nil {
199 t.Fatalf("unexpected failure deleting file: %v", err)
200 }
201 // Event has fired, but until processed it should still be in the map
202 port.checkInternals(t, 0, 1, 1, 1)
203 e, err = getOneRetry(t, port, nil)
204 if err != nil {
205 t.Errorf("failed to get an event: %v", err)
206 }
207 if e.Cookie != "cookie2" {
208 t.Errorf(`expected "cookie2", got "%v"`, e.Cookie)
209 }
210 // The maps should be empty and there should be no pending events
211 port.checkInternals(t, 0, 0, 0, 0)
212 }
213
214 // Regression test for spuriously triggering a panic about memory mismanagement
215 // that can be triggered by an event processing thread trying to process an event
216 // after a different thread has already called port.Close().
217 // Implemented as an internal test so that we can just simulate the Close()
218 // because if you call close first in the same thread, things work properly
219 // anyway.
220 func TestEventPortGetAfterClose(t *testing.T) {
221 port, err := NewEventPort()
222 if err != nil {
223 t.Fatalf("NewEventPort failed: %v", err)
224 }
225 // Create, associate, and delete 2 files
226 for i := 0; i < 2; i++ {
227 tmpfile, err := os.CreateTemp("", "eventport")
228 if err != nil {
229 t.Fatalf("unable to create tempfile: %v", err)
230 }
231 path := tmpfile.Name()
232 stat, err := os.Stat(path)
233 if err != nil {
234 t.Fatalf("unable to stat tempfile: %v", err)
235 }
236 err = port.AssociatePath(path, stat, FILE_MODIFIED, nil)
237 if err != nil {
238 t.Fatalf("unable to AssociatePath tempfile: %v", err)
239 }
240 err = os.Remove(path)
241 if err != nil {
242 t.Fatalf("unable to Remove tempfile: %v", err)
243 }
244 }
245 n, err := port.Pending()
246 if err != nil {
247 t.Errorf("Pending failed: %v", err)
248 }
249 if n != 2 {
250 t.Errorf("expected 2 pending events, got %d", n)
251 }
252 // Simulate a close from a different thread
253 port.fds = nil
254 port.paths = nil
255 port.cookies = nil
256 // Ensure that we get back reasonable errors rather than panic
257 _, err = getOneRetry(t, port, nil)
258 if err == nil || err.Error() != "this EventPort is already closed" {
259 t.Errorf("didn't receive expected error of 'this EventPort is already closed'; got: %v", err)
260 }
261 events := make([]PortEvent, 2)
262 n, err = getRetry(t, port, events, 1, nil)
263 if n != 0 {
264 t.Errorf("expected to get back 0 events, got %d", n)
265 }
266 if err == nil || err.Error() != "this EventPort is already closed" {
267 t.Errorf("didn't receive expected error of 'this EventPort is already closed'; got: %v", err)
268 }
269 }