1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
|
// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package poll
import (
"sync/atomic"
"syscall"
"unsafe"
)
type SysFile struct {
// RefCountPtr is a pointer to the reference count of Sysfd.
//
// WASI preview 1 lacks a dup(2) system call. When the os and net packages
// need to share a file/socket, instead of duplicating the underlying file
// descriptor, we instead provide a way to copy FD instances and manage the
// underlying file descriptor with reference counting.
RefCountPtr *int32
// RefCount is the reference count of Sysfd. When a copy of an FD is made,
// it points to the reference count of the original FD instance.
RefCount int32
// Cache for the file type, lazily initialized when Seek is called.
Filetype uint32
// If the file represents a directory, this field contains the current
// readdir position. It is reset to zero if the program calls Seek(0, 0).
Dircookie uint64
// Absolute path of the file, as returned by syscall.PathOpen;
// this is used by Fchdir to emulate setting the current directory
// to an open file descriptor.
Path string
// TODO(achille): it could be meaningful to move isFile from FD to a method
// on this struct type, and expose it as `IsFile() bool` which derives the
// result from the Filetype field. We would need to ensure that Filetype is
// always set instead of being lazily initialized.
}
func (s *SysFile) init() {
if s.RefCountPtr == nil {
s.RefCount = 1
s.RefCountPtr = &s.RefCount
}
}
func (s *SysFile) ref() SysFile {
atomic.AddInt32(s.RefCountPtr, +1)
return SysFile{RefCountPtr: s.RefCountPtr}
}
func (s *SysFile) destroy(fd int) error {
if s.RefCountPtr != nil && atomic.AddInt32(s.RefCountPtr, -1) > 0 {
return nil
}
// We don't use ignoringEINTR here because POSIX does not define
// whether the descriptor is closed if close returns EINTR.
// If the descriptor is indeed closed, using a loop would race
// with some other goroutine opening a new descriptor.
// (The Linux kernel guarantees that it is closed on an EINTR error.)
return CloseFunc(fd)
}
// Copy creates a copy of the FD.
//
// The FD instance points to the same underlying file descriptor. The file
// descriptor isn't closed until all FD instances that refer to it have been
// closed/destroyed.
func (fd *FD) Copy() FD {
return FD{
Sysfd: fd.Sysfd,
SysFile: fd.SysFile.ref(),
IsStream: fd.IsStream,
ZeroReadIsEOF: fd.ZeroReadIsEOF,
isBlocking: fd.isBlocking,
isFile: fd.isFile,
}
}
// dupCloseOnExecOld always errors on wasip1 because there is no mechanism to
// duplicate file descriptors.
func dupCloseOnExecOld(fd int) (int, string, error) {
return -1, "dup", syscall.ENOSYS
}
// Fchdir wraps syscall.Fchdir.
func (fd *FD) Fchdir() error {
if err := fd.incref(); err != nil {
return err
}
defer fd.decref()
return syscall.Chdir(fd.Path)
}
// ReadDir wraps syscall.ReadDir.
// We treat this like an ordinary system call rather than a call
// that tries to fill the buffer.
func (fd *FD) ReadDir(buf []byte, cookie syscall.Dircookie) (int, error) {
if err := fd.incref(); err != nil {
return 0, err
}
defer fd.decref()
for {
n, err := syscall.ReadDir(fd.Sysfd, buf, cookie)
if err != nil {
n = 0
if err == syscall.EAGAIN && fd.pd.pollable() {
if err = fd.pd.waitRead(fd.isFile); err == nil {
continue
}
}
}
// Do not call eofError; caller does not expect to see io.EOF.
return n, err
}
}
func (fd *FD) ReadDirent(buf []byte) (int, error) {
n, err := fd.ReadDir(buf, fd.Dircookie)
if err != nil {
return 0, err
}
if n <= 0 {
return n, nil // EOF
}
// We assume that the caller of ReadDirent will consume the entire buffer
// up to the last full entry, so we scan through the buffer looking for the
// value of the last next cookie.
b := buf[:n]
for len(b) > 0 {
next, ok := direntNext(b)
if !ok {
break
}
size, ok := direntReclen(b)
if !ok {
break
}
if size > uint64(len(b)) {
break
}
fd.Dircookie = syscall.Dircookie(next)
b = b[size:]
}
// Trim a potentially incomplete trailing entry; this is necessary because
// the code in src/os/dir_unix.go does not deal well with partial values in
// calls to direntReclen, etc... and ends up causing an early EOF before all
// directory entries were consumed. ReadDirent is called with a large enough
// buffer (8 KiB) that at least one entry should always fit, tho this seems
// a bit brittle but cannot be addressed without a large change of the
// algorithm in the os.(*File).readdir method.
return n - len(b), nil
}
// Seek wraps syscall.Seek.
func (fd *FD) Seek(offset int64, whence int) (int64, error) {
if err := fd.incref(); err != nil {
return 0, err
}
defer fd.decref()
// syscall.Filetype is a uint8 but we store it as a uint32 in SysFile in
// order to use atomic load/store on the field, which is why we have to
// perform this type conversion.
fileType := syscall.Filetype(atomic.LoadUint32(&fd.Filetype))
if fileType == syscall.FILETYPE_UNKNOWN {
var stat syscall.Stat_t
if err := fd.Fstat(&stat); err != nil {
return 0, err
}
fileType = stat.Filetype
atomic.StoreUint32(&fd.Filetype, uint32(fileType))
}
if fileType == syscall.FILETYPE_DIRECTORY {
// If the file descriptor is opened on a directory, we reset the readdir
// cookie when seeking back to the beginning to allow reusing the file
// descriptor to scan the directory again.
if offset == 0 && whence == 0 {
fd.Dircookie = 0
return 0, nil
} else {
return 0, syscall.EINVAL
}
}
return syscall.Seek(fd.Sysfd, offset, whence)
}
// https://github.com/WebAssembly/WASI/blob/main/legacy/preview1/docs.md#-dirent-record
const sizeOfDirent = 24
func direntReclen(buf []byte) (uint64, bool) {
namelen, ok := direntNamlen(buf)
return sizeOfDirent + namelen, ok
}
func direntNamlen(buf []byte) (uint64, bool) {
return readInt(buf, unsafe.Offsetof(syscall.Dirent{}.Namlen), unsafe.Sizeof(syscall.Dirent{}.Namlen))
}
func direntNext(buf []byte) (uint64, bool) {
return readInt(buf, unsafe.Offsetof(syscall.Dirent{}.Next), unsafe.Sizeof(syscall.Dirent{}.Next))
}
// readInt returns the size-bytes unsigned integer in native byte order at offset off.
func readInt(b []byte, off, size uintptr) (u uint64, ok bool) {
if len(b) < int(off+size) {
return 0, false
}
return readIntLE(b[off:], size), true
}
func readIntLE(b []byte, size uintptr) uint64 {
switch size {
case 1:
return uint64(b[0])
case 2:
_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808
return uint64(b[0]) | uint64(b[1])<<8
case 4:
_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808
return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24
case 8:
_ = b[7] // bounds check hint to compiler; see golang.org/issue/14808
return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |
uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
default:
panic("internal/poll: readInt with unsupported size")
}
}
|
