|
66
|
1 // Copyright 2009,2010 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 // Darwin system calls.
|
|
|
6 // This file is compiled as ordinary Go code,
|
|
|
7 // but it is also input to mksyscall,
|
|
|
8 // which parses the //sys lines and generates system call stubs.
|
|
|
9 // Note that sometimes we use a lowercase //sys name and wrap
|
|
|
10 // it in our own nicer implementation, either here or in
|
|
|
11 // syscall_bsd.go or syscall_unix.go.
|
|
|
12
|
|
|
13 package unix
|
|
|
14
|
|
|
15 import (
|
|
|
16 "fmt"
|
|
|
17 "runtime"
|
|
|
18 "syscall"
|
|
|
19 "unsafe"
|
|
|
20 )
|
|
|
21
|
|
|
22 // SockaddrDatalink implements the Sockaddr interface for AF_LINK type sockets.
|
|
|
23 type SockaddrDatalink struct {
|
|
|
24 Len uint8
|
|
|
25 Family uint8
|
|
|
26 Index uint16
|
|
|
27 Type uint8
|
|
|
28 Nlen uint8
|
|
|
29 Alen uint8
|
|
|
30 Slen uint8
|
|
|
31 Data [12]int8
|
|
|
32 raw RawSockaddrDatalink
|
|
|
33 }
|
|
|
34
|
|
|
35 // SockaddrCtl implements the Sockaddr interface for AF_SYSTEM type sockets.
|
|
|
36 type SockaddrCtl struct {
|
|
|
37 ID uint32
|
|
|
38 Unit uint32
|
|
|
39 raw RawSockaddrCtl
|
|
|
40 }
|
|
|
41
|
|
|
42 func (sa *SockaddrCtl) sockaddr() (unsafe.Pointer, _Socklen, error) {
|
|
|
43 sa.raw.Sc_len = SizeofSockaddrCtl
|
|
|
44 sa.raw.Sc_family = AF_SYSTEM
|
|
|
45 sa.raw.Ss_sysaddr = AF_SYS_CONTROL
|
|
|
46 sa.raw.Sc_id = sa.ID
|
|
|
47 sa.raw.Sc_unit = sa.Unit
|
|
|
48 return unsafe.Pointer(&sa.raw), SizeofSockaddrCtl, nil
|
|
|
49 }
|
|
|
50
|
|
|
51 // SockaddrVM implements the Sockaddr interface for AF_VSOCK type sockets.
|
|
|
52 // SockaddrVM provides access to Darwin VM sockets: a mechanism that enables
|
|
|
53 // bidirectional communication between a hypervisor and its guest virtual
|
|
|
54 // machines.
|
|
|
55 type SockaddrVM struct {
|
|
|
56 // CID and Port specify a context ID and port address for a VM socket.
|
|
|
57 // Guests have a unique CID, and hosts may have a well-known CID of:
|
|
|
58 // - VMADDR_CID_HYPERVISOR: refers to the hypervisor process.
|
|
|
59 // - VMADDR_CID_LOCAL: refers to local communication (loopback).
|
|
|
60 // - VMADDR_CID_HOST: refers to other processes on the host.
|
|
|
61 CID uint32
|
|
|
62 Port uint32
|
|
|
63 raw RawSockaddrVM
|
|
|
64 }
|
|
|
65
|
|
|
66 func (sa *SockaddrVM) sockaddr() (unsafe.Pointer, _Socklen, error) {
|
|
|
67 sa.raw.Len = SizeofSockaddrVM
|
|
|
68 sa.raw.Family = AF_VSOCK
|
|
|
69 sa.raw.Port = sa.Port
|
|
|
70 sa.raw.Cid = sa.CID
|
|
|
71
|
|
|
72 return unsafe.Pointer(&sa.raw), SizeofSockaddrVM, nil
|
|
|
73 }
|
|
|
74
|
|
|
75 func anyToSockaddrGOOS(fd int, rsa *RawSockaddrAny) (Sockaddr, error) {
|
|
|
76 switch rsa.Addr.Family {
|
|
|
77 case AF_SYSTEM:
|
|
|
78 pp := (*RawSockaddrCtl)(unsafe.Pointer(rsa))
|
|
|
79 if pp.Ss_sysaddr == AF_SYS_CONTROL {
|
|
|
80 sa := new(SockaddrCtl)
|
|
|
81 sa.ID = pp.Sc_id
|
|
|
82 sa.Unit = pp.Sc_unit
|
|
|
83 return sa, nil
|
|
|
84 }
|
|
|
85 case AF_VSOCK:
|
|
|
86 pp := (*RawSockaddrVM)(unsafe.Pointer(rsa))
|
|
|
87 sa := &SockaddrVM{
|
|
|
88 CID: pp.Cid,
|
|
|
89 Port: pp.Port,
|
|
|
90 }
|
|
|
91 return sa, nil
|
|
|
92 }
|
|
|
93 return nil, EAFNOSUPPORT
|
|
|
94 }
|
|
|
95
|
|
|
96 // Some external packages rely on SYS___SYSCTL being defined to implement their
|
|
|
97 // own sysctl wrappers. Provide it here, even though direct syscalls are no
|
|
|
98 // longer supported on darwin.
|
|
|
99 const SYS___SYSCTL = SYS_SYSCTL
|
|
|
100
|
|
|
101 // Translate "kern.hostname" to []_C_int{0,1,2,3}.
|
|
|
102 func nametomib(name string) (mib []_C_int, err error) {
|
|
|
103 const siz = unsafe.Sizeof(mib[0])
|
|
|
104
|
|
|
105 // NOTE(rsc): It seems strange to set the buffer to have
|
|
|
106 // size CTL_MAXNAME+2 but use only CTL_MAXNAME
|
|
|
107 // as the size. I don't know why the +2 is here, but the
|
|
|
108 // kernel uses +2 for its own implementation of this function.
|
|
|
109 // I am scared that if we don't include the +2 here, the kernel
|
|
|
110 // will silently write 2 words farther than we specify
|
|
|
111 // and we'll get memory corruption.
|
|
|
112 var buf [CTL_MAXNAME + 2]_C_int
|
|
|
113 n := uintptr(CTL_MAXNAME) * siz
|
|
|
114
|
|
|
115 p := (*byte)(unsafe.Pointer(&buf[0]))
|
|
|
116 bytes, err := ByteSliceFromString(name)
|
|
|
117 if err != nil {
|
|
|
118 return nil, err
|
|
|
119 }
|
|
|
120
|
|
|
121 // Magic sysctl: "setting" 0.3 to a string name
|
|
|
122 // lets you read back the array of integers form.
|
|
|
123 if err = sysctl([]_C_int{0, 3}, p, &n, &bytes[0], uintptr(len(name))); err != nil {
|
|
|
124 return nil, err
|
|
|
125 }
|
|
|
126 return buf[0 : n/siz], nil
|
|
|
127 }
|
|
|
128
|
|
|
129 func direntIno(buf []byte) (uint64, bool) {
|
|
|
130 return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
|
|
|
131 }
|
|
|
132
|
|
|
133 func direntReclen(buf []byte) (uint64, bool) {
|
|
|
134 return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
|
|
|
135 }
|
|
|
136
|
|
|
137 func direntNamlen(buf []byte) (uint64, bool) {
|
|
|
138 return readInt(buf, unsafe.Offsetof(Dirent{}.Namlen), unsafe.Sizeof(Dirent{}.Namlen))
|
|
|
139 }
|
|
|
140
|
|
|
141 func PtraceAttach(pid int) (err error) { return ptrace(PT_ATTACH, pid, 0, 0) }
|
|
|
142 func PtraceDetach(pid int) (err error) { return ptrace(PT_DETACH, pid, 0, 0) }
|
|
|
143
|
|
|
144 //sysnb pipe(p *[2]int32) (err error)
|
|
|
145
|
|
|
146 func Pipe(p []int) (err error) {
|
|
|
147 if len(p) != 2 {
|
|
|
148 return EINVAL
|
|
|
149 }
|
|
|
150 var x [2]int32
|
|
|
151 err = pipe(&x)
|
|
|
152 if err == nil {
|
|
|
153 p[0] = int(x[0])
|
|
|
154 p[1] = int(x[1])
|
|
|
155 }
|
|
|
156 return
|
|
|
157 }
|
|
|
158
|
|
|
159 func Getfsstat(buf []Statfs_t, flags int) (n int, err error) {
|
|
|
160 var _p0 unsafe.Pointer
|
|
|
161 var bufsize uintptr
|
|
|
162 if len(buf) > 0 {
|
|
|
163 _p0 = unsafe.Pointer(&buf[0])
|
|
|
164 bufsize = unsafe.Sizeof(Statfs_t{}) * uintptr(len(buf))
|
|
|
165 }
|
|
|
166 return getfsstat(_p0, bufsize, flags)
|
|
|
167 }
|
|
|
168
|
|
|
169 func xattrPointer(dest []byte) *byte {
|
|
|
170 // It's only when dest is set to NULL that the OS X implementations of
|
|
|
171 // getxattr() and listxattr() return the current sizes of the named attributes.
|
|
|
172 // An empty byte array is not sufficient. To maintain the same behaviour as the
|
|
|
173 // linux implementation, we wrap around the system calls and pass in NULL when
|
|
|
174 // dest is empty.
|
|
|
175 var destp *byte
|
|
|
176 if len(dest) > 0 {
|
|
|
177 destp = &dest[0]
|
|
|
178 }
|
|
|
179 return destp
|
|
|
180 }
|
|
|
181
|
|
|
182 //sys getxattr(path string, attr string, dest *byte, size int, position uint32, options int) (sz int, err error)
|
|
|
183
|
|
|
184 func Getxattr(path string, attr string, dest []byte) (sz int, err error) {
|
|
|
185 return getxattr(path, attr, xattrPointer(dest), len(dest), 0, 0)
|
|
|
186 }
|
|
|
187
|
|
|
188 func Lgetxattr(link string, attr string, dest []byte) (sz int, err error) {
|
|
|
189 return getxattr(link, attr, xattrPointer(dest), len(dest), 0, XATTR_NOFOLLOW)
|
|
|
190 }
|
|
|
191
|
|
|
192 //sys fgetxattr(fd int, attr string, dest *byte, size int, position uint32, options int) (sz int, err error)
|
|
|
193
|
|
|
194 func Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) {
|
|
|
195 return fgetxattr(fd, attr, xattrPointer(dest), len(dest), 0, 0)
|
|
|
196 }
|
|
|
197
|
|
|
198 //sys setxattr(path string, attr string, data *byte, size int, position uint32, options int) (err error)
|
|
|
199
|
|
|
200 func Setxattr(path string, attr string, data []byte, flags int) (err error) {
|
|
|
201 // The parameters for the OS X implementation vary slightly compared to the
|
|
|
202 // linux system call, specifically the position parameter:
|
|
|
203 //
|
|
|
204 // linux:
|
|
|
205 // int setxattr(
|
|
|
206 // const char *path,
|
|
|
207 // const char *name,
|
|
|
208 // const void *value,
|
|
|
209 // size_t size,
|
|
|
210 // int flags
|
|
|
211 // );
|
|
|
212 //
|
|
|
213 // darwin:
|
|
|
214 // int setxattr(
|
|
|
215 // const char *path,
|
|
|
216 // const char *name,
|
|
|
217 // void *value,
|
|
|
218 // size_t size,
|
|
|
219 // u_int32_t position,
|
|
|
220 // int options
|
|
|
221 // );
|
|
|
222 //
|
|
|
223 // position specifies the offset within the extended attribute. In the
|
|
|
224 // current implementation, only the resource fork extended attribute makes
|
|
|
225 // use of this argument. For all others, position is reserved. We simply
|
|
|
226 // default to setting it to zero.
|
|
|
227 return setxattr(path, attr, xattrPointer(data), len(data), 0, flags)
|
|
|
228 }
|
|
|
229
|
|
|
230 func Lsetxattr(link string, attr string, data []byte, flags int) (err error) {
|
|
|
231 return setxattr(link, attr, xattrPointer(data), len(data), 0, flags|XATTR_NOFOLLOW)
|
|
|
232 }
|
|
|
233
|
|
|
234 //sys fsetxattr(fd int, attr string, data *byte, size int, position uint32, options int) (err error)
|
|
|
235
|
|
|
236 func Fsetxattr(fd int, attr string, data []byte, flags int) (err error) {
|
|
|
237 return fsetxattr(fd, attr, xattrPointer(data), len(data), 0, 0)
|
|
|
238 }
|
|
|
239
|
|
|
240 //sys removexattr(path string, attr string, options int) (err error)
|
|
|
241
|
|
|
242 func Removexattr(path string, attr string) (err error) {
|
|
|
243 // We wrap around and explicitly zero out the options provided to the OS X
|
|
|
244 // implementation of removexattr, we do so for interoperability with the
|
|
|
245 // linux variant.
|
|
|
246 return removexattr(path, attr, 0)
|
|
|
247 }
|
|
|
248
|
|
|
249 func Lremovexattr(link string, attr string) (err error) {
|
|
|
250 return removexattr(link, attr, XATTR_NOFOLLOW)
|
|
|
251 }
|
|
|
252
|
|
|
253 //sys fremovexattr(fd int, attr string, options int) (err error)
|
|
|
254
|
|
|
255 func Fremovexattr(fd int, attr string) (err error) {
|
|
|
256 return fremovexattr(fd, attr, 0)
|
|
|
257 }
|
|
|
258
|
|
|
259 //sys listxattr(path string, dest *byte, size int, options int) (sz int, err error)
|
|
|
260
|
|
|
261 func Listxattr(path string, dest []byte) (sz int, err error) {
|
|
|
262 return listxattr(path, xattrPointer(dest), len(dest), 0)
|
|
|
263 }
|
|
|
264
|
|
|
265 func Llistxattr(link string, dest []byte) (sz int, err error) {
|
|
|
266 return listxattr(link, xattrPointer(dest), len(dest), XATTR_NOFOLLOW)
|
|
|
267 }
|
|
|
268
|
|
|
269 //sys flistxattr(fd int, dest *byte, size int, options int) (sz int, err error)
|
|
|
270
|
|
|
271 func Flistxattr(fd int, dest []byte) (sz int, err error) {
|
|
|
272 return flistxattr(fd, xattrPointer(dest), len(dest), 0)
|
|
|
273 }
|
|
|
274
|
|
|
275 //sys utimensat(dirfd int, path string, times *[2]Timespec, flags int) (err error)
|
|
|
276
|
|
|
277 /*
|
|
|
278 * Wrapped
|
|
|
279 */
|
|
|
280
|
|
|
281 //sys fcntl(fd int, cmd int, arg int) (val int, err error)
|
|
|
282
|
|
|
283 //sys kill(pid int, signum int, posix int) (err error)
|
|
|
284
|
|
|
285 func Kill(pid int, signum syscall.Signal) (err error) { return kill(pid, int(signum), 1) }
|
|
|
286
|
|
|
287 //sys ioctl(fd int, req uint, arg uintptr) (err error)
|
|
|
288
|
|
|
289 func IoctlCtlInfo(fd int, ctlInfo *CtlInfo) error {
|
|
|
290 err := ioctl(fd, CTLIOCGINFO, uintptr(unsafe.Pointer(ctlInfo)))
|
|
|
291 runtime.KeepAlive(ctlInfo)
|
|
|
292 return err
|
|
|
293 }
|
|
|
294
|
|
|
295 // IfreqMTU is struct ifreq used to get or set a network device's MTU.
|
|
|
296 type IfreqMTU struct {
|
|
|
297 Name [IFNAMSIZ]byte
|
|
|
298 MTU int32
|
|
|
299 }
|
|
|
300
|
|
|
301 // IoctlGetIfreqMTU performs the SIOCGIFMTU ioctl operation on fd to get the MTU
|
|
|
302 // of the network device specified by ifname.
|
|
|
303 func IoctlGetIfreqMTU(fd int, ifname string) (*IfreqMTU, error) {
|
|
|
304 var ifreq IfreqMTU
|
|
|
305 copy(ifreq.Name[:], ifname)
|
|
|
306 err := ioctl(fd, SIOCGIFMTU, uintptr(unsafe.Pointer(&ifreq)))
|
|
|
307 return &ifreq, err
|
|
|
308 }
|
|
|
309
|
|
|
310 // IoctlSetIfreqMTU performs the SIOCSIFMTU ioctl operation on fd to set the MTU
|
|
|
311 // of the network device specified by ifreq.Name.
|
|
|
312 func IoctlSetIfreqMTU(fd int, ifreq *IfreqMTU) error {
|
|
|
313 err := ioctl(fd, SIOCSIFMTU, uintptr(unsafe.Pointer(ifreq)))
|
|
|
314 runtime.KeepAlive(ifreq)
|
|
|
315 return err
|
|
|
316 }
|
|
|
317
|
|
|
318 //sys sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS_SYSCTL
|
|
|
319
|
|
|
320 func Uname(uname *Utsname) error {
|
|
|
321 mib := []_C_int{CTL_KERN, KERN_OSTYPE}
|
|
|
322 n := unsafe.Sizeof(uname.Sysname)
|
|
|
323 if err := sysctl(mib, &uname.Sysname[0], &n, nil, 0); err != nil {
|
|
|
324 return err
|
|
|
325 }
|
|
|
326
|
|
|
327 mib = []_C_int{CTL_KERN, KERN_HOSTNAME}
|
|
|
328 n = unsafe.Sizeof(uname.Nodename)
|
|
|
329 if err := sysctl(mib, &uname.Nodename[0], &n, nil, 0); err != nil {
|
|
|
330 return err
|
|
|
331 }
|
|
|
332
|
|
|
333 mib = []_C_int{CTL_KERN, KERN_OSRELEASE}
|
|
|
334 n = unsafe.Sizeof(uname.Release)
|
|
|
335 if err := sysctl(mib, &uname.Release[0], &n, nil, 0); err != nil {
|
|
|
336 return err
|
|
|
337 }
|
|
|
338
|
|
|
339 mib = []_C_int{CTL_KERN, KERN_VERSION}
|
|
|
340 n = unsafe.Sizeof(uname.Version)
|
|
|
341 if err := sysctl(mib, &uname.Version[0], &n, nil, 0); err != nil {
|
|
|
342 return err
|
|
|
343 }
|
|
|
344
|
|
|
345 // The version might have newlines or tabs in it, convert them to
|
|
|
346 // spaces.
|
|
|
347 for i, b := range uname.Version {
|
|
|
348 if b == '\n' || b == '\t' {
|
|
|
349 if i == len(uname.Version)-1 {
|
|
|
350 uname.Version[i] = 0
|
|
|
351 } else {
|
|
|
352 uname.Version[i] = ' '
|
|
|
353 }
|
|
|
354 }
|
|
|
355 }
|
|
|
356
|
|
|
357 mib = []_C_int{CTL_HW, HW_MACHINE}
|
|
|
358 n = unsafe.Sizeof(uname.Machine)
|
|
|
359 if err := sysctl(mib, &uname.Machine[0], &n, nil, 0); err != nil {
|
|
|
360 return err
|
|
|
361 }
|
|
|
362
|
|
|
363 return nil
|
|
|
364 }
|
|
|
365
|
|
|
366 func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
|
|
|
367 if raceenabled {
|
|
|
368 raceReleaseMerge(unsafe.Pointer(&ioSync))
|
|
|
369 }
|
|
|
370 var length = int64(count)
|
|
|
371 err = sendfile(infd, outfd, *offset, &length, nil, 0)
|
|
|
372 written = int(length)
|
|
|
373 return
|
|
|
374 }
|
|
|
375
|
|
|
376 func GetsockoptIPMreqn(fd, level, opt int) (*IPMreqn, error) {
|
|
|
377 var value IPMreqn
|
|
|
378 vallen := _Socklen(SizeofIPMreqn)
|
|
|
379 errno := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
|
|
|
380 return &value, errno
|
|
|
381 }
|
|
|
382
|
|
|
383 func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) {
|
|
|
384 return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
|
|
|
385 }
|
|
|
386
|
|
|
387 // GetsockoptXucred is a getsockopt wrapper that returns an Xucred struct.
|
|
|
388 // The usual level and opt are SOL_LOCAL and LOCAL_PEERCRED, respectively.
|
|
|
389 func GetsockoptXucred(fd, level, opt int) (*Xucred, error) {
|
|
|
390 x := new(Xucred)
|
|
|
391 vallen := _Socklen(SizeofXucred)
|
|
|
392 err := getsockopt(fd, level, opt, unsafe.Pointer(x), &vallen)
|
|
|
393 return x, err
|
|
|
394 }
|
|
|
395
|
|
|
396 func GetsockoptTCPConnectionInfo(fd, level, opt int) (*TCPConnectionInfo, error) {
|
|
|
397 var value TCPConnectionInfo
|
|
|
398 vallen := _Socklen(SizeofTCPConnectionInfo)
|
|
|
399 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
|
|
|
400 return &value, err
|
|
|
401 }
|
|
|
402
|
|
|
403 func SysctlKinfoProc(name string, args ...int) (*KinfoProc, error) {
|
|
|
404 mib, err := sysctlmib(name, args...)
|
|
|
405 if err != nil {
|
|
|
406 return nil, err
|
|
|
407 }
|
|
|
408
|
|
|
409 var kinfo KinfoProc
|
|
|
410 n := uintptr(SizeofKinfoProc)
|
|
|
411 if err := sysctl(mib, (*byte)(unsafe.Pointer(&kinfo)), &n, nil, 0); err != nil {
|
|
|
412 return nil, err
|
|
|
413 }
|
|
|
414 if n != SizeofKinfoProc {
|
|
|
415 return nil, EIO
|
|
|
416 }
|
|
|
417 return &kinfo, nil
|
|
|
418 }
|
|
|
419
|
|
|
420 func SysctlKinfoProcSlice(name string, args ...int) ([]KinfoProc, error) {
|
|
|
421 mib, err := sysctlmib(name, args...)
|
|
|
422 if err != nil {
|
|
|
423 return nil, err
|
|
|
424 }
|
|
|
425
|
|
|
426 // Find size.
|
|
|
427 n := uintptr(0)
|
|
|
428 if err := sysctl(mib, nil, &n, nil, 0); err != nil {
|
|
|
429 return nil, err
|
|
|
430 }
|
|
|
431 if n == 0 {
|
|
|
432 return nil, nil
|
|
|
433 }
|
|
|
434 if n%SizeofKinfoProc != 0 {
|
|
|
435 return nil, fmt.Errorf("sysctl() returned a size of %d, which is not a multiple of %d", n, SizeofKinfoProc)
|
|
|
436 }
|
|
|
437
|
|
|
438 // Read into buffer of that size.
|
|
|
439 buf := make([]KinfoProc, n/SizeofKinfoProc)
|
|
|
440 if err := sysctl(mib, (*byte)(unsafe.Pointer(&buf[0])), &n, nil, 0); err != nil {
|
|
|
441 return nil, err
|
|
|
442 }
|
|
|
443 if n%SizeofKinfoProc != 0 {
|
|
|
444 return nil, fmt.Errorf("sysctl() returned a size of %d, which is not a multiple of %d", n, SizeofKinfoProc)
|
|
|
445 }
|
|
|
446
|
|
|
447 // The actual call may return less than the original reported required
|
|
|
448 // size so ensure we deal with that.
|
|
|
449 return buf[:n/SizeofKinfoProc], nil
|
|
|
450 }
|
|
|
451
|
|
|
452 //sys sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error)
|
|
|
453
|
|
|
454 //sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error)
|
|
|
455 //sys shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error)
|
|
|
456 //sys shmdt(addr uintptr) (err error)
|
|
|
457 //sys shmget(key int, size int, flag int) (id int, err error)
|
|
|
458
|
|
|
459 /*
|
|
|
460 * Exposed directly
|
|
|
461 */
|
|
|
462 //sys Access(path string, mode uint32) (err error)
|
|
|
463 //sys Adjtime(delta *Timeval, olddelta *Timeval) (err error)
|
|
|
464 //sys Chdir(path string) (err error)
|
|
|
465 //sys Chflags(path string, flags int) (err error)
|
|
|
466 //sys Chmod(path string, mode uint32) (err error)
|
|
|
467 //sys Chown(path string, uid int, gid int) (err error)
|
|
|
468 //sys Chroot(path string) (err error)
|
|
|
469 //sys ClockGettime(clockid int32, time *Timespec) (err error)
|
|
|
470 //sys Close(fd int) (err error)
|
|
|
471 //sys Clonefile(src string, dst string, flags int) (err error)
|
|
|
472 //sys Clonefileat(srcDirfd int, src string, dstDirfd int, dst string, flags int) (err error)
|
|
|
473 //sys Dup(fd int) (nfd int, err error)
|
|
|
474 //sys Dup2(from int, to int) (err error)
|
|
|
475 //sys Exchangedata(path1 string, path2 string, options int) (err error)
|
|
|
476 //sys Exit(code int)
|
|
|
477 //sys Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
|
|
|
478 //sys Fchdir(fd int) (err error)
|
|
|
479 //sys Fchflags(fd int, flags int) (err error)
|
|
|
480 //sys Fchmod(fd int, mode uint32) (err error)
|
|
|
481 //sys Fchmodat(dirfd int, path string, mode uint32, flags int) (err error)
|
|
|
482 //sys Fchown(fd int, uid int, gid int) (err error)
|
|
|
483 //sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error)
|
|
|
484 //sys Fclonefileat(srcDirfd int, dstDirfd int, dst string, flags int) (err error)
|
|
|
485 //sys Flock(fd int, how int) (err error)
|
|
|
486 //sys Fpathconf(fd int, name int) (val int, err error)
|
|
|
487 //sys Fsync(fd int) (err error)
|
|
|
488 //sys Ftruncate(fd int, length int64) (err error)
|
|
|
489 //sys Getcwd(buf []byte) (n int, err error)
|
|
|
490 //sys Getdtablesize() (size int)
|
|
|
491 //sysnb Getegid() (egid int)
|
|
|
492 //sysnb Geteuid() (uid int)
|
|
|
493 //sysnb Getgid() (gid int)
|
|
|
494 //sysnb Getpgid(pid int) (pgid int, err error)
|
|
|
495 //sysnb Getpgrp() (pgrp int)
|
|
|
496 //sysnb Getpid() (pid int)
|
|
|
497 //sysnb Getppid() (ppid int)
|
|
|
498 //sys Getpriority(which int, who int) (prio int, err error)
|
|
|
499 //sysnb Getrlimit(which int, lim *Rlimit) (err error)
|
|
|
500 //sysnb Getrusage(who int, rusage *Rusage) (err error)
|
|
|
501 //sysnb Getsid(pid int) (sid int, err error)
|
|
|
502 //sysnb Gettimeofday(tp *Timeval) (err error)
|
|
|
503 //sysnb Getuid() (uid int)
|
|
|
504 //sysnb Issetugid() (tainted bool)
|
|
|
505 //sys Kqueue() (fd int, err error)
|
|
|
506 //sys Lchown(path string, uid int, gid int) (err error)
|
|
|
507 //sys Link(path string, link string) (err error)
|
|
|
508 //sys Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error)
|
|
|
509 //sys Listen(s int, backlog int) (err error)
|
|
|
510 //sys Mkdir(path string, mode uint32) (err error)
|
|
|
511 //sys Mkdirat(dirfd int, path string, mode uint32) (err error)
|
|
|
512 //sys Mkfifo(path string, mode uint32) (err error)
|
|
|
513 //sys Mknod(path string, mode uint32, dev int) (err error)
|
|
|
514 //sys Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error)
|
|
|
515 //sys Open(path string, mode int, perm uint32) (fd int, err error)
|
|
|
516 //sys Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error)
|
|
|
517 //sys Pathconf(path string, name int) (val int, err error)
|
|
|
518 //sys pread(fd int, p []byte, offset int64) (n int, err error)
|
|
|
519 //sys pwrite(fd int, p []byte, offset int64) (n int, err error)
|
|
|
520 //sys read(fd int, p []byte) (n int, err error)
|
|
|
521 //sys Readlink(path string, buf []byte) (n int, err error)
|
|
|
522 //sys Readlinkat(dirfd int, path string, buf []byte) (n int, err error)
|
|
|
523 //sys Rename(from string, to string) (err error)
|
|
|
524 //sys Renameat(fromfd int, from string, tofd int, to string) (err error)
|
|
|
525 //sys Revoke(path string) (err error)
|
|
|
526 //sys Rmdir(path string) (err error)
|
|
|
527 //sys Seek(fd int, offset int64, whence int) (newoffset int64, err error) = SYS_LSEEK
|
|
|
528 //sys Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error)
|
|
|
529 //sys Setegid(egid int) (err error)
|
|
|
530 //sysnb Seteuid(euid int) (err error)
|
|
|
531 //sysnb Setgid(gid int) (err error)
|
|
|
532 //sys Setlogin(name string) (err error)
|
|
|
533 //sysnb Setpgid(pid int, pgid int) (err error)
|
|
|
534 //sys Setpriority(which int, who int, prio int) (err error)
|
|
|
535 //sys Setprivexec(flag int) (err error)
|
|
|
536 //sysnb Setregid(rgid int, egid int) (err error)
|
|
|
537 //sysnb Setreuid(ruid int, euid int) (err error)
|
|
|
538 //sysnb Setrlimit(which int, lim *Rlimit) (err error)
|
|
|
539 //sysnb Setsid() (pid int, err error)
|
|
|
540 //sysnb Settimeofday(tp *Timeval) (err error)
|
|
|
541 //sysnb Setuid(uid int) (err error)
|
|
|
542 //sys Symlink(path string, link string) (err error)
|
|
|
543 //sys Symlinkat(oldpath string, newdirfd int, newpath string) (err error)
|
|
|
544 //sys Sync() (err error)
|
|
|
545 //sys Truncate(path string, length int64) (err error)
|
|
|
546 //sys Umask(newmask int) (oldmask int)
|
|
|
547 //sys Undelete(path string) (err error)
|
|
|
548 //sys Unlink(path string) (err error)
|
|
|
549 //sys Unlinkat(dirfd int, path string, flags int) (err error)
|
|
|
550 //sys Unmount(path string, flags int) (err error)
|
|
|
551 //sys write(fd int, p []byte) (n int, err error)
|
|
|
552 //sys mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
|
|
|
553 //sys munmap(addr uintptr, length uintptr) (err error)
|
|
|
554 //sys readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_READ
|
|
|
555 //sys writelen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_WRITE
|
|
|
556
|
|
|
557 /*
|
|
|
558 * Unimplemented
|
|
|
559 */
|
|
|
560 // Profil
|
|
|
561 // Sigaction
|
|
|
562 // Sigprocmask
|
|
|
563 // Getlogin
|
|
|
564 // Sigpending
|
|
|
565 // Sigaltstack
|
|
|
566 // Ioctl
|
|
|
567 // Reboot
|
|
|
568 // Execve
|
|
|
569 // Vfork
|
|
|
570 // Sbrk
|
|
|
571 // Sstk
|
|
|
572 // Ovadvise
|
|
|
573 // Mincore
|
|
|
574 // Setitimer
|
|
|
575 // Swapon
|
|
|
576 // Select
|
|
|
577 // Sigsuspend
|
|
|
578 // Readv
|
|
|
579 // Writev
|
|
|
580 // Nfssvc
|
|
|
581 // Getfh
|
|
|
582 // Quotactl
|
|
|
583 // Csops
|
|
|
584 // Waitid
|
|
|
585 // Add_profil
|
|
|
586 // Kdebug_trace
|
|
|
587 // Sigreturn
|
|
|
588 // Atsocket
|
|
|
589 // Kqueue_from_portset_np
|
|
|
590 // Kqueue_portset
|
|
|
591 // Getattrlist
|
|
|
592 // Setattrlist
|
|
|
593 // Getdirentriesattr
|
|
|
594 // Searchfs
|
|
|
595 // Delete
|
|
|
596 // Copyfile
|
|
|
597 // Watchevent
|
|
|
598 // Waitevent
|
|
|
599 // Modwatch
|
|
|
600 // Fsctl
|
|
|
601 // Initgroups
|
|
|
602 // Posix_spawn
|
|
|
603 // Nfsclnt
|
|
|
604 // Fhopen
|
|
|
605 // Minherit
|
|
|
606 // Semsys
|
|
|
607 // Msgsys
|
|
|
608 // Shmsys
|
|
|
609 // Semctl
|
|
|
610 // Semget
|
|
|
611 // Semop
|
|
|
612 // Msgctl
|
|
|
613 // Msgget
|
|
|
614 // Msgsnd
|
|
|
615 // Msgrcv
|
|
|
616 // Shm_open
|
|
|
617 // Shm_unlink
|
|
|
618 // Sem_open
|
|
|
619 // Sem_close
|
|
|
620 // Sem_unlink
|
|
|
621 // Sem_wait
|
|
|
622 // Sem_trywait
|
|
|
623 // Sem_post
|
|
|
624 // Sem_getvalue
|
|
|
625 // Sem_init
|
|
|
626 // Sem_destroy
|
|
|
627 // Open_extended
|
|
|
628 // Umask_extended
|
|
|
629 // Stat_extended
|
|
|
630 // Lstat_extended
|
|
|
631 // Fstat_extended
|
|
|
632 // Chmod_extended
|
|
|
633 // Fchmod_extended
|
|
|
634 // Access_extended
|
|
|
635 // Settid
|
|
|
636 // Gettid
|
|
|
637 // Setsgroups
|
|
|
638 // Getsgroups
|
|
|
639 // Setwgroups
|
|
|
640 // Getwgroups
|
|
|
641 // Mkfifo_extended
|
|
|
642 // Mkdir_extended
|
|
|
643 // Identitysvc
|
|
|
644 // Shared_region_check_np
|
|
|
645 // Shared_region_map_np
|
|
|
646 // __pthread_mutex_destroy
|
|
|
647 // __pthread_mutex_init
|
|
|
648 // __pthread_mutex_lock
|
|
|
649 // __pthread_mutex_trylock
|
|
|
650 // __pthread_mutex_unlock
|
|
|
651 // __pthread_cond_init
|
|
|
652 // __pthread_cond_destroy
|
|
|
653 // __pthread_cond_broadcast
|
|
|
654 // __pthread_cond_signal
|
|
|
655 // Setsid_with_pid
|
|
|
656 // __pthread_cond_timedwait
|
|
|
657 // Aio_fsync
|
|
|
658 // Aio_return
|
|
|
659 // Aio_suspend
|
|
|
660 // Aio_cancel
|
|
|
661 // Aio_error
|
|
|
662 // Aio_read
|
|
|
663 // Aio_write
|
|
|
664 // Lio_listio
|
|
|
665 // __pthread_cond_wait
|
|
|
666 // Iopolicysys
|
|
|
667 // __pthread_kill
|
|
|
668 // __pthread_sigmask
|
|
|
669 // __sigwait
|
|
|
670 // __disable_threadsignal
|
|
|
671 // __pthread_markcancel
|
|
|
672 // __pthread_canceled
|
|
|
673 // __semwait_signal
|
|
|
674 // Proc_info
|
|
|
675 // sendfile
|
|
|
676 // Stat64_extended
|
|
|
677 // Lstat64_extended
|
|
|
678 // Fstat64_extended
|
|
|
679 // __pthread_chdir
|
|
|
680 // __pthread_fchdir
|
|
|
681 // Audit
|
|
|
682 // Auditon
|
|
|
683 // Getauid
|
|
|
684 // Setauid
|
|
|
685 // Getaudit
|
|
|
686 // Setaudit
|
|
|
687 // Getaudit_addr
|
|
|
688 // Setaudit_addr
|
|
|
689 // Auditctl
|
|
|
690 // Bsdthread_create
|
|
|
691 // Bsdthread_terminate
|
|
|
692 // Stack_snapshot
|
|
|
693 // Bsdthread_register
|
|
|
694 // Workq_open
|
|
|
695 // Workq_ops
|
|
|
696 // __mac_execve
|
|
|
697 // __mac_syscall
|
|
|
698 // __mac_get_file
|
|
|
699 // __mac_set_file
|
|
|
700 // __mac_get_link
|
|
|
701 // __mac_set_link
|
|
|
702 // __mac_get_proc
|
|
|
703 // __mac_set_proc
|
|
|
704 // __mac_get_fd
|
|
|
705 // __mac_set_fd
|
|
|
706 // __mac_get_pid
|
|
|
707 // __mac_get_lcid
|
|
|
708 // __mac_get_lctx
|
|
|
709 // __mac_set_lctx
|
|
|
710 // Setlcid
|
|
|
711 // Read_nocancel
|
|
|
712 // Write_nocancel
|
|
|
713 // Open_nocancel
|
|
|
714 // Close_nocancel
|
|
|
715 // Wait4_nocancel
|
|
|
716 // Recvmsg_nocancel
|
|
|
717 // Sendmsg_nocancel
|
|
|
718 // Recvfrom_nocancel
|
|
|
719 // Accept_nocancel
|
|
|
720 // Fcntl_nocancel
|
|
|
721 // Select_nocancel
|
|
|
722 // Fsync_nocancel
|
|
|
723 // Connect_nocancel
|
|
|
724 // Sigsuspend_nocancel
|
|
|
725 // Readv_nocancel
|
|
|
726 // Writev_nocancel
|
|
|
727 // Sendto_nocancel
|
|
|
728 // Pread_nocancel
|
|
|
729 // Pwrite_nocancel
|
|
|
730 // Waitid_nocancel
|
|
|
731 // Poll_nocancel
|
|
|
732 // Msgsnd_nocancel
|
|
|
733 // Msgrcv_nocancel
|
|
|
734 // Sem_wait_nocancel
|
|
|
735 // Aio_suspend_nocancel
|
|
|
736 // __sigwait_nocancel
|
|
|
737 // __semwait_signal_nocancel
|
|
|
738 // __mac_mount
|
|
|
739 // __mac_get_mount
|
|
|
740 // __mac_getfsstat
|
